Tauri 2.0 Mobile Zero-Copy Binary IPC Buffer Safety Guardrail

--- description: Tauri 2.0 Mobile Zero-Copy Binary IPC Buffer Safety Guardrail - Enforces memory-safe, zero-copy binary streaming protocols between Tauri 2.0 native Rust host engines and mobile webviews (iOS WKWebView and Android WebView). Prevents mobile operating system terminations (iOS Jetsam, Android LowMemoryKiller), GC thrashing from Base64 string serialization, and cross-thread buffer mutations during high-bandwidth media and sensor ingestion. 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-zerocopy-ipc-guardrail" --- # Tauri 2.0 Mobile Zero-Copy Binary IPC Buffer Safety Guardrail > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Serializing high-bandwidth binary streams via Base64/JSON strings or mutating in-flight Rust memory buffers without atomic ownership handoff. ## System Constraints You are a Principal Mobile Systems Architect and Rust/WebKit IPC Specialist enforcing Tauri 2.0 Rust-to-Webview Zero-Copy IPC Buffer Guardrails. Mandate non-allocating binary data transfers, strict buffer ownership semantics, deterministic memory backpressure, and zero-copy TypedArray consumption across iOS WKWebView and Android WebView runtimes. ## Strict Guidelines - Engineers MUST ALWAYS transfer high-bandwidth binary payloads via Tauri 2.0 raw binary responses (`tauri::ipc::Response::new(vec)`) or typed binary `Channel` instances instead of JSON or Base64 string serialization. - Engineers MUST NOT mutate, reallocate, or deallocate underlying native memory buffers while an asynchronous mobile IPC bridge transfer is in flight without deterministic Rust ownership transfer. - Code SHOULD consume raw binary payloads on the mobile webview main thread exclusively as `Uint8Array` views and immediately transfer ownership to a Web Worker via transferable `postMessage([buffer], [buffer])` to prevent UI thread frame drops. - Services MUST enforce bounded ring buffers with explicit backpressure signaling between the Rust producer thread and mobile webview consumer to avoid triggering OS-level out-of-memory terminations (iOS Jetsam, Android LMK). - Components NEVER decode binary payloads using `atob()` or JSON string conversions on mobile webview runtimes. ## Bad vs Good Implementations ### Tauri 2.0 Binary IPC Ingestion on Mobile Webview #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Transfers binary data as Base64 inside a JSON payload. This causes a 33% memory footprint expansion, creates thousands of short-lived string allocations, and triggers aggressive garbage collection pauses on mobile devices, often resulting in Jetsam kills on iOS. ```typescript import { invoke } from '@tauri-apps/api/core'; interface FramePayload { frameId: number; base64Data: string; // Anti-pattern: High-overhead Base64 encoding over IPC } export async function subscribeToVideoFrames(onFrame: (data: Uint8Array) => void): Promise<void> { // Incurs 33% payload expansion, JSON parsing overhead, and massive V8/JSC GC pauses const payload = await invoke<FramePayload>('get_next_camera_frame'); const binaryString = atob(payload.base64Data); const bytes = new Uint8Array(binaryString.length); for (let i = 0; i < binaryString.length; i++) { bytes[i] = binaryString.charCodeAt(i); } onFrame(bytes); } ``` #### Production Standard (Correct) > **Standard**: Utilizes Tauri 2.0 typed binary Channel delivering direct raw ArrayBuffers. The payload bypasses Base64 encoding entirely, and the memory buffer is immediately transferred to a Web Worker using Transferable Objects, ensuring zero-copy overhead and 60fps UI responsiveness on mobile devices. ```typescript import { Channel, invoke } from '@tauri-apps/api/core'; export async function subscribeToVideoFrames( worker: Worker, signal: AbortSignal ): Promise<void> { // Tauri 2.0 Channel transmitting raw ArrayBuffer chunks without Base64/JSON overhead const onFrameChannel = new Channel<ArrayBuffer>(); onFrameChannel.onmessage = (frameBuffer: ArrayBuffer) => { if (signal.aborted) return; // Direct zero-copy transfer to dedicated processing Web Worker worker.postMessage({ frame: frameBuffer }, [frameBuffer]); }; await invoke('stream_camera_frames_binary', { onFrame: onFrameChannel }); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile Zero-Copy Binary IPC Buffer Safety Guardrail

Tauri 2.0 Mobile Zero-Copy Binary IPC Buffer Safety Guardrail defines an industrial-grade behavioral standard for mobile engineering. Enforces memory-safe, zero-copy binary streaming protocols between Tauri 2.0 native Rust host engines and mobile webviews (iOS WKWebView and Android WebView). Prevents mobile operating system terminations (iOS Jetsam, Android LowMemoryKiller), GC thrashing from Base64 string serialization, and cross-thread buffer mutations during high-bandwidth media and sensor ingestion. 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-bandwidth binary streams via Base64/JSON strings or mutating in-flight Rust memory buffers without atomic ownership handoff. 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-bandwidth binary streams via Base64/JSON strings or mutating in-flight Rust memory buffers without atomic ownership handoff.	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-bandwidth binary payloads via Tauri 2.0 raw binary responses (`tauri

Engineers MUST ALWAYS transfer high-bandwidth binary payloads via Tauri 2.0 raw binary responses (`tauri::ipc::Response::new(vec)`) or typed binary `Channel` instances instead of JSON or Base64 string serialization.

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.