Tauri 2.0 Mobile IPC Buffer Alignment and Granular Capability Scoping

--- description: Tauri 2.0 Mobile IPC Buffer Alignment and Granular Capability Scoping - Mandates zero-copy TypedArray IPC transfers between Tauri 2.0 Rust/native plugins and mobile WebViews, preventing Base64 string payload degradation and memory alignment faults on ARM architectures. Enforces compile-time capability scoping to strictly isolate native mobile OS bridge permissions by platform and webview label. globs: src-tauri/src/**/*.rs, src-tauri/capabilities/**/*.json, src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-mobile-ipc-buffer-alignment-capability-scoping" --- # Tauri 2.0 Mobile IPC Buffer Alignment and Granular Capability Scoping > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Base64 Payload Serialization Over Mobile IPC Bridges Combined with Wildcard Capability ACLs ## System Constraints You are a Principal Systems and Mobile Architect enforcing strict Tauri 2.0 IPC performance and capability boundary standards. You must mandate zero-copy byte buffers for mobile WebViews, enforce strict byte-offset alignment verification on ARM devices, and reject any ambient wildcard permissions in Tauri capability ACL files. ## Strict Guidelines - Engineers MUST ALWAYS transfer binary data over Tauri 2.0 IPC using raw byte responses (e.g., tauri::ipc::Response::new(bytes)) instead of JSON byte arrays or Base64 string serialization. - Engineers MUST verify ArrayBuffer byte offsets (`buffer.byteOffset % TypedArray.BYTES_PER_ELEMENT === 0`) prior to instantiating multi-byte typed views (e.g., Float32Array, Uint32Array) to prevent bus errors and SIGBUS/SIGSEGV crashes on 64-bit ARM mobile CPUs. - Engineers MUST NOT declare wildcard permissions (`*`) in `src-tauri/capabilities/*.json`; capabilities MUST be restricted to explicit command names and scoped to specific mobile platforms (iOS, Android) and webview windows. - Frontend IPC invokers MUST invoke binary commands with Tauri 2.0's raw response handling or custom binary protocols to preserve zero-copy IPC characteristics across Android WebView (evaluateJavascript/postMessage) and iOS WKWebView (WKScriptMessageHandler). - Native mobile plugins MUST implement permissions via Tauri 2.0 ACL definitions (permissions manifests) rather than executing unrestricted direct JNI or Objective-C invocations. ## Bad vs Good Implementations ### Tauri 2.0 Mobile Binary IPC and Memory Alignment Handling #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Base64 serialization over the mobile IPC bridge induces high memory allocations and JS thread stalls. Directly slicing an ArrayBuffer without verifying word alignment (4-byte alignment for Float32Array) can cause SIGBUS crashes on ARM64 mobile hardware. ```typescript import { invoke } from '@tauri-apps/api/core'; // ANTI-PATTERN: Serializing large binary frames as Base64 strings over IPC // Causes memory thrashing and GC pressure on mobile WebViews. // Furthermore, blindly views byte arrays without alignment verification. export async function fetchSensorTelemetry(): Promise<Float32Array> { const base64Data = await invoke<string>('get_telemetry_base64'); const binaryString = atob(base64Data); const bytes = new Uint8Array(binaryString.length); for (let i = 0; i < binaryString.length; i++) { bytes[i] = binaryString.charCodeAt(i); } // CRITICAL: Unaligned slice cast will crash on ARM architectures return new Float32Array(bytes.buffer, bytes.byteOffset + 1); } ``` #### Production Standard (Correct) > **Standard**: Leverages direct binary IPC transfer from Tauri 2.0 native responses, validates byte lengths and memory offset alignment before casting to Float32Array, completely preventing ARM alignment faults while eliminating serialization overhead. ```typescript import { invoke } from '@tauri-apps/api/core'; // PRODUCTION INVARIANT: Zero-copy ArrayBuffer IPC with strict ARM alignment verification export async function fetchSensorTelemetry(): Promise<Float32Array> { // In Tauri 2.0, raw Response bytes resolve as an ArrayBuffer or Uint8Array directly const rawBuffer = await invoke<ArrayBuffer>('get_telemetry_binary'); const requiredAlignment = Float32Array.BYTES_PER_ELEMENT; // 4 bytes if (rawBuffer.byteLength % requiredAlignment !== 0) { throw new RangeError(`Buffer byteLength ${rawBuffer.byteLength} is not a multiple of ${requiredAlignment}`); } // When creating a typed view over an ArrayBuffer, ensure byteOffset is aligned const byteOffset = 0; if (byteOffset % requiredAlignment !== 0) { // Re-align via copy only if offset is misaligned, preserving zero-copy in standard cases const alignedBuffer = rawBuffer.slice(byteOffset); return new Float32Array(alignedBuffer); } return new Float32Array(rawBuffer, byteOffset, rawBuffer.byteLength / requiredAlignment); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC Buffer Alignment and Granular Capability Scoping

Tauri 2.0 Mobile IPC Buffer Alignment and Granular Capability Scoping defines an industrial-grade behavioral standard for mobile engineering. Mandates zero-copy TypedArray IPC transfers between Tauri 2.0 Rust/native plugins and mobile WebViews, preventing Base64 string payload degradation and memory alignment faults on ARM architectures. Enforces compile-time capability scoping to strictly isolate native mobile OS bridge permissions by platform and webview label. 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 Payload Serialization Over Mobile IPC Bridges Combined with Wildcard Capability ACLs 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 Payload Serialization Over Mobile IPC Bridges Combined with Wildcard Capability ACLs	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 binary data over Tauri 2.0 IPC using raw byte responses (e.g., tauri

Engineers MUST ALWAYS transfer binary data over Tauri 2.0 IPC using raw byte responses (e.g., tauri::ipc::Response::new(bytes)) instead of JSON byte arrays 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.