Tauri 2.0 Mobile IPC Binary Channel Streaming Backpressure Standard

--- description: Tauri 2.0 Mobile IPC Binary Channel Streaming Backpressure Standard - Enforces credit-based or acknowledgement-driven windowing on native-to-webview binary streaming channels in Tauri 2.0. Prevents Android Choreographer skipped frames and iOS CADisplayLink hitches caused by unbounded IPC message queues saturating the mobile WebView main execution thread. globs: src/**/*.{ts,tsx}, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri2-mobile-ipc-binary-backpressure-standard" --- # Tauri 2.0 Mobile IPC Binary Channel Streaming Backpressure Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Unbounded native-to-webview binary streaming via unthrottled Tauri 2.0 Channels starving mobile main thread frame loops ## System Constraints You are a Principal Engineer enforcing the Tauri 2.0 Mobile IPC Binary Channel Streaming Backpressure Standard. Mandate that all streaming binary data transferred from Rust to the WebView across the Tauri 2.0 IPC boundary implements strict windowed or ACK-driven backpressure. Forbid unthrottled binary channel streaming that causes Android Choreographer frame drops or iOS WKWebView message port starvation. ## Strict Guidelines - Engineers MUST ALWAYS implement an ACK-based or credit-window protocol for native-to-webview binary streaming across Tauri 2.0 Channels. - Engineers MUST NOT allow native Rust emitters to continuously publish binary ArrayBuffer chunks without awaiting an acknowledgement or credit grant from the frontend. - Code SHOULD yield binary chunk ingestion to the mobile render loop via requestAnimationFrame or scheduler.yield() before dispatching ACK signals back to native Rust. - Services MUST bound the in-flight IPC window size (recommended maximum of 2 to 4 concurrent chunks, sized between 16KB and 64KB on mobile platforms). - Components NEVER ingest high-frequency binary streams directly into React/Solid state without offloading batching to an internal TypedArray buffer. ## Bad vs Good Implementations ### Naive Unbounded Channel vs. ACK-Paced Binary Stream Consumer #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Invoking a streaming channel without a backpressure control mechanism allows the Rust worker thread to flood the mobile WebView IPC bridge faster than the Chromium or WebKit UI thread can drain it. This exhausts IPC buffers, spikes memory, and causes severe Choreographer dropped frames on Android. ```typescript import { Channel, invoke } from '@tauri-apps/api/core'; export async function streamNativeAudioNaive(sessionId: string): Promise<Uint8Array[]> { const onData = new Channel<ArrayBuffer>(); const chunks: Uint8Array[] = []; // ANTI-PATTERN: Rust streams thousands of chunks unpaced. // This floods Android Chromium IPC message queues and causes massive Choreographer frame drops. onData.onmessage = (buffer: ArrayBuffer) => { chunks.push(new Uint8Array(buffer)); }; await invoke('start_unbounded_audio_stream', { sessionId, onData }); return chunks; } ``` #### Production Standard (Correct) > **Standard**: The paced implementation passes an envelope with an identifier and returns an ACK to native Rust only after the chunk is ingested and requestAnimationFrame yields execution back to the mobile display compositor, ensuring frame deadlines are consistently met. ```typescript import { Channel, invoke } from '@tauri-apps/api/core'; interface StreamChunkEnvelope { chunkId: number; payload: ArrayBuffer; isLast: boolean; } export async function streamNativeAudioPaced( sessionId: string, onChunkProcessed: (chunk: Uint8Array) => Promise<void> ): Promise<void> { const onData = new Channel<StreamChunkEnvelope>(); onData.onmessage = async ({ chunkId, payload, isLast }) => { // Ingest payload and yield to Choreographer / UI thread await onChunkProcessed(new Uint8Array(payload)); // Yield to let the mobile compositor render the frame await new Promise((resolve) => requestAnimationFrame(resolve)); // CRITICAL: Send credit ACK back to native to release the next window slice if (!isLast) { await invoke('ack_binary_stream_chunk', { sessionId, chunkId }); } }; await invoke('start_paced_audio_stream', { sessionId, onData, windowSize: 2 }); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC Binary Channel Streaming Backpressure Standard

Tauri 2.0 Mobile IPC Binary Channel Streaming Backpressure Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces credit-based or acknowledgement-driven windowing on native-to-webview binary streaming channels in Tauri 2.0. Prevents Android Choreographer skipped frames and iOS CADisplayLink hitches caused by unbounded IPC message queues saturating the mobile WebView main execution thread. 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 native-to-webview binary streaming via unthrottled Tauri 2.0 Channels starving mobile main thread frame loops 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 native-to-webview binary streaming via unthrottled Tauri 2.0 Channels starving mobile main thread frame loops	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 implement an ACK-based or credit-window protocol for native-to-webview binary streaming across Tauri 2.0 Channels.

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.