WHATWG Streams API Backpressure-Driven Byte Stream Decoding Pipeline Standard

Q: How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Unbounded ArrayBuffer Aggregation and Unconstrained Async Loop Ingestion Without Backpressure) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q: Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q: Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

WHATWG Streams API Backpressure-Driven Byte Stream Decoding Pipeline Standard

--- description: WHATWG Streams API Backpressure-Driven Byte Stream Decoding Pipeline Standard - Enforces strict backpressure propagation, unbuffered zero-copy chunk handoff, and BYOB (Bring Your Own Buffer) reader semantics across browser streaming pipelines. Mandates that multi-gigabyte binary streams are consumed using chunk-aligned transform loops and dedicated Web Workers to eliminate main-thread stalls and unbounded heap growth. globs: src/**/*.{ts,tsx}, src/workers/**/*.{ts,js} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/whatwg-streams-backpressure-pipeline-standard" --- # WHATWG Streams API Backpressure-Driven Byte Stream Decoding Pipeline Standard > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Unbounded ArrayBuffer Aggregation and Unconstrained Async Loop Ingestion Without Backpressure ## System Constraints You are a Principal Software Architect enforcing zero memory ballooning and strict backpressure compliance across client-side WHATWG Streams pipelines. All multi-megabyte and multi-gigabyte binary ingestion pipelines must employ ReadableStream BYOB readers or TransformStream backpressure chains, never aggregate binary chunks into intermediate unbounded buffers in memory, and offload synchronous deserialization to dedicated Web Workers via Transferable ArrayBuffers. ## Strict Guidelines - Engineers MUST ALWAYS use BYOB (`readableStream.getReader({ mode: 'byob' })`) reader semantics or pipe through chained `TransformStream` instances to naturally propagate backpressure to the underlying network transport. - Engineers MUST NOT aggregate chunks via `response.arrayBuffer()` or append chunks into unbounded growing arrays/buffers when parsing streams of indeterminate or multi-megabyte size. - Code SHOULD allocate reusable `ArrayBuffer` allocations or transfer byte slice ownership via `postMessage(..., [buffer])` when offloading decoded frames to Web Workers or presentation layers. - Services MUST monitor `controller.desiredSize` inside custom `TransformStream` or `UnderlyingSink` implementations, pausing pulls or upstream emission when `desiredSize <= 0`. - Components NEVER execute synchronous binary deserialization loops or decompression algorithms directly on the browser main thread. ## Bad vs Good Implementations ### Multi-Gigabyte Binary Stream Consumption and Frame Parsing #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Accumulates all binary chunks in memory before processing, entirely breaking WHATWG backpressure semantics and causing rapid out-of-memory (OOM) browser crashes on multi-gigabyte streams, while also freezing the main UI thread during massive buffer reallocations and copies. ```typescript export async function ingestBinaryDataset(url: string): Promise<void> { const response = await fetch(url); if (!response.body) throw new Error('Missing body'); // CRITICAL ANTI-PATTERN: Accumulates entire stream into unbounded memory const chunks: Uint8Array[] = []; const reader = response.body.getReader(); while (true) { const { done, value } = await reader.read(); if (done) break; if (value) { chunks.push(value); // Heap memory inflates proportionally to file size } } // Synchronous deserialization directly freezes the main thread const totalSize = chunks.reduce((acc, c) => acc + c.byteLength, 0); const fullBuffer = new Uint8Array(totalSize); let offset = 0; for (const chunk of chunks) { fullBuffer.set(chunk, offset); offset += chunk.byteLength; } processAllRecordsSync(fullBuffer); } ``` #### Production Standard (Correct) > **Standard**: Processes the stream via a pipelined TransformStream that respects controller queue bounds, isolates frame parsing to manageable slices, preserves backpressure down the network pipe, and yields execution cleanly without memory ballooning. ```typescript export async function ingestBinaryDataset( stream: ReadableStream<Uint8Array>, onRecordDecoded: (record: ArrayBuffer) => void ): Promise<void> { const HEADER_SIZE = 8; let remainder = new Uint8Array(0); // Chained TransformStream enforces flow control via backpressure signals const framedStream = stream.pipeThrough( new TransformStream<Uint8Array, Uint8Array>({ transform(chunk, controller) { const combined = new Uint8Array(remainder.byteLength + chunk.byteLength); combined.set(remainder, 0); combined.set(chunk, remainder.byteLength); let offset = 0; const view = new DataView(combined.buffer, combined.byteOffset, combined.byteLength); while (offset + HEADER_SIZE <= combined.byteLength) { const payloadLength = view.getUint32(offset + 4, true); const frameLength = HEADER_SIZE + payloadLength; if (offset + frameLength > combined.byteLength) break; const recordChunk = combined.slice(offset, offset + frameLength); controller.enqueue(recordChunk); offset += frameLength; } remainder = combined.slice(offset); } }) ); const reader = framedStream.getReader(); try { while (true) { const { done, value } = await reader.read(); if (done) break; // Value is bounded, processed chunk-by-chunk without full stream accumulation onRecordDecoded(value.buffer); } } finally { reader.releaseLock(); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: WHATWG Streams API Backpressure-Driven Byte Stream Decoding Pipeline Standard

WHATWG Streams API Backpressure-Driven Byte Stream Decoding Pipeline Standard defines an industrial-grade behavioral standard for frontend engineering. Enforces strict backpressure propagation, unbuffered zero-copy chunk handoff, and BYOB (Bring Your Own Buffer) reader semantics across browser streaming pipelines. Mandates that multi-gigabyte binary streams are consumed using chunk-aligned transform loops and dedicated Web Workers to eliminate main-thread stalls and unbounded heap growth. 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 ArrayBuffer Aggregation and Unconstrained Async Loop Ingestion Without Backpressure 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 ArrayBuffer Aggregation and Unconstrained Async Loop Ingestion Without Backpressure	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 BYOB (`readableStream.getReader({ mode

Engineers MUST ALWAYS use BYOB (`readableStream.getReader({ mode: 'byob' })`) reader semantics or pipe through chained `TransformStream` instances to naturally propagate backpressure to the underlying network transport.

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.