Tauri 2.0 Mobile IPC Zero-Copy Binary Stream Backpressure Protocol

--- description: Tauri 2.0 Mobile IPC Zero-Copy Binary Stream Backpressure Protocol - Enforces deterministic chunk-level flow control and sliding-window acknowledgement contracts across the Rust-to-Webview IPC boundary in Tauri 2.0 mobile environments. Prevents fatal native host process terminations triggered by the Android Low Memory Killer (LMK) and iOS Jetsam daemon during multi-gigabyte client binary transfers. globs: src/**/*.{ts,tsx,js}, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri2-mobile-ipc-zero-copy-backpressure-protocol" --- # Tauri 2.0 Mobile IPC Zero-Copy Binary Stream Backpressure Protocol > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Unbounded IPC Channel Ingestion and Base64 Buffering Causing Mobile OS Process Termination ## System Constraints You are a Principal Systems Architect enforcing the Tauri 2.0 IPC Zero-Copy Binary Stream Backpressure Protocol. You must reject any IPC design that buffers entire binary payloads into memory, converts binary buffers to Base64/JSON strings, or emits streaming chunks without explicit consumer-driven credit tokens across the Rust/Webview bridge. ## Strict Guidelines - Engineers MUST ALWAYS enforce bounded chunk sizes (recommended 64 KiB to 256 KiB) when streaming binary data to mobile WebViews. - Engineers MUST NOT serialize raw binary arrays into JSON strings, Base64 strings, or generic tauri::Event payloads. - Services MUST implement a credit-based backpressure handshake where Rust pauses transmission until the Webview acknowledges consumption of chunk n via a low-overhead ACK IPC invocation. - Components NEVER buffer full multi-megabyte or multi-gigabyte file payloads into heap memory (Vec<u8> or ArrayBuffer) on mobile host runtimes. - Code SHOULD utilize Tauri 2.0 Channel<tauri::ipc::InvokeResponseBody> or raw stream responses with an abort controller bound to DOM lifecycle state. ## Bad vs Good Implementations ### Frontend Backpressure Chunk Consumer #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Attempting to receive a multi-gigabyte or multi-megabyte payload via a single naive invoke call forces Rust to serialize the entire buffer into a JSON array of numbers, causing a 10x-20x memory spike that immediately triggers Android LMK or iOS Jetsam termination. ```typescript import { invoke } from '@tauri-apps/api/core'; // ANTI-PATTERN: Pulling unbounded full payload into heap memory causes OOM crash on mobile export async function downloadLargeAsset(assetId: string): Promise<Uint8Array> { const payload = await invoke<number[]>('download_asset_naive', { assetId }); return new Uint8Array(payload); } ``` #### Production Standard (Correct) > **Standard**: Uses Tauri 2.0's Channel primitive to stream raw typed arrays. Rust pauses reading from the file system or network socket until the Webview flushes the received chunk to its sink and fires an explicit ACK, maintaining a strictly bounded memory footprint. ```typescript import { invoke, Channel } from '@tauri-apps/api/core'; interface StreamChunk { sequence: number; data: Uint8Array; isFinal: boolean; } // PRODUCTION FIX: Windowed backpressure channel with explicit credit-based IPC acknowledgements export async function streamLargeAssetWithBackpressure( assetId: string, writer: WritableStreamDefaultWriter<Uint8Array> ): Promise<void> { const onChunk = new Channel<StreamChunk>(); onChunk.onmessage = async ({ sequence, data, isFinal }: StreamChunk) => { await writer.write(data); // Explicit ACK releases the Rust bounded channel permit await invoke('ack_asset_chunk', { assetId, sequence }); if (isFinal) { await writer.close(); } }; await invoke('start_backpressure_stream', { assetId, onChunk }); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC Zero-Copy Binary Stream Backpressure Protocol

Tauri 2.0 Mobile IPC Zero-Copy Binary Stream Backpressure Protocol defines an industrial-grade behavioral standard for mobile engineering. Enforces deterministic chunk-level flow control and sliding-window acknowledgement contracts across the Rust-to-Webview IPC boundary in Tauri 2.0 mobile environments. Prevents fatal native host process terminations triggered by the Android Low Memory Killer (LMK) and iOS Jetsam daemon during multi-gigabyte client binary transfers. 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: Unbounded IPC Channel Ingestion and Base64 Buffering Causing Mobile OS Process Termination 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	Unbounded IPC Channel Ingestion and Base64 Buffering Causing Mobile OS Process Termination	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 enforce bounded chunk sizes (recommended 64 KiB to 256 KiB) when streaming binary data to mobile WebViews.

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.