Tauri 2.0 Mobile IPC ArrayBuffer Isolation and Zero-Copy Binary Framing

--- description: Tauri 2.0 Mobile IPC ArrayBuffer Isolation and Zero-Copy Binary Framing - Enforces memory isolation, strict framing invariants, and zero-copy binary streaming between the Tauri 2.0 Rust runtime and mobile WebViews (WKWebView/Android WebView). Prevents base64 JSON serialization overhead, OOM crashes from uncontrolled buffer allocation, and detached buffer panics during high-throughput binary IPC. globs: src-tauri/src/**/*.rs, src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-mobile-ipc-zero-copy-buffer-isolation" --- # Tauri 2.0 Mobile IPC ArrayBuffer Isolation and Zero-Copy Binary Framing > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Serializing Raw Binary Payloads via Base64 JSON Strings or Mutating In-Flight ArrayBuffers ## System Constraints You are a Principal Systems Architect enforcing Tauri 2.0 binary IPC protocols and memory isolation on mobile platforms. Mandate zero-copy binary frames via raw IPC responses and binary channels, eliminate base64 JSON IPC serialization, enforce strict byte-alignment and bounds checking on Webview ArrayBuffers, and prevent mobile Webview memory pressure OOMs through rigid transfer ownership semantics. ## Strict Guidelines - Engineers MUST ALWAYS use Tauri 2.0 raw IPC binary returns (`tauri::ipc::Response`) or `tauri::ipc::Channel` for high-throughput binary transfers rather than serializing byte arrays into JSON strings or Base64. - Engineers MUST NOT mutate an ArrayBuffer or TypedArray in the frontend while it is queued or being transferred to the Tauri native core via IPC. - Code MUST validate binary header frames (magic bytes, version, payload length, CRC/checksum) before accessing TypedArray buffer offsets to avoid buffer overrun attacks and out-of-bounds reads. - Services MUST enforce backpressure and bounded buffer pools on high-throughput streams (e.g., camera feeds, audio processing, sensor telemetry) to prevent mobile WKWebView and Android WebView message queue saturation. - Components NEVER assume transferred ArrayBuffers remain valid after structured transfer operations; callers must verify buffer detachment state (`buffer.byteLength === 0`). ## Bad vs Good Implementations ### Tauri 2.0 Binary IPC Command Handling #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Encoding binary frames as Base64 JSON strings introduces an immediate 33% memory footprint penalty, high CPU overhead, and causes mobile WebViews (iOS WKWebView/Android WebView) to trigger aggressive garbage collection pauses or outright process termination due to OOM memory pressure. ```typescript import { invoke } from '@tauri-apps/api/core'; interface FramePayload { id: number; // Anti-pattern: Base64 string causes 33% overhead, GC thrashing, and high mobile memory pressure base64Data: string; } export async function fetchCameraFrame(frameId: number): Promise<Uint8Array> { const response = await invoke<FramePayload>('get_camera_frame', { frameId }); const binaryString = atob(response.base64Data); 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**: Leverages Tauri 2.0 direct binary response IPC without Base64 serialization. Enforces invariant bounds checking, magic byte header verification, and explicit buffer length validation before exposing the isolated TypedArray slice. ```typescript import { invoke } from '@tauri-apps/api/core'; const FRAME_HEADER_SIZE = 8; const MAGIC_BYTES = 0x5446524d; // 'TFRM' export async function fetchCameraFrame(frameId: number): Promise<Uint8Array> { // Tauri 2.0 supports direct raw ArrayBuffer response returns via custom IPC binary decoding const rawBuffer: ArrayBuffer = await invoke('get_camera_frame_binary', { frameId }, { responseType: 3 /* ResponseType.Binary */ } ); if (rawBuffer.byteLength < FRAME_HEADER_SIZE) { throw new RangeError(`Frame undersized: expected >= ${FRAME_HEADER_SIZE} bytes, got ${rawBuffer.byteLength}`); } const view = new DataView(rawBuffer); const magic = view.getUint32(0, false); if (magic !== MAGIC_BYTES) { throw new Error(`Corrupt binary frame header: invalid magic byte sequence`); } const payloadLength = view.getUint32(4, false); if (rawBuffer.byteLength - FRAME_HEADER_SIZE !== payloadLength) { throw new RangeError(`Payload length mismatch: header specifies ${payloadLength}, actual ${rawBuffer.byteLength - FRAME_HEADER_SIZE}`); } // Return memory-isolated zero-copy view of payload return new Uint8Array(rawBuffer, FRAME_HEADER_SIZE, payloadLength); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC ArrayBuffer Isolation and Zero-Copy Binary Framing

Tauri 2.0 Mobile IPC ArrayBuffer Isolation and Zero-Copy Binary Framing defines an industrial-grade behavioral standard for mobile engineering. Enforces memory isolation, strict framing invariants, and zero-copy binary streaming between the Tauri 2.0 Rust runtime and mobile WebViews (WKWebView/Android WebView). Prevents base64 JSON serialization overhead, OOM crashes from uncontrolled buffer allocation, and detached buffer panics during high-throughput binary IPC. 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 Raw Binary Payloads via Base64 JSON Strings or Mutating In-Flight ArrayBuffers 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 Raw Binary Payloads via Base64 JSON Strings or Mutating In-Flight ArrayBuffers	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 2.0 raw IPC binary returns (`tauri

Engineers MUST ALWAYS use Tauri 2.0 raw IPC binary returns (`tauri::ipc::Response`) or `tauri::ipc::Channel` for high-throughput binary transfers rather than serializing byte arrays into JSON strings or Base64.

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.