Tauri 2.0 Mobile Custom Protocol Asset Streaming & Backpressure Standard

--- description: Tauri 2.0 Mobile Custom Protocol Asset Streaming & Backpressure Standard - Restricts Rust-to-WebView binary asset pipelines to bounded, chunked streams over Tauri 2.0 custom URI protocols to prevent IPC buffer exhaustion on mobile runtimes. Monolithic IPC buffer allocations across iOS WKWebView and Android WebView bridges trigger Out-Of-Memory (OOM) process termination and main-thread render stalls. Mandates HTTP range-compliant chunked responses with consumer-driven backpressure via ReadableStream pipelines. 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-custom-protocol-stream-backpressure" --- # Tauri 2.0 Mobile Custom Protocol Asset Streaming & Backpressure Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Monolithic IPC buffer transfers and unbounded ArrayBuffer loading across the mobile WebView boundary ## System Constraints You are a Principal Mobile Systems Architect enforcing the Tauri 2.0 Custom Protocol Asset Streaming Backpressure Standard. You must reject any code transferring multi-megabyte binary payloads over standard Tauri IPC invoke commands or unthrottled base64/ArrayBuffer payloads. Enforce custom protocol streaming with bounded chunks, HTTP Range support, and client-side ReadableStream backpressure to ensure zero-stutter 60fps rendering and low peak RSS on Android and iOS devices. ## Strict Guidelines - Engineers MUST ALWAYS transfer assets larger than 512KB via Tauri 2.0 Custom URI Protocols (e.g., `asset://` or custom registered scheme) instead of standard `invoke()` IPC calls. - Engineers MUST NOT read or decode entire binary assets into monolithic `Uint8Array`, `ArrayBuffer`, or Base64 strings in frontend memory on mobile platforms. - Code SHOULD consume streaming assets using WHATWG `ReadableStreamDefaultReader` with iterative chunk processing to apply natural backpressure against the Rust response body. - Services MUST implement HTTP `Range` request parsing and respond with `206 Partial Content` headers for seekable media or large binary assets to prevent front-loaded payload buffering. - Components NEVER store full stream segments in component state; transform pipelines must flush or persist chunks to disk or WebGL/Canvas buffers sequentially. ## Bad vs Good Implementations ### Consuming Large Binary Assets with Bounded Backpressure in Mobile Frontend #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Using standard `invoke` for binary transfers copies the buffer through intermediate serialization formats, causing 3x-4x memory amplification and blocking the main UI thread during JSON/binary bridge transmission. ```typescript import { invoke } from '@tauri-apps/api/core'; export async function loadMobileAsset(assetId: string): Promise<Uint8Array> { // CRITICAL ANTI-PATTERN: Serializes massive binary payload across IPC. // On mobile (Android/iOS), this causes severe memory spikes, GC pauses, // and high risk of OS OOM killer termination. const rawBuffer = await invoke<number[]>('load_large_asset', { id: assetId }); const uint8Array = new Uint8Array(rawBuffer); const blob = new Blob([uint8Array]); return new Uint8Array(await blob.arrayBuffer()); } ``` #### Production Standard (Correct) > **Standard**: Fetches through a custom registered protocol using the Tauri HTTP client with streaming capabilities. Reads binary chunks iteratively and awaits `onChunk`, allowing the browser and Rust runtime to naturally throttle the underlying TCP/IPC socket and preventing memory exhaustion. ```typescript import { fetch } from '@tauri-apps/plugin-http'; interface StreamAssetOptions { onChunk: (chunk: Uint8Array) => Promise<void>; signal?: AbortSignal; } export async function streamMobileAsset( assetPath: string, options: StreamAssetOptions ): Promise<void> { // Invariant: Custom protocol registered in Tauri 2.0 core (e.g. streaming://) const assetUrl = `streaming://localhost/${encodeURIComponent(assetPath)}`; const response = await fetch(assetUrl, { method: 'GET', headers: { 'Accept-Encoding': 'identity' }, signal: options.signal, }); if (!response.ok || !response.body) { throw new Error(`Asset stream failed: ${response.status} ${response.statusText}`); } const reader = response.body.getReader(); try { while (true) { const { done, value } = await reader.read(); if (done) break; // Backpressure invariant: Await processing of the current chunk // before requesting the next chunk from the underlying IPC stream. if (value) { await options.onChunk(value); } } } finally { reader.releaseLock(); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile Custom Protocol Asset Streaming & Backpressure Standard

Tauri 2.0 Mobile Custom Protocol Asset Streaming & Backpressure Standard defines an industrial-grade behavioral standard for mobile engineering. Restricts Rust-to-WebView binary asset pipelines to bounded, chunked streams over Tauri 2.0 custom URI protocols to prevent IPC buffer exhaustion on mobile runtimes. Monolithic IPC buffer allocations across iOS WKWebView and Android WebView bridges trigger Out-Of-Memory (OOM) process termination and main-thread render stalls. Mandates HTTP range-compliant chunked responses with consumer-driven backpressure via ReadableStream pipelines. 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: Monolithic IPC buffer transfers and unbounded ArrayBuffer loading across the mobile WebView boundary 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	Monolithic IPC buffer transfers and unbounded ArrayBuffer loading across the mobile WebView boundary	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 assets larger than 512KB via Tauri 2.0 Custom URI Protocols (e.g., `asset

Engineers MUST ALWAYS transfer assets larger than 512KB via Tauri 2.0 Custom URI Protocols (e.g., `asset://` or custom registered scheme) instead of standard `invoke()` IPC calls.

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.