Tauri 2.0 Mobile IPC Buffer Backpressure and Flow Control Standard

--- description: Tauri 2.0 Mobile IPC Buffer Backpressure and Flow Control Standard - Enforces bounded channel backpressure, rate-limiting, and chunked binary transfers over Tauri 2.0 IPC between mobile WebViews and the Rust core. Prevents main UI thread starvation, Android ANR (Application Not Responding) triggers, and iOS watchdog kills caused by bridge queue saturation under high-frequency event bursts. 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-v2-mobile-ipc-backpressure-saturation-standard" --- # Tauri 2.0 Mobile IPC Buffer Backpressure and Flow Control Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Unbounded Fire-and-Forget IPC Event Flooding Across Mobile WebView Bridges ## System Constraints You are a Principal Rust and Mobile Systems Architect enforcing the Tauri 2.0 Mobile IPC Buffer Backpressure Saturation Standard. You must mandate bounded queues, token-based backpressure, and coalesced streaming across the mobile WebView-to-Rust bridge. Unconditionally reject unthrottled invoke loops, unwindowed app_handle.emit calls, and large JSON payloads that risk JNI/WKWebView bridge saturation. ## Strict Guidelines - Engineers MUST ALWAYS use Tauri 2.0 Channels (`tauri::ipc::Channel`) with client-acknowledged flow control or pull-based queries for high-frequency data streams (>60Hz). - Engineers MUST NOT invoke `app_handle.emit()` or `Window::emit()` in tight loops or unbounded background tasks without hardware-paced micro-batching. - Code SHOULD aggregate high-throughput sensor, socket, or telemetry events in Rust ring buffers and flush coalesced batches at display refresh rates (e.g., 60Hz/120Hz via `requestAnimationFrame` timing). - Services MUST transfer large payloads (>64KB) across mobile IPC via typed binary arrays (`Uint8Array` / `Response::binary`) rather than base64 strings or deeply nested serialized JSON structures. - Components NEVER attach direct un-debounced UI event listeners that dispatch individual `invoke()` calls during gestures, scroll interactions, or drag tracking. ## Bad vs Good Implementations ### High-Frequency Stream: Unbounded emit() vs. Tauri 2.0 Backpressured Channel #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Unbounded `emit()` calls flood the native mobile IPC bridge with serialized string events. The mobile OS message pump becomes saturated deserializing payloads on the main thread, leading to dropped frames, lost touch events, and eventual OS watchdog termination. ```typescript import { listen } from '@tauri-apps/api/event'; import { invoke } from '@tauri-apps/api/core'; // ANTI-PATTERN: Direct unbounded event listener under 1000Hz hardware streaming // Floods the iOS WKScriptMessageHandler / Android JNI message loop, freezing the UI export function setupSensorSubscription() { invoke('start_sensor_stream'); // Rust emits 'sensor-data' fire-and-forget at 1kHz return listen<number[]>('sensor-data', (event) => { // UI thread starved during active rendering or gestures updateGraph(event.payload); }); } ``` #### Production Standard (Correct) > **Standard**: Uses Tauri 2.0's `Channel` abstraction with pre-allocated typed arrays and Rust-side time-window coalescing (16ms). Keeps bridge traffic within mobile frame budgets and decouples native sampling frequency from the UI thread's rendering pipeline. ```typescript import { Channel, invoke } from '@tauri-apps/api/core'; interface SensorBatch { timestamps: Float64Array; values: Float32Array; } // PRODUCTION FIX: Tauri 2.0 Channel with pull-based batching and typed arrays export async function setupSensorSubscription(onBatch: (batch: SensorBatch) => void) { const onEvent = new Channel<SensorBatch>(); onEvent.onmessage = (batch) => { // Receives pre-aggregated batches aligned to frame budget requestAnimationFrame(() => { onBatch(batch); }); }; // Passes backpressure-capable Channel; Rust flushes at <= 60Hz intervals await invoke('subscribe_sensor_stream_bounded', { channel: onEvent, batchWindowMs: 16, }); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC Buffer Backpressure and Flow Control Standard

Tauri 2.0 Mobile IPC Buffer Backpressure and Flow Control Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces bounded channel backpressure, rate-limiting, and chunked binary transfers over Tauri 2.0 IPC between mobile WebViews and the Rust core. Prevents main UI thread starvation, Android ANR (Application Not Responding) triggers, and iOS watchdog kills caused by bridge queue saturation under high-frequency event bursts. 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: Unbounded Fire-and-Forget IPC Event Flooding Across Mobile WebView Bridges 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	Unbounded Fire-and-Forget IPC Event Flooding Across Mobile WebView Bridges	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 use Tauri 2.0 Channels (`tauri

Engineers MUST ALWAYS use Tauri 2.0 Channels (`tauri::ipc::Channel`) with client-acknowledged flow control or pull-based queries for high-frequency data streams (>60Hz).

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.