Tauri 2.0 IPC Capability-Scoped Zero-Copy ArrayBuffer Isolation

--- description: Tauri 2.0 IPC Capability-Scoped Zero-Copy ArrayBuffer Isolation - Enforces fine-grained Tauri 2.0 ACL capability scoping and raw binary TypedArray/ArrayBuffer transfers across the Webview-to-Core boundary. Prohibits base64 or JSON-serialized byte arrays to eliminate GC pressure, heap fragmentation, and unauthorized IPC capability escalation. globs: src/**/*.{ts,tsx}, src-tauri/capabilities/**/*.json, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-capability-scoped-zero-copy-ipc" --- # Tauri 2.0 IPC Capability-Scoped Zero-Copy ArrayBuffer Isolation > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Passing Large Binary Blobs via Base64/JSON Serialization Over Unscoped Tauri IPC Commands ## System Constraints You are a Principal Engineer enforcing Tauri 2.0 IPC Capability-Scoped Zero-Copy ArrayBuffer Isolation. You must mandate strict capability-driven access controls for IPC commands and enforce binary zero-copy IPC patterns using Uint8Array/ArrayBuffer over the Tauri 2.0 IPC bridge. Prohibit JSON-serialized arrays of numbers, base64 data encoding, and global/wildcard permission grants. ## Strict Guidelines - Engineers MUST ALWAYS transmit binary payloads between the Webview and Rust host using raw Uint8Array and the Tauri 2.0 binary IPC interface (tauri::ipc::Response/Request) rather than JSON stringification or base64 encoding. - Engineers MUST NOT configure wildcard permissions ('*') or unscoped invocation handlers in src-tauri/capabilities/*.json for high-throughput or privileged commands. - Code SHOULD verify ArrayBuffer detachment and lifecycle bounds when passing large memory buffers across the bridge to prevent race conditions and concurrent mutation. - Services MUST enforce cryptographic capability isolation by ensuring each frontend domain or window label has a discrete permission manifest declaring explicit command access. - Components NEVER parse multi-megabyte binary payloads from UTF-8 strings or generic JSON objects within the frontend rendering thread. ## Bad vs Good Implementations ### Tauri IPC Binary Transfer and Capability Scoping #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Array.from(new Uint8Array(buffer)) copies every byte into a JavaScript V8 heap object array, causing severe memory spikes, GC thrashing, and high latency. Furthermore, invoking without a typed binary transport exposes the command to non-isolated string serialization overhead. ```typescript import { invoke } from '@tauri-apps/api/core'; // ANTI-PATTERN: Serializing binary buffer to base64 or JSON number array export async function uploadAudioBuffer(buffer: ArrayBuffer): Promise<void> { const bytes = Array.from(new Uint8Array(buffer)); // Heap allocation & stringification bottleneck await invoke('process_audio_chunk', { payload: { data: bytes, encoding: 'json_array' } }); } ``` #### Production Standard (Correct) > **Standard**: Directly transfers the ArrayBuffer via a Uint8Array view using Tauri 2.0's raw IPC channel. This avoids JSON and base64 allocation penalties, reduces memory footprint to zero-copy pointer transfers at the bridge boundary, and stays compliant with capability permission sets. ```typescript import { invoke } from '@tauri-apps/api/core'; // PRODUCTION FIX: Zero-copy raw Uint8Array passing via Tauri 2.0 binary IPC export async function uploadAudioBuffer(buffer: ArrayBuffer): Promise<Uint8Array> { const payload = new Uint8Array(buffer); // Tauri 2.0 supports direct Uint8Array transfer without serialization overhead const rawResponse = await invoke<ArrayBuffer>('process_audio_chunk', payload, { headers: { 'content-type': 'application/octet-stream' } }); return new Uint8Array(rawResponse); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 IPC Capability-Scoped Zero-Copy ArrayBuffer Isolation

Tauri 2.0 IPC Capability-Scoped Zero-Copy ArrayBuffer Isolation defines an industrial-grade behavioral standard for frontend engineering. Enforces fine-grained Tauri 2.0 ACL capability scoping and raw binary TypedArray/ArrayBuffer transfers across the Webview-to-Core boundary. Prohibits base64 or JSON-serialized byte arrays to eliminate GC pressure, heap fragmentation, and unauthorized IPC capability escalation. 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: Passing Large Binary Blobs via Base64/JSON Serialization Over Unscoped Tauri IPC Commands 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	Passing Large Binary Blobs via Base64/JSON Serialization Over Unscoped Tauri IPC Commands	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 transmit binary payloads between the Webview and Rust host using raw Uint8Array and the Tauri 2.0 binary IPC interface (tauri

Engineers MUST ALWAYS transmit binary payloads between the Webview and Rust host using raw Uint8Array and the Tauri 2.0 binary IPC interface (tauri::ipc::Response/Request) rather than JSON stringification or base64 encoding.

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.