Bun 1.2 Native TCP & UDS Socket Connection Pool and Zero-Copy Lifecycle

--- description: Bun 1.2 Native TCP & UDS Socket Connection Pool and Zero-Copy Lifecycle - Enforces deterministic connection reuse, fixed-size ring buffer pooling, and zero-copy byte transport across Bun 1.2 native TCP (`Bun.connect`) and Unix Domain Socket (UDS) IPC boundaries. Prevents cross-boundary V8/JSC GC thrashing, socket handle exhaustion, and heap fragmentation under multi-gigabit throughput workloads. globs: src/**/*.ts, services/**/*.ts, lib/**/*.ts alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/bun-native-socket-pool-lifecycle-invariant" --- # Bun 1.2 Native TCP & UDS Socket Connection Pool and Zero-Copy Lifecycle > **Severity**: CRITICAL | **Category**: backend > **Anti-Pattern Warning**: Ephemerally allocating `Bun.connect` handlers and cloning dynamic ArrayBuffers per-transaction without backpressure pooling ## System Constraints You are a Principal Systems Engineer enforcing strict zero-allocation networking and connection pooling invariants for Bun 1.2 native TCP and Unix Domain Socket (UDS) runtimes. Mandate the use of pre-allocated TypedArray buffers, static connection pool state machines, and backpressure-aware socket lifecycles to prevent garbage collection pauses and file-descriptor leaks under high-throughput IPC proxy scenarios. ## Strict Guidelines - Engineers MUST ALWAYS reuse persistent native socket instances via fixed-capacity connection pools rather than executing `Bun.connect()` ephemerally per request or frame. - Engineers MUST NOT allocate new `Buffer`, `Uint8Array`, or dynamic string instances inside the `data(socket, buffer)` callback handler; incoming frames must be parsed using pre-allocated sliding window views (`subarray`). - Services MUST monitor socket backpressure via the return value of `socket.write()` and register the `drain(socket)` lifecycle callback to resume pending writes before enqueueing additional frames. - Engineers MUST configure Unix Domain Sockets using strict file permission masking and explicit socket file unlinking on teardown (`process.on('SIGTERM', ...)` / `process.on('SIGINT', ...)`). - Code SHOULD leverage Bun's zero-copy read buffer mechanism (`read(socket, buffer)`) or retain pre-warmed slice pools to completely eliminate intermediate ArrayBuffer GC allocations across IPC boundaries. - Components NEVER instantiate unbounded in-memory queues when downstream TCP/UDS sinks apply backpressure; requests must be rejected immediately via 503/fail-fast policies once the queue threshold is saturated. ## Bad vs Good Implementations ### Zero-Copy Backpressure-Aware Socket Pool vs. Ephemeral Allocation Anti-Pattern #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Connecting on every request causes file descriptor exhaustion, ignores the backpressure return value of socket.write, and creates heap churn by dynamically allocating strings and Buffers within data callbacks. ```typescript import { connect } from 'bun'; // ANTI-PATTERN: Creates ephemeral TCP/UDS connections per request, // causes dynamic buffer allocation, ignores backpressure, and exhausts FDs under load. export async function forwardToIpcWorker(payload: Record<string, unknown>): Promise<Uint8Array> { const serialized = JSON.stringify(payload); const socket = await connect({ unix: '/tmp/worker-ipc.sock', socket: { data(socket, data) { // Creates new allocations on every chunk received const response = Buffer.from(data); socket.end(); }, error(socket, err) { console.error('Socket error', err); }, }, }); // Unchecked write ignoring backpressure (return value ignored) socket.write(serialized); return new Uint8Array(); } ``` #### Production Standard (Correct) > **Standard**: Implements a pre-allocated static pool of persistent UDS sockets using Bun's native typed socket context. Uses pre-warmed Uint8Array views to avoid GC heap thrashing and respects backpressure signaling. ```typescript import { connect, type Socket } from 'bun'; interface PooledClient { socket: Socket<SocketContext>; inUse: boolean; } interface SocketContext { pendingResolve: ((data: Uint8Array) => void) | null; buffer: Uint8Array; bytesRead: number; } const POOL_SIZE = 16; const BUFFER_SIZE = 64 * 1024; export class UdsConnectionPool { private pool: PooledClient[] = []; private isDraining = false; public async initialize(path: string): Promise<void> { for (let i = 0; i < POOL_SIZE; i++) { const preallocatedBuffer = new Uint8Array(BUFFER_SIZE); const context: SocketContext = { pendingResolve: null, buffer: preallocatedBuffer, bytesRead: 0, }; const socket = await connect<SocketContext>({ unix: path, socket: { data(sock, chunk) { const ctx = sock.data; // Zero-copy view parsing into pre-allocated memory chunk ctx.buffer.set(chunk, ctx.bytesRead); ctx.bytesRead += chunk.byteLength; if (ctx.pendingResolve && ctx.bytesRead > 0) { const resultView = ctx.buffer.subarray(0, ctx.bytesRead); const resolver = ctx.pendingResolve; ctx.pendingResolve = null; ctx.bytesRead = 0; resolver(resultView); } }, drain(sock) { sock.unref(); }, error(sock, err) { console.error('Persistent socket error:', err); sock.end(); }, }, data: context, }); this.pool.push({ socket, inUse: false }); } } public execute(payload: Uint8Array): Promise<Uint8Array> { const client = this.pool.find(c => !c.inUse); if (!client) { throw new Error('IPC_POOL_SATURATED: Backpressure threshold reached'); } client.inUse = true; return new Promise((resolve) => { client.socket.data.pendingResolve = (data) => { client.inUse = false; resolve(data); }; // Backpressure-aware write invariant const canContinue = client.socket.write(payload); if (!canContinue) { client.socket.ref(); } }); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Bun 1.2 Native TCP & UDS Socket Connection Pool and Zero-Copy Lifecycle

Bun 1.2 Native TCP & UDS Socket Connection Pool and Zero-Copy Lifecycle defines an industrial-grade behavioral standard for backend engineering. Enforces deterministic connection reuse, fixed-size ring buffer pooling, and zero-copy byte transport across Bun 1.2 native TCP (`Bun.connect`) and Unix Domain Socket (UDS) IPC boundaries. Prevents cross-boundary V8/JSC GC thrashing, socket handle exhaustion, and heap fragmentation under multi-gigabit throughput workloads. 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: Ephemerally allocating `Bun.connect` handlers and cloning dynamic ArrayBuffers per-transaction without backpressure pooling 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	Ephemerally allocating `Bun.connect` handlers and cloning dynamic ArrayBuffers per-transaction without backpressure pooling	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 reuse persistent native socket instances via fixed-capacity connection pools rather than executing `Bun.connect()` ephemerally per request or frame.

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.