Tauri 2.0 Mobile IPC Zero-Copy Binary Telemetry Transfer Boundary

--- description: Tauri 2.0 Mobile IPC Zero-Copy Binary Telemetry Transfer Boundary - Enforces zero-copy ArrayBuffer semantics and dedicated binary IPC channels for high-frequency sensor and telemetry streams crossing the Rust-to-WebView mobile boundary. Eliminates Base64/JSON serialization thrashing that causes JNI local reference table exhaustion on Android, WebKit IPC pipe stalls on iOS, and mobile OS Out-Of-Memory (OOM) watchdog terminations. 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/tauri2-mobile-ipc-zero-copy-arraybuffer-guardrail" --- # Tauri 2.0 Mobile IPC Zero-Copy Binary Telemetry Transfer Boundary > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Serializing High-Frequency Binary Streams into JSON Arrays or Base64 Strings Across Mobile IPC ## System Constraints You are a Principal Mobile Architect enforcing zero-copy IPC transport boundaries in Tauri 2.0 applications. Mandate binary Channel streams and ArrayBuffer views for high-frequency data, rejecting JSON and Base64 bridge payloads. ## Strict Guidelines - Engineers MUST ALWAYS transfer high-frequency (>30Hz) sensor, audio, or telemetry data using `tauri::ipc::Channel<tauri::ipc::InvokeResponseBody>` or raw binary byte buffers (`Uint8Array`) on the frontend. - Engineers MUST NOT serialize numeric sensor arrays into JSON arrays (`number[]` / `Vec<f32>`) or Base64 strings across Tauri IPC commands or events. - Code SHOULD wrap incoming `Uint8Array` payloads into typed views (`Float32Array`, `DataView`) sharing the underlying `ArrayBuffer` without intermediate memory allocations. - Services MUST recycle static destination views or ring buffers when ingesting streaming packets to prevent garbage collection spikes in WebKit/V8. - Components NEVER attach generic `listen()` event listeners to rapid telemetry streams; they MUST establish explicit lifecycle-bound `Channel` instances managed via Tauri 2.0 `invoke` contracts. ## Bad vs Good Implementations ### High-Frequency Telemetry Ingestion Boundary #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Transmitting raw sensor metrics via JSON-encoded events allocates dynamic JS arrays and strings on every message, causing bridge serialization serialization latency, GC pauses, and JNI global reference exhaustion on Android. ```typescript import { listen } from '@tauri-apps/api/event'; interface SensorEvent { readings: number[]; // Triggers JSON deserialization overhead on every tick timestamp: number; } // ANTI-PATTERN: Generic global event listener parsing JSON arrays at 100Hz. // Causes JNI local ref overflows on Android and rapid WebKit memory pressure. export function subscribeToSensors(onUpdate: (data: number[]) => void) { const unlistenPromise = listen<SensorEvent>('sensor-stream', (event) => { // Dynamic allocation of 100s of numbers per frame generates heavy GC thrashing const data = event.payload.readings; onUpdate(data); }); return async () => { const unlisten = await unlistenPromise; unlisten(); }; } ``` #### Production Standard (Correct) > **Standard**: Utilizes Tauri 2.0's typed Channel passing raw Uint8Array payloads. Memory is read directly via a Float32Array view over the incoming ArrayBuffer without JSON parsing or string encoding. ```typescript import { Channel, invoke } from '@tauri-apps/api/core'; // PRODUCTION INVARIANT: Zero-copy Channel pipeline using typed binary views. // Shares memory backed by native WebKit/Android WebView ArrayBuffers directly. export async function subscribeToSensors( onUpdate: (view: Float32Array) => void ): Promise<() => Promise<void>> { const channel = new Channel<Uint8Array>(); channel.onmessage = (rawPacket: Uint8Array) => { // Create a zero-allocation typed view over the existing byte buffer const sampleView = new Float32Array( rawPacket.buffer, rawPacket.byteOffset, rawPacket.byteLength / Float32Array.BYTES_PER_ELEMENT ); onUpdate(sampleView); }; await invoke('start_sensor_stream', { onEvent: channel }); return async () => { await invoke('stop_sensor_stream'); }; } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC Zero-Copy Binary Telemetry Transfer Boundary

Tauri 2.0 Mobile IPC Zero-Copy Binary Telemetry Transfer Boundary defines an industrial-grade behavioral standard for mobile engineering. Enforces zero-copy ArrayBuffer semantics and dedicated binary IPC channels for high-frequency sensor and telemetry streams crossing the Rust-to-WebView mobile boundary. Eliminates Base64/JSON serialization thrashing that causes JNI local reference table exhaustion on Android, WebKit IPC pipe stalls on iOS, and mobile OS Out-Of-Memory (OOM) watchdog terminations. 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: Serializing High-Frequency Binary Streams into JSON Arrays or Base64 Strings Across Mobile IPC 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	Serializing High-Frequency Binary Streams into JSON Arrays or Base64 Strings Across Mobile IPC	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 transfer high-frequency (>30Hz) sensor, audio, or telemetry data using `tauri

Engineers MUST ALWAYS transfer high-frequency (>30Hz) sensor, audio, or telemetry data using `tauri::ipc::Channel<tauri::ipc::InvokeResponseBody>` or raw binary byte buffers (`Uint8Array`) on the frontend.

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.