Tauri 2.0 Multi-Window IPC State Synchronization Mutex Standard

--- description: Tauri 2.0 Multi-Window IPC State Synchronization Mutex Standard - Enforces deterministic, serialized state transitions across isolated Tauri 2.0 webview windows by delegating mutable state mutations exclusively to a Rust-managed transactional state mutex via typed IPC commands. Prohibits direct inter-window communication, optimistic unverified local state overrides, and peer-to-peer event bus broadcasts that induce split-brain conditions. globs: src/**/*.{ts,tsx}, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-2-multiwindow-ipc-state-mutex-standard" --- # Tauri 2.0 Multi-Window IPC State Synchronization Mutex Standard > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Optimistic Frontend State Mutation with Unsynchronized Cross-Window Custom Events ## System Constraints You are a Principal Engineer enforcing the Tauri 2.0 Multi-Window IPC State Synchronization Mutex Standard. You must reject any frontend code that mutates application state locally across multiple webview windows without transactional Rust backend mutex arbitration. Ensure that frontend instances act strictly as read-only projections or command dispatchers, with the Rust core serving as the single linearizable source of truth. ## Strict Guidelines - Engineers MUST ALWAYS dispatch state mutations via @tauri-apps/api/core invoke() to a Rust backend command wrapped in an Arc<tokio::sync::Mutex<T>> or tauri::State<Mutex<T>>. - Engineers MUST NOT utilize window.__TAURI__.event.emit() or Tauri's emit() directly between webview windows for mutable domain state synchronization. - Code SHOULD subscribe to a single canonical backend-emitted event via listen() from @tauri-apps/api/event to update frontend reactive stores after serialized commits. - Services MUST implement transactional sequencing IDs or monotonic version counters on state payloads to reject stale or out-of-order IPC frames. - Components NEVER store unsynchronized local state copies that mutate independently of the Rust-backed state transaction lifecycle. ## Bad vs Good Implementations ### Cross-Window State Mutation Synchronization #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Directly broadcasting local frontend mutations via peer-to-peer events causes race conditions when multiple windows update concurrently, permits split-brain states when windows are created or destroyed, and bypasses backend validation and locking. ```typescript import { emit, listen } from '@tauri-apps/api/event'; import { useState, useEffect } from 'react'; interface DocumentState { title: string; content: string; } export function useSharedDocument() { const [doc, setDoc] = useState<DocumentState>({ title: '', content: '' }); useEffect(() => { // ANTI-PATTERN: Peer-to-peer webview broadcast prone to race conditions, // missed events if a window is detached, and lack of linearizable ordering. const unlisten = listen<DocumentState>('peer-doc-update', (event) => { setDoc(event.payload); }); return () => { unlisten.then((fn) => fn()); }; }, []); const updateContent = async (newContent: string) => { const updated = { ...doc, content: newContent }; // Direct local mutation and raw emit to other webviews setDoc(updated); await emit('peer-doc-update', updated); }; return { doc, updateContent }; } ``` #### Production Standard (Correct) > **Standard**: Frontend state is treated as a read-only projection hydrated from the Rust core. Mutations dispatch typed commands through the Rust mutex with monotonic version guards, preventing split-brain conditions across detached and active windows. ```typescript import { invoke } from '@tauri-apps/api/core'; import { listen } from '@tauri-apps/api/event'; import { useState, useEffect, useRef } from 'react'; interface DocumentState { version: number; title: string; content: string; } export function useSharedDocument() { const [doc, setDoc] = useState<DocumentState>({ version: 0, title: '', content: '' }); const currentVersion = useRef(0); useEffect(() => { let unlistenFn: (() => void) | undefined; const setupSync = async () => { // Invariant: Fetch canonical snapshot on initialization const initial = await invoke<DocumentState>('get_document_state'); currentVersion.current = initial.version; setDoc(initial); // Invariant: Listen only to serialized backend mutex commit events unlistenFn = await listen<DocumentState>('state://document-committed', (event) => { if (event.payload.version > currentVersion.current) { currentVersion.current = event.payload.version; setDoc(event.payload); } }); }; void setupSync(); return () => { if (unlistenFn) unlistenFn(); }; }, []); const updateContent = async (newContent: string): Promise<void> => { // Invariant: Mutex serialization handled in Rust; frontend does not optimistically diverge await invoke<void>('update_document_content', { expectedVersion: currentVersion.current, newContent, }); }; return { doc, updateContent }; } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Multi-Window IPC State Synchronization Mutex Standard

Tauri 2.0 Multi-Window IPC State Synchronization Mutex Standard defines an industrial-grade behavioral standard for frontend engineering. Enforces deterministic, serialized state transitions across isolated Tauri 2.0 webview windows by delegating mutable state mutations exclusively to a Rust-managed transactional state mutex via typed IPC commands. Prohibits direct inter-window communication, optimistic unverified local state overrides, and peer-to-peer event bus broadcasts that induce split-brain conditions. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Optimistic Frontend State Mutation with Unsynchronized Cross-Window Custom Events Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Optimistic Frontend State Mutation with Unsynchronized Cross-Window Custom Events	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS dispatch state mutations via @tauri-apps/api/core invoke() to a Rust backend command wrapped in an Arc<tokio

Engineers MUST ALWAYS dispatch state mutations via @tauri-apps/api/core invoke() to a Rust backend command wrapped in an Arc<tokio::sync::Mutex<T>> or tauri::State<Mutex<T>>.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.