Tauri 2.0 Zero-Copy IPC Buffer Streaming Barrier for Mobile WebViews

--- description: Tauri 2.0 Zero-Copy IPC Buffer Streaming Barrier for Mobile WebViews - Enforces zero-copy binary streaming protocols for high-frequency Rust-to-WebView IPC in Tauri 2.0 mobile applications. Eliminates main-thread JSON serialization bottlenecks and microtask starvation in mobile WebKit (iOS) and V8 (Android) runtimes by streaming raw binary buffers directly into transferable TypedArrays and dedicated Web Workers. globs: src/**/*.{ts,tsx,js,jsx}, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-zerocopy-ipc-stream-barrier-production-standard" --- # Tauri 2.0 Zero-Copy IPC Buffer Streaming Barrier for Mobile WebViews > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: JSON-serialized high-frequency IPC flooding the mobile WebView main thread with V8/WebKit GC pauses and microtask queue lockup ## System Constraints You are a Principal Engineer enforcing the Tauri 2.0 Zero-Copy IPC Buffer Streaming Barrier. Mandate strict binary-level IPC design, memory-mapped byte transfers, and off-main-thread processing for any IPC frequency exceeding 60 Hz or payload sizes exceeding 64 KB on mobile platforms. ## Strict Guidelines - Engineers MUST ALWAYS use raw binary responses (`tauri::ipc::Response`) or byte channels (`tauri::ipc::Channel<tauri::ipc::InvokeResponseBody>`) in Tauri 2.0 when emitting data exceeding 60 Hz or 64 KB. - Engineers MUST NOT serialize streaming telemetry, audio, sensor, or canvas frame data as JSON strings or arbitrary serde-serialized structs across the IPC boundary on mobile platforms. - Code SHOULD offload incoming `ArrayBuffer` and `Uint8Array` payloads immediately to a dedicated Web Worker via transferable objects (`postMessage(buffer, [buffer])`) to ensure 120 FPS UI thread smoothness in iOS WebKit and Android Chromium. - Services MUST pre-allocate fixed-size ring buffers or typed array views on the frontend instead of instantiating new JavaScript heap objects per incoming IPC frame. - Components NEVER parse base64-encoded strings or execute `JSON.parse` inside Tauri IPC event listeners on the mobile WebView main thread. ## Bad vs Good Implementations ### High-Frequency Stream Ingestion (JSON Serialization vs Zero-Copy Binary IPC) #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Emitting serde-serialized structs over Tauri's default event bus forces mobile WebKit and V8 to continuously allocate, parse, and collect thousands of JSON AST strings per second, leading to UI frame drops, latency spikes, and eventual OOM kills on memory-constrained mobile devices. ```typescript import { listen } from '@tauri-apps/api/event'; interface SensorTelemetry { timestamp: number; values: number[]; } // ANTI-PATTERN: Flooding the mobile WebView main thread with JSON IPC events. // High-frequency JSON parsing triggers severe garbage collection pauses in V8/WebKit. export function subscribeSensorStream(onData: (data: SensorTelemetry) => void): void { listen<SensorTelemetry>('sensor-stream', (event) => { // Microtask queue is flooded; main thread drops frames during scrolling or gestures onData(event.payload); }); } ``` #### Production Standard (Correct) > **Standard**: By returning raw binary payloads via Tauri 2.0 IPC and immediately transferring the resulting ArrayBuffer to a Web Worker using Transferable Objects, the main WebView thread allocates zero intermediate JS objects and bypasses all V8/WebKit JSON deserialization overhead. ```typescript import { invoke } from '@tauri-apps/api/core'; // PRODUCTION INVARIANT: Stream raw binary buffers directly and transfer ownership off-thread export class ZeroCopyStreamConsumer { private worker: Worker; constructor(workerScriptUrl: string) { this.worker = new Worker(workerScriptUrl, { type: 'module' }); } public async ingestBinaryStream(streamId: string): Promise<void> { // Tauri 2.0 raw binary command returns an ArrayBuffer without intermediate JSON parsing const rawBuffer: ArrayBuffer = await invoke('stream_sensor_binary_chunk', { streamId, }); // Zero-copy transfer to dedicated background worker thread; main thread allocation is 0 bytes this.worker.postMessage({ type: 'CHUNK', buffer: rawBuffer }, [rawBuffer]); } public terminate(): void { this.worker.terminate(); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Zero-Copy IPC Buffer Streaming Barrier for Mobile WebViews

Tauri 2.0 Zero-Copy IPC Buffer Streaming Barrier for Mobile WebViews defines an industrial-grade behavioral standard for mobile engineering. Enforces zero-copy binary streaming protocols for high-frequency Rust-to-WebView IPC in Tauri 2.0 mobile applications. Eliminates main-thread JSON serialization bottlenecks and microtask starvation in mobile WebKit (iOS) and V8 (Android) runtimes by streaming raw binary buffers directly into transferable TypedArrays and dedicated Web Workers. 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: JSON-serialized high-frequency IPC flooding the mobile WebView main thread with V8/WebKit GC pauses and microtask queue lockup 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	JSON-serialized high-frequency IPC flooding the mobile WebView main thread with V8/WebKit GC pauses and microtask queue lockup	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 raw binary responses (`tauri

Engineers MUST ALWAYS use raw binary responses (`tauri::ipc::Response`) or byte channels (`tauri::ipc::Channel<tauri::ipc::InvokeResponseBody>`) in Tauri 2.0 when emitting data exceeding 60 Hz or 64 KB.

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.