Tauri 2.0 Scoped IPC Shared-Memory & ArrayBuffer Streaming Standard

--- description: Tauri 2.0 Scoped IPC Shared-Memory & ArrayBuffer Streaming Standard - Enforces zero-copy, non-blocking binary data transfer between Tauri 2.0 Rust core commands and mobile WebViews (iOS WKWebView and Android WebView). Prohibits base64 stringification and numeric array serialization of binary payloads to eliminate main thread garbage collection pauses and UI frame dropping. Mandates raw IPC binary channels or custom asset protocol streaming for payloads exceeding 64KB. 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-arraybuffer-streaming-standard" --- # Tauri 2.0 Scoped IPC Shared-Memory & ArrayBuffer Streaming Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Base64 or JSON-Array Serialization of Multi-Megabyte Binary Payloads Across Mobile IPC ## System Constraints You are a Principal Mobile Systems Architect enforcing Tauri 2.0 IPC binary streaming standards. Mandate zero-copy binary streaming patterns for any payload transfer above 64KB between Rust and WebViews on iOS and Android. Reject all PRs and generated code that serialize raw byte buffers into JSON number arrays or Base64 strings. Enforce Tauri 2.0 IPC Channel/Response raw binary streaming and custom URI protocols to ensure the mobile UI thread maintains a locked 60/120 FPS. ## Strict Guidelines - Engineers MUST ALWAYS use `tauri::ipc::Response::new(bytes)` in Rust and typed `ArrayBuffer` / `Uint8Array` handlers on the client for binary payloads over 64KB. - Engineers MUST NOT convert `Vec<u8>` into Base64 strings or standard JSON numeric arrays (`serde_json::to_value`) before emitting across the IPC bridge. - Code SHOULD utilize Tauri 2.0 `Channel<ipc::InvokeResponseBody>` or chunked `Channel<Vec<u8>>` when transferring unbounded, continuous, or multi-megabyte streams to prevent buffer bloat. - Services MUST route file/media streaming (>5MB) through Tauri 2.0 custom asset protocol handlers (`register_uri_scheme_protocol`) instead of standard command `invoke` pipelines. - Components NEVER execute synchronous IPC invocations on the mobile UI thread that block JavaScript event loop execution. ## Bad vs Good Implementations ### Tauri 2.0 Mobile Binary IPC Invariant #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Passing binary data as Base64 strings or JSON numeric arrays forces string allocations inside the native-to-web bridge, spikes mobile memory consumption by 33-300%, and triggers heavy GC pauses on the mobile JavaScript thread. ```typescript import { invoke } from '@tauri-apps/api/core'; interface LegacyBinaryPayload { fileName: string; // Anti-pattern: Base64 stringification or Vec<u8> serialized as number[] data: string; } export async function loadDocumentBad(docId: string): Promise<Uint8Array> { // Incurs 33% base64 memory overhead and blocks mobile UI thread during decoding const response = await invoke<LegacyBinaryPayload>('get_document', { docId }); const binaryString = atob(response.data); const bytes = new Uint8Array(binaryString.length); for (let i = 0; i < binaryString.length; i++) { bytes[i] = binaryString.charCodeAt(i); } return bytes; } ``` #### Production Standard (Correct) > **Standard**: Tauri 2.0 binary IPC and Channel streaming return raw ArrayBuffers directly via the platform-native IPC interface (WKScriptMessageHandler/Android WebMessagePort), avoiding JSON parsing and string allocations entirely. ```typescript import { invoke, Channel } from '@tauri-apps/api/core'; export async function streamDocumentGood( docId: string, onChunk: (chunk: Uint8Array) => void ): Promise<void> { // Tauri 2.0 Channel enables zero-copy chunked binary delivery const onProgress = new Channel<ArrayBuffer>(); onProgress.onmessage = (arrayBuffer: ArrayBuffer) => { onChunk(new Uint8Array(arrayBuffer)); }; await invoke('stream_document_binary', { docId, onProgress }); } export async function fetchDocumentDirect(docId: string): Promise<Uint8Array> { // Raw binary IPC response directly into ArrayBuffer const rawBuffer = await invoke<ArrayBuffer>('get_document_binary', { docId }); return new Uint8Array(rawBuffer); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Scoped IPC Shared-Memory & ArrayBuffer Streaming Standard

Tauri 2.0 Scoped IPC Shared-Memory & ArrayBuffer Streaming Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces zero-copy, non-blocking binary data transfer between Tauri 2.0 Rust core commands and mobile WebViews (iOS WKWebView and Android WebView). Prohibits base64 stringification and numeric array serialization of binary payloads to eliminate main thread garbage collection pauses and UI frame dropping. Mandates raw IPC binary channels or custom asset protocol streaming for payloads exceeding 64KB. 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: Base64 or JSON-Array Serialization of Multi-Megabyte Binary Payloads 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	Base64 or JSON-Array Serialization of Multi-Megabyte Binary Payloads 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 use `tauri

Engineers MUST ALWAYS use `tauri::ipc::Response::new(bytes)` in Rust and typed `ArrayBuffer` / `Uint8Array` handlers on the client for binary payloads over 64KB.

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.