stitchkit 0.94.0 → 0.95.0

package/dist/{index-p81267c2.js → index-p3vsv1fb.js}

@@ -10,15 +10,15 @@ import {
 import {
   createValidatedRealtimeSocket,
   isModuleNotFound
-} from "./index-x4799c19.js";
+} from "./index-ndddxtyx.js";
 import {
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES
 } from "./index-wqgjfstn.js";
 import {
   DEFAULT_PROCESS_SIGNALS,
-  RUNTIME_CONTEXT_RESERVED_KEYS,
   applyCors,
   assertCorsConfig,
+  bindContract,
   corsPreflightResponse,
   defaultSignalSource,
   guardSignalCallback,
@@ -26,11 +26,11 @@ import {
   mediaTypeEssence,
   reportSignalError,
   requestCorsHeaders
-} from "./index-xnj9bgxe.js";
+} from "./index-2gxzjvyr.js";
 import {
   joinRoutePath,
   parseTrailingWildcard
-} from "./index-gyr48nzg.js";
+} from "./index-4gcnakhx.js";
 import {
   getRequestContext,
   runWithRequestContext,
@@ -67,11 +67,8 @@ import {
   transportResult
 } from "./index-hffjpmq9.js";
 
-// src/server/multipart.ts
-var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
-var DEFAULT_MAX_FIELD_BYTES = 1024 * 1024;
+// src/server/multipart-reader.ts
 var DEFAULT_MAX_HEADER_BYTES = 64 * 1024;
-var DEFAULT_MAX_PARTS = 1000;
 var CRLF = new Uint8Array([13, 10]);
 var HEADER_END = new Uint8Array([13, 10, 13, 10]);
 var decoder = new TextDecoder;
@@ -356,6 +353,11 @@ class MultipartStreamReader {
     this.#buffer = this.#buffer.slice(length);
   }
 }
+
+// src/server/multipart.ts
+var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
+var DEFAULT_MAX_FIELD_BYTES = 1024 * 1024;
+var DEFAULT_MAX_PARTS = 1000;
 function matchesContentType(contentType, accepted) {
   const normalized = contentType.toLowerCase();
   return accepted.some((candidate) => {
@@ -554,6 +556,45 @@ async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
   }
 }
 
+// src/server/streaming-pump.ts
+async function pumpFrames(p) {
+  let sinceYield = 0;
+  try {
+    for (;; ) {
+      await p.awaitDemand();
+      if (p.isClosed())
+        return;
+      const next = await p.iterator.next();
+      if (p.isClosed())
+        return;
+      if (next.done)
+        break;
+      if (!p.send(p.framing.frame(next.value)))
+        return;
+      sinceYield += 1;
+      if (sinceYield >= MAX_BUFFERED_FRAMES) {
+        sinceYield = 0;
+        await new Promise((resolve) => {
+          setTimeout(resolve, 0);
+        });
+        if (p.isClosed())
+          return;
+      }
+    }
+    if (p.framing.done)
+      p.send(p.framing.done);
+  } catch (error) {
+    if (p.isClosed()) {
+      if (!isStreamCancellation(error, p.departed))
+        p.pumped.reject(error);
+    } else
+      p.send(p.framing.frame(normalizeError(error).toJSON()));
+  } finally {
+    p.pumped.resolve();
+    p.end();
+  }
+}
+
 // src/server/streaming-route.ts
 var DEFAULT_STREAM_HEARTBEAT_MS = 5000;
 var FRAMINGS = {
@@ -603,7 +644,7 @@ function responseHeaders(framing, extra) {
   headers.set("X-Accel-Buffering", "no");
   return headers;
 }
-function streamingRoute(options) {
+function streamingTimings(options) {
   const heartbeatMs = options.heartbeatMs ?? DEFAULT_STREAM_HEARTBEAT_MS;
   if (!Number.isFinite(heartbeatMs) || heartbeatMs <= 0) {
     throw new TypeError("heartbeatMs must be a finite positive number of milliseconds");
@@ -612,6 +653,10 @@ function streamingRoute(options) {
   if (!Number.isInteger(idleTimeoutSeconds) || idleTimeoutSeconds < 0) {
     throw new TypeError("idleTimeoutSeconds must be a non-negative integer");
   }
+  return { heartbeatMs, idleTimeoutSeconds };
+}
+function streamingRoute(options) {
+  const { heartbeatMs, idleTimeoutSeconds } = streamingTimings(options);
   const framing = FRAMINGS[options.format ?? "ndjson"];
   return {
     method: options.method ?? "GET",
@@ -719,44 +764,19 @@ function streamingRoute(options) {
               });
             }
           };
-          let sinceYield = 0;
-          (async () => {
-            try {
-              for (;; ) {
-                await awaitDemand();
-                if (closed)
-                  return;
-                const next = await iterator.next();
-                if (closed)
-                  return;
-                if (next.done)
-                  break;
-                if (!send(framing.frame(next.value)))
-                  return;
-                sinceYield += 1;
-                if (sinceYield >= MAX_BUFFERED_FRAMES) {
-                  sinceYield = 0;
-                  await new Promise((resolve) => {
-                    setTimeout(resolve, 0);
-                  });
-                  if (closed)
-                    return;
-                }
-              }
-              if (framing.done)
-                send(framing.done);
-            } catch (error) {
-              if (closed) {
-                if (!isStreamCancellation(error, departed.signal))
-                  pumped.reject(error);
-              } else
-                send(framing.frame(normalizeError(error).toJSON()));
-            } finally {
-              pumped.resolve();
+          pumpFrames({
+            iterator,
+            framing,
+            send,
+            awaitDemand,
+            isClosed: () => closed,
+            departed: departed.signal,
+            pumped,
+            end: () => {
               release();
               finish();
             }
-          })();
+          });
         },
         pull() {
           signalDemand();
@@ -776,6 +796,101 @@ function sseRoute(options) {
   return streamingRoute({ ...options, format: "sse" });
 }
 
+// src/server/context-contribution.ts
+var RUNTIME_CONTEXT_RESERVED_KEYS = new Set([
+  "params",
+  "input",
+  "files",
+  "rawBody",
+  "source",
+  "req",
+  "url",
+  "headers",
+  "traceId",
+  "spanId",
+  "ipAddress",
+  "userAgent",
+  "signal",
+  "mcp",
+  "reportProgress"
+]);
+function contributionError(scope, reason) {
+  return new TypeError(`[stitchkit] auth: invalid context contribution for scope ${JSON.stringify(scope)}: ${reason}`);
+}
+function descriptorsEqual(left, right) {
+  if (!left || !right)
+    return left === right;
+  if (left.enumerable !== right.enumerable || left.configurable !== right.configurable || left.writable !== right.writable) {
+    return false;
+  }
+  if ("value" in left || "value" in right) {
+    return "value" in left && "value" in right && Object.is(left.value, right.value);
+  }
+  return left.get === right.get && left.set === right.set;
+}
+function contextContributionDelta(original, shadow, scope) {
+  if (Object.getPrototypeOf(shadow) !== Object.getPrototypeOf(original)) {
+    throw contributionError(scope, "context prototype changes are not supported");
+  }
+  const originalKeys = Reflect.ownKeys(original);
+  const shadowKeys = Reflect.ownKeys(shadow);
+  const shadowKeySet = new Set(shadowKeys);
+  for (const key of originalKeys) {
+    if (!shadowKeySet.has(key)) {
+      const printable = typeof key === "string" ? JSON.stringify(key) : "a symbol key";
+      throw contributionError(scope, `context key ${printable} may not be deleted`);
+    }
+  }
+  const contribution = Object.create(null);
+  for (const key of shadowKeys) {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(original, key);
+    const shadowDescriptor = Object.getOwnPropertyDescriptor(shadow, key);
+    if (!shadowDescriptor || descriptorsEqual(originalDescriptor, shadowDescriptor))
+      continue;
+    Object.defineProperty(contribution, key, shadowDescriptor);
+  }
+  return contribution;
+}
+function prepareContextContribution(value, scope) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw contributionError(scope, "expected a plain record");
+  }
+  let prototype;
+  let descriptors;
+  let keys;
+  try {
+    prototype = Object.getPrototypeOf(value);
+    descriptors = Object.getOwnPropertyDescriptors(value);
+    keys = Reflect.ownKeys(value);
+  } catch {
+    throw contributionError(scope, "record inspection failed");
+  }
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw contributionError(scope, "expected Object.prototype or null prototype");
+  }
+  const prepared = Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string") {
+      throw contributionError(scope, "symbol keys are not supported");
+    }
+    if (isUnsafeKey(key)) {
+      throw contributionError(scope, `unsafe key ${JSON.stringify(key)}`);
+    }
+    if (RUNTIME_CONTEXT_RESERVED_KEYS.has(key)) {
+      throw contributionError(scope, `reserved key ${JSON.stringify(key)}`);
+    }
+    const descriptor = descriptors[key];
+    if (!descriptor?.enumerable || !("value" in descriptor)) {
+      throw contributionError(scope, `key ${JSON.stringify(key)} must be enumerable data`);
+    }
+    prepared[key] = descriptor.value;
+  }
+  return prepared;
+}
+function mergeContextContribution(ctx, value, scope) {
+  Object.assign(ctx, prepareContextContribution(value, scope));
+}
+
 // src/server/request-body.ts
 function requestAbortReason(req) {
   return req.signal.reason ?? new DOMException("The connection was closed", "AbortError");
@@ -2044,6 +2159,68 @@ async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
   return dispatchEndpoint(state, request, match);
 }
 
+// src/server/implement-registry.ts
+function createScopedImplementRegistry() {
+  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
+}
+function isImplementationContract(value) {
+  return isRecord(value) && isRecord(value.meta) && typeof value.meta.prefix === "string" && isRecord(value.endpoints);
+}
+function bindRegistry(contracts, handlers, options) {
+  const contractKeys = Object.keys(contracts);
+  const handlerKeys = Object.keys(handlers);
+  const missing = contractKeys.filter((key) => !Object.hasOwn(handlers, key));
+  const extra = handlerKeys.filter((key) => !Object.hasOwn(contracts, key));
+  if (missing.length > 0 || extra.length > 0) {
+    if (options?.onMissingHandler !== "stub") {
+      throw new Error(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"})`);
+    }
+    console.warn(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"}) — missing contracts are mounted as 501 stubs and extra handlers are ignored`);
+  }
+  const prefixes = new Map;
+  const services = [];
+  const byKey = {};
+  for (const [key, candidate] of Object.entries(contracts)) {
+    if (!isImplementationContract(candidate)) {
+      throw new TypeError(`[stitchkit] implementRegistry: registry entry "${key}" must be one contract; composed arrays and namespaces are not supported`);
+    }
+    const contract = candidate;
+    const groupScope = contract.meta.scope ?? "public";
+    const identity = `${groupScope}\x00${contract.meta.prefix}`;
+    const previousKey = prefixes.get(identity);
+    if (previousKey !== undefined) {
+      throw new Error(`[stitchkit] implementRegistry: duplicate contract prefix "${contract.meta.prefix}" in scope "${groupScope}" at "${previousKey}" and "${key}"`);
+    }
+    prefixes.set(identity, key);
+    const entryHandlers = handlers[key] === undefined && options?.onMissingHandler === "stub" ? {} : handlers[key];
+    if (!isRecord(entryHandlers)) {
+      throw new TypeError(`[stitchkit] implementRegistry: handlers for "${key}" must be an object`);
+    }
+    const endpointKeys = Object.keys(contract.endpoints);
+    const handlerEntryKeys = Object.keys(entryHandlers);
+    const missingEndpoints = endpointKeys.filter((endpointKey) => !Object.hasOwn(entryHandlers, endpointKey));
+    const extraEndpoints = handlerEntryKeys.filter((endpointKey) => !Object.hasOwn(contract.endpoints, endpointKey));
+    if (missingEndpoints.length > 0 || extraEndpoints.length > 0) {
+      const detail = `handlers for "${key}" mismatch (missing: ${missingEndpoints.join(", ") || "none"}; extra: ${extraEndpoints.join(", ") || "none"})`;
+      if (options?.onMissingHandler !== "stub") {
+        throw new Error(`[stitchkit] implementRegistry: ${detail}`);
+      }
+      console.warn(`[stitchkit] implementRegistry: ${detail} — missing endpoints are mounted as 501 stubs and extra handlers are ignored`);
+    }
+    const service = bindContract(contract, entryHandlers, options);
+    services.push(service);
+    byKey[key] = service;
+  }
+  Object.defineProperty(services, "byKey", { value: byKey, enumerable: false });
+  return transportResult(services);
+}
+function implementRegistry(contracts, handlers, options) {
+  return transportResult(bindRegistry(contracts, handlers, options));
+}
+function createImplementRegistry() {
+  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
+}
+
 // src/server/process-signals.ts
 var bound = new WeakSet;
 function bindProcessSignals(handle, options = {}) {
@@ -2556,20 +2733,11 @@ function incomingResponseBody(response, maxBytes, onDone) {
   }, { highWaterMark: 1 });
 }
 
-// src/server/unix-client-bun.ts
+// src/server/unix-client-http1.ts
 var MAX_BODY_CHUNK_BYTES = 64 * 1024;
-function isBunUnixRuntime(candidate) {
-  if (typeof candidate !== "object" || candidate === null)
-    return false;
-  return typeof Reflect.get(candidate, "connect") === "function";
-}
-function runtimeBun() {
-  const candidate = Reflect.get(globalThis, "Bun");
-  return isBunUnixRuntime(candidate) ? candidate : undefined;
-}
-function hasBunUnixRuntime() {
-  return runtimeBun() !== undefined;
-}
+var MAX_CHUNK_HEADER_BYTES = 1024;
+var CRLF2 = [13, 10];
+var CRLFCRLF = [13, 10, 13, 10];
 function concatBytes2(left, right) {
   if (left.byteLength === 0)
     return right.slice();
@@ -2589,6 +2757,27 @@ function indexOfSequence(bytes, sequence) {
     }
   return -1;
 }
+
+class WireBuffer {
+  bytes = new Uint8Array;
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  append(data) {
+    this.bytes = concatBytes2(this.bytes, data);
+  }
+  take(count) {
+    const value = this.bytes.slice(0, count);
+    this.bytes = this.bytes.slice(count);
+    return value;
+  }
+  indexOf(sequence) {
+    return indexOfSequence(this.bytes, sequence);
+  }
+  startsWith(sequence) {
+    return sequence.every((byte, index) => this.bytes[index] === byte);
+  }
+}
 function requestBytes(request, body) {
   const url = new URL(request.url);
   const headers = new Headers(request.headers);
@@ -2620,6 +2809,213 @@ function parseContentLength(headers) {
   }
   return value;
 }
+function readResponseHead(wire, maxHeaderBytes) {
+  const headerEnd = wire.indexOf(CRLFCRLF);
+  if (headerEnd < 0) {
+    return wire.byteLength > maxHeaderBytes ? { kind: "too-large" } : { kind: "more" };
+  }
+  if (headerEnd + 4 > maxHeaderBytes)
+    return { kind: "too-large" };
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(wire.take(headerEnd));
+  } catch (error) {
+    return { kind: "malformed", error };
+  }
+  wire.take(4);
+  const lines = text.split(`\r
+`);
+  const statusLine = lines.shift() ?? "";
+  const matched = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
+  if (!matched) {
+    return {
+      kind: "malformed",
+      error: new Error("Unix response has an invalid HTTP status line")
+    };
+  }
+  const headers = new Headers;
+  let contentLength;
+  try {
+    for (const line of lines) {
+      const separator = line.indexOf(":");
+      if (separator <= 0)
+        throw new Error("Unix response has an invalid header line");
+      headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+    }
+    contentLength = parseContentLength(headers);
+  } catch (error) {
+    return { kind: "malformed", error };
+  }
+  return {
+    kind: "head",
+    status: Number(matched[1]),
+    statusText: matched[2] ?? "",
+    headers,
+    contentLength,
+    chunked: headers.get("transfer-encoding")?.toLowerCase().includes("chunked") ?? false
+  };
+}
+var malformed = (message) => ({
+  kind: "malformed",
+  error: new Error(message)
+});
+
+class BodyDecoder {
+  chunked;
+  remainingLength;
+  maxHeaderBytes;
+  chunkRemaining;
+  expectChunkCrlf = false;
+  trailers = false;
+  constructor(chunked, remainingLength, maxHeaderBytes) {
+    this.chunked = chunked;
+    this.remainingLength = remainingLength;
+    this.maxHeaderBytes = maxHeaderBytes;
+  }
+  next(wire, peerEnded) {
+    return this.chunked ? this.nextChunked(wire, peerEnded) : this.nextPlain(wire, peerEnded);
+  }
+  nextPlain(wire, peerEnded) {
+    if (wire.byteLength > 0) {
+      const permitted = this.remainingLength ?? wire.byteLength;
+      const bytes = Math.min(permitted, wire.byteLength, MAX_BODY_CHUNK_BYTES);
+      if (this.remainingLength !== undefined)
+        this.remainingLength -= bytes;
+      return { kind: "data", value: wire.take(bytes) };
+    }
+    if (this.remainingLength === 0)
+      return { kind: "complete" };
+    if (!peerEnded)
+      return { kind: "more" };
+    return this.remainingLength !== undefined && this.remainingLength > 0 ? malformed("Unix response ended before Content-Length bytes arrived") : { kind: "complete" };
+  }
+  get plainComplete() {
+    return !this.chunked && this.remainingLength === 0;
+  }
+  nextChunked(wire, peerEnded) {
+    for (;; ) {
+      if (this.trailers)
+        return this.readTrailers(wire, peerEnded);
+      if (this.expectChunkCrlf) {
+        if (wire.byteLength < 2) {
+          return peerEnded ? malformed("Unix chunked response ended before chunk delimiter") : { kind: "more" };
+        }
+        if (!wire.startsWith(CRLF2)) {
+          return malformed("Unix chunked response has an invalid chunk delimiter");
+        }
+        wire.take(2);
+        this.expectChunkCrlf = false;
+      }
+      if (this.chunkRemaining === undefined) {
+        const header = this.readChunkHeader(wire, peerEnded);
+        if (header !== undefined)
+          return header;
+        if (this.trailers)
+          continue;
+      }
+      const remaining = this.chunkRemaining ?? 0;
+      if (wire.byteLength === 0) {
+        return peerEnded ? malformed("Unix chunked response ended inside a chunk") : { kind: "more" };
+      }
+      const bytes = Math.min(remaining, wire.byteLength, MAX_BODY_CHUNK_BYTES);
+      const value = wire.take(bytes);
+      this.chunkRemaining = remaining - bytes;
+      if (this.chunkRemaining === 0) {
+        this.chunkRemaining = undefined;
+        this.expectChunkCrlf = true;
+      }
+      return { kind: "data", value };
+    }
+  }
+  readChunkHeader(wire, peerEnded) {
+    const lineEnd = wire.indexOf(CRLF2);
+    if (lineEnd < 0) {
+      if (wire.byteLength > MAX_CHUNK_HEADER_BYTES)
+        return malformed("Unix chunk header is too large");
+      return peerEnded ? malformed("Unix chunked response ended inside chunk header") : { kind: "more" };
+    }
+    const line = new TextDecoder("ascii", { fatal: true }).decode(wire.take(lineEnd));
+    wire.take(2);
+    const sizeText = line.split(";", 1)[0]?.trim() ?? "";
+    if (!/^[0-9a-f]+$/i.test(sizeText)) {
+      return malformed("Unix chunked response has an invalid chunk size");
+    }
+    const size = Number.parseInt(sizeText, 16);
+    if (!Number.isSafeInteger(size))
+      return malformed("Unix chunk size is not a safe integer");
+    if (size === 0)
+      this.trailers = true;
+    else
+      this.chunkRemaining = size;
+    return;
+  }
+  readTrailers(wire, peerEnded) {
+    if (wire.byteLength >= 2 && wire.startsWith(CRLF2)) {
+      wire.take(2);
+      return { kind: "complete" };
+    }
+    const trailerEnd = wire.indexOf(CRLFCRLF);
+    if (trailerEnd < 0) {
+      if (wire.byteLength > this.maxHeaderBytes)
+        return { kind: "trailers-too-large" };
+      return peerEnded ? malformed("Unix chunked response ended inside trailers") : { kind: "more" };
+    }
+    wire.take(trailerEnd + 4);
+    return { kind: "complete" };
+  }
+}
+
+// src/server/unix-client-bun.ts
+function isBunUnixRuntime(candidate) {
+  if (typeof candidate !== "object" || candidate === null)
+    return false;
+  return typeof Reflect.get(candidate, "connect") === "function";
+}
+function runtimeBun() {
+  const candidate = Reflect.get(globalThis, "Bun");
+  return isBunUnixRuntime(candidate) ? candidate : undefined;
+}
+function hasBunUnixRuntime() {
+  return runtimeBun() !== undefined;
+}
+function classifyTransportFailure(error, headersReceived, dispatched) {
+  if (error instanceof UnixClientTransportError)
+    return error;
+  if (headersReceived) {
+    return new UnixClientTransportError("UNIX_RESPONSE_ABORTED", "Unix response failed before completion", "response-received", { cause: error });
+  }
+  return new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error });
+}
+function limitError(limit, what, bytes) {
+  return limit === "body" ? new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${bytes} byte limit`, "response-received") : new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response ${what} exceed the ${bytes} byte limit`, "response-received");
+}
+function socketHandlers(events) {
+  return {
+    binaryType: "uint8array",
+    open: events.open,
+    drain: events.flush,
+    data(active, data) {
+      active.pause();
+      events.data(data);
+    },
+    end: () => events.ended(undefined, "ended"),
+    close: (_active, error) => events.ended(error, "closed"),
+    error: (_active, error) => events.failed(error),
+    connectError: (_active, error) => events.failed(error)
+  };
+}
+function writeAvailable(active, bytes, offset) {
+  let written = offset;
+  while (written < bytes.byteLength) {
+    const count = active.write(bytes, written, bytes.byteLength - written);
+    if (count < 0)
+      return "closed";
+    if (count === 0)
+      break;
+    written += count;
+  }
+  return written;
+}
 function bunUnixRequest(options) {
   const outgoing = requestBytes(options.request, options.body);
   const bun = runtimeBun();
@@ -2627,17 +3023,13 @@ function bunUnixRequest(options) {
     throw new Error("Bun Unix runtime is unavailable");
   let socket;
   let controller;
-  let wire = new Uint8Array;
+  const wire = new WireBuffer;
+  let decoder2;
   let responseResolved = false;
   let headersReceived = false;
   let settled = false;
   let bodyComplete = false;
   let peerEnded = false;
-  let chunked = false;
-  let chunkRemaining;
-  let expectChunkCrlf = false;
-  let trailers = false;
-  let remainingLength;
   let received = 0;
   let writeOffset = 0;
   let resolveResponse = () => {
@@ -2650,15 +3042,7 @@ function bunUnixRequest(options) {
     resolveResponse = resolve;
     rejectResponse = reject;
   });
-  const transportFailure = (error) => {
-    if (error instanceof UnixClientTransportError)
-      return error;
-    if (headersReceived) {
-      return new UnixClientTransportError("UNIX_RESPONSE_ABORTED", "Unix response failed before completion", "response-received", { cause: error });
-    }
-    const dispatched = writeOffset > 0;
-    return new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error });
-  };
+  const transportFailure = (error) => classifyTransportFailure(error, headersReceived, writeOffset > 0);
   const clearRegistration = options.registerAbort(() => {
     fail(new UnixClientTransportError("UNIX_CLIENT_CLOSED", "Unix client transport is closed"));
   });
@@ -2691,16 +3075,11 @@ function bunUnixRequest(options) {
   function abortRequest() {
     fail(options.request.signal.reason ?? new DOMException("Request aborted", "AbortError"));
   }
-  const takeWire = (bytes) => {
-    const value = wire.slice(0, bytes);
-    wire = wire.slice(bytes);
-    return value;
-  };
   const enqueue = (value) => {
     if (options.maxResponseBytes !== undefined)
       received += value.byteLength;
     if (options.maxResponseBytes !== undefined && received > options.maxResponseBytes) {
-      fail(new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${options.maxResponseBytes} byte limit`, "response-received"));
+      fail(limitError("body", "body", options.maxResponseBytes));
       return;
     }
     controller?.enqueue(value);
@@ -2717,186 +3096,51 @@ function bunUnixRequest(options) {
       return;
     socket?.resume();
   };
-  const pumpChunked = () => {
-    if (!controller || settled || bodyComplete)
-      return;
-    for (;; ) {
+  const headersTooLarge = (what) => limitError("headers", what, options.maxHeaderBytes);
+  const pump = () => {
+    while (controller && decoder2 && !settled && !bodyComplete) {
       if ((controller.desiredSize ?? 1) <= 0)
         return;
-      if (trailers) {
-        if (wire.byteLength >= 2 && wire[0] === 13 && wire[1] === 10) {
-          takeWire(2);
+      const step = decoder2.next(wire, peerEnded);
+      if (step.kind === "data") {
+        enqueue(step.value);
+        if (!settled && decoder2.plainComplete)
           completeBody();
-          return;
-        }
-        const trailerEnd = indexOfSequence(wire, [13, 10, 13, 10]);
-        if (trailerEnd < 0) {
-          if (wire.byteLength > options.maxHeaderBytes) {
-            fail(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response trailers exceed the ${options.maxHeaderBytes} byte limit`, "response-received"));
-          } else if (peerEnded) {
-            fail(transportFailure(new Error("Unix chunked response ended inside trailers")));
-          } else {
-            resumeForData();
-          }
-          return;
-        }
-        takeWire(trailerEnd + 4);
+      } else if (step.kind === "more")
+        resumeForData();
+      else if (step.kind === "complete")
         completeBody();
-        return;
-      }
-      if (expectChunkCrlf) {
-        if (wire.byteLength < 2) {
-          if (peerEnded) {
-            fail(transportFailure(new Error("Unix chunked response ended before chunk delimiter")));
-          } else
-            resumeForData();
-          return;
-        }
-        if (wire[0] !== 13 || wire[1] !== 10) {
-          fail(transportFailure(new Error("Unix chunked response has an invalid chunk delimiter")));
-          return;
-        }
-        takeWire(2);
-        expectChunkCrlf = false;
-      }
-      if (chunkRemaining === undefined) {
-        const lineEnd = indexOfSequence(wire, [13, 10]);
-        if (lineEnd < 0) {
-          if (wire.byteLength > 1024) {
-            fail(transportFailure(new Error("Unix chunk header is too large")));
-          } else if (peerEnded) {
-            fail(transportFailure(new Error("Unix chunked response ended inside chunk header")));
-          } else
-            resumeForData();
-          return;
-        }
-        const line = new TextDecoder("ascii", { fatal: true }).decode(takeWire(lineEnd));
-        takeWire(2);
-        const sizeText = line.split(";", 1)[0]?.trim() ?? "";
-        if (!/^[0-9a-f]+$/i.test(sizeText)) {
-          fail(transportFailure(new Error("Unix chunked response has an invalid chunk size")));
-          return;
-        }
-        chunkRemaining = Number.parseInt(sizeText, 16);
-        if (!Number.isSafeInteger(chunkRemaining)) {
-          fail(transportFailure(new Error("Unix chunk size is not a safe integer")));
-          return;
-        }
-        if (chunkRemaining === 0) {
-          chunkRemaining = undefined;
-          trailers = true;
-          continue;
-        }
-      }
-      if (wire.byteLength === 0) {
-        if (peerEnded) {
-          fail(transportFailure(new Error("Unix chunked response ended inside a chunk")));
-        } else
-          resumeForData();
-        return;
-      }
-      const bytes = Math.min(chunkRemaining, wire.byteLength, MAX_BODY_CHUNK_BYTES);
-      const value = takeWire(bytes);
-      chunkRemaining -= bytes;
-      if (chunkRemaining === 0) {
-        chunkRemaining = undefined;
-        expectChunkCrlf = true;
-      }
-      enqueue(value);
-      return;
-    }
-  };
-  const pumpPlain = () => {
-    if (!controller || settled || bodyComplete)
-      return;
-    if ((controller.desiredSize ?? 1) <= 0)
-      return;
-    if (wire.byteLength > 0) {
-      const permitted = remainingLength ?? wire.byteLength;
-      const bytes = Math.min(permitted, wire.byteLength, MAX_BODY_CHUNK_BYTES);
-      enqueue(takeWire(bytes));
-      if (settled)
-        return;
-      if (remainingLength !== undefined) {
-        remainingLength -= bytes;
-        if (remainingLength === 0) {
-          completeBody();
-          return;
-        }
-      }
-      return;
-    }
-    if (peerEnded) {
-      if (remainingLength !== undefined && remainingLength > 0) {
-        fail(transportFailure(new Error("Unix response ended before Content-Length bytes arrived")));
-      } else {
-        completeBody();
-      }
+      else if (step.kind === "malformed")
+        fail(transportFailure(step.error));
+      else
+        fail(headersTooLarge("trailers"));
       return;
     }
-    resumeForData();
-  };
-  const pump = () => {
-    if (chunked)
-      pumpChunked();
-    else
-      pumpPlain();
   };
   const parseHeaders = () => {
-    const headerEnd = indexOfSequence(wire, [13, 10, 13, 10]);
-    if (headerEnd < 0) {
-      if (wire.byteLength > options.maxHeaderBytes) {
-        fail(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${options.maxHeaderBytes} byte limit`, "response-received"));
-      } else {
+    const head = readResponseHead(wire, options.maxHeaderBytes);
+    if (head.kind !== "head") {
+      if (head.kind === "malformed")
+        headersReceived = true;
+      if (head.kind === "more")
         socket?.resume();
-      }
-      return;
-    }
-    if (headerEnd + 4 > options.maxHeaderBytes) {
-      fail(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${options.maxHeaderBytes} byte limit`, "response-received"));
+      else if (head.kind === "too-large")
+        fail(headersTooLarge("headers"));
+      else
+        fail(transportFailure(head.error));
       return;
     }
     headersReceived = true;
-    let text;
-    try {
-      text = new TextDecoder("utf-8", { fatal: true }).decode(takeWire(headerEnd));
-    } catch (error) {
-      fail(transportFailure(error));
-      return;
-    }
-    takeWire(4);
-    const lines = text.split(`\r
-`);
-    const statusLine = lines.shift() ?? "";
-    const matched = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
-    if (!matched) {
-      fail(transportFailure(new Error("Unix response has an invalid HTTP status line")));
+    const { status, statusText, headers, contentLength } = head;
+    if (options.maxResponseBytes !== undefined && contentLength !== undefined && contentLength > options.maxResponseBytes) {
+      fail(limitError("body", "body", options.maxResponseBytes));
       return;
     }
-    const status = Number(matched[1]);
-    const statusText = matched[2] ?? "";
-    const headers = new Headers;
-    try {
-      for (const line of lines) {
-        const separator = line.indexOf(":");
-        if (separator <= 0)
-          throw new Error("Unix response has an invalid header line");
-        headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
-      }
-      remainingLength = parseContentLength(headers);
-    } catch (error) {
-      fail(transportFailure(error));
-      return;
-    }
-    if (options.maxResponseBytes !== undefined && remainingLength !== undefined && remainingLength > options.maxResponseBytes) {
-      fail(new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${options.maxResponseBytes} byte limit`, "response-received"));
-      return;
-    }
-    chunked = headers.get("transfer-encoding")?.toLowerCase().includes("chunked") ?? false;
+    decoder2 = new BodyDecoder(head.chunked, contentLength, options.maxHeaderBytes);
     const bodyless = options.request.method === "HEAD" || status === 204 || status === 205 || status === 304;
     clearTimeout(timer);
     responseResolved = true;
-    if (bodyless || remainingLength === 0) {
+    if (bodyless || contentLength === 0) {
       resolveResponse(new Response(null, { status, statusText, headers }));
       finish();
       return;
@@ -2916,16 +3160,11 @@ function bunUnixRequest(options) {
     resolveResponse(new Response(body, { status, statusText, headers }));
   };
   const flushRequest = (active) => {
-    while (writeOffset < outgoing.byteLength) {
-      const written = active.write(outgoing, writeOffset, outgoing.byteLength - writeOffset);
-      if (written < 0) {
-        fail(transportFailure(new Error("Unix request socket closed while writing")));
-        return;
-      }
-      if (written === 0)
-        return;
-      writeOffset += written;
-    }
+    const next = writeAvailable(active, outgoing, writeOffset);
+    if (next === "closed") {
+      fail(transportFailure(new Error("Unix request socket closed while writing")));
+    } else
+      writeOffset = next;
   };
   if (options.request.signal.aborted) {
     fail(options.request.signal.reason ?? new DOMException("Request aborted", "AbortError"));
@@ -2934,52 +3173,35 @@ function bunUnixRequest(options) {
   options.request.signal.addEventListener("abort", abortRequest, { once: true });
   bun.connect({
     unix: options.socketPath,
-    socket: {
-      binaryType: "uint8array",
+    socket: socketHandlers({
       open(active) {
         socket = active;
-        if (settled) {
+        if (settled)
           active.terminate();
-          return;
-        }
-        flushRequest(active);
-      },
-      drain(active) {
-        flushRequest(active);
+        else
+          flushRequest(active);
       },
-      data(active, data) {
-        active.pause();
-        wire = concatBytes2(wire, data);
+      flush: flushRequest,
+      data(data) {
+        wire.append(data);
         if (!responseResolved)
           parseHeaders();
         else
           pump();
       },
-      end() {
-        peerEnded = true;
-        if (!responseResolved) {
-          fail(transportFailure(new Error("Unix connection ended before response headers")));
-        } else
-          pump();
-      },
-      close(_active, error) {
+      ended(error, how) {
         peerEnded = true;
         if (settled)
           return;
         if (error)
           fail(transportFailure(error));
         else if (!responseResolved) {
-          fail(transportFailure(new Error("Unix connection closed before response headers")));
+          fail(transportFailure(new Error(`Unix connection ${how} before response headers`)));
         } else
           pump();
       },
-      error(_active, error) {
-        fail(transportFailure(error));
-      },
-      connectError(_active, error) {
-        fail(transportFailure(error));
-      }
-    }
+      failed: (error) => fail(transportFailure(error))
+    })
   }).catch((error) => fail(transportFailure(error)));
   return response;
 }
@@ -3043,7 +3265,7 @@ function redirectedRequest(request, location, status, body) {
     signal: request.signal
   });
 }
-function createUnixClientTransport(config) {
+function resolveUnixClientLimits(config) {
   if (!config.socketPath.startsWith("/") || config.socketPath.includes("\x00")) {
     throw new TypeError("socketPath must be an absolute Unix socket path");
   }
@@ -3056,6 +3278,92 @@ function createUnixClientTransport(config) {
   const maxConnections = positiveInteger(config.maxConnections, DEFAULT_MAX_CONNECTIONS, "maxConnections");
   const maxHeaderBytes = positiveInteger(config.maxHeaderBytes, DEFAULT_MAX_HEADER_BYTES2, "maxHeaderBytes");
   const maxRedirects = nonNegativeInteger(config.maxRedirects, DEFAULT_MAX_REDIRECTS, "maxRedirects");
+  return {
+    maxRequestBytes,
+    maxResponseBytes,
+    headersTimeoutMs,
+    maxConnections,
+    maxHeaderBytes,
+    maxRedirects
+  };
+}
+function redirectStep(request, status, location, redirectCount, maxRedirects) {
+  if (!location || !isRedirect(status))
+    return "return";
+  if (request.redirect === "error" || redirectCount >= maxRedirects) {
+    throw new UnixClientTransportError("UNIX_REDIRECT_REFUSED", redirectCount >= maxRedirects ? `Unix redirect limit ${maxRedirects} exceeded` : "Unix request redirect mode is error", "response-received");
+  }
+  return request.redirect === "follow" ? "follow" : "return";
+}
+function nodeUnixRequest(input) {
+  const { request, url, headersTimeoutMs, maxHeaderBytes, activeRequests } = input;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const resolveOnce = (response) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve(response);
+    };
+    const rejectOnce = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      reject(error);
+    };
+    const outgoing = httpRequest({
+      socketPath: input.socketPath,
+      path: `${url.pathname}${url.search}`,
+      method: request.method,
+      headers: input.headers,
+      agent: input.agent,
+      signal: request.signal,
+      maxHeaderSize: maxHeaderBytes
+    }, resolveOnce);
+    let connected = false;
+    let requestStartBytes = 0;
+    outgoing.once("socket", (socket) => {
+      requestStartBytes = socket.bytesWritten;
+      if (!socket.connecting && !socket.destroyed)
+        connected = true;
+      else {
+        socket.once("connect", () => {
+          connected = true;
+        });
+      }
+    });
+    activeRequests.add(outgoing);
+    const timer = setTimeout(() => {
+      const error = new UnixClientTransportError("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${headersTimeoutMs}ms`);
+      rejectOnce(error);
+      outgoing.destroy(error);
+    }, headersTimeoutMs);
+    timer.unref();
+    outgoing.once("response", () => clearTimeout(timer));
+    outgoing.once("error", (error) => {
+      if (isNodeHeaderOverflow(error)) {
+        rejectOnce(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${maxHeaderBytes} byte limit`, "response-received", { cause: error }));
+        return;
+      }
+      const dispatched = connected && (outgoing.socket?.bytesWritten ?? requestStartBytes) > requestStartBytes;
+      rejectOnce(new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error }));
+    });
+    outgoing.once("close", () => {
+      clearTimeout(timer);
+      activeRequests.delete(outgoing);
+    });
+    outgoing.end(input.body);
+  });
+}
+function createUnixClientTransport(config) {
+  const {
+    maxRequestBytes,
+    maxResponseBytes,
+    headersTimeoutMs,
+    maxConnections,
+    maxHeaderBytes,
+    maxRedirects
+  } = resolveUnixClientLimits(config);
   const agent = new Agent({ keepAlive: true, maxSockets: maxConnections });
   const activeRequests = new Set;
   const activeResponses = new Set;
@@ -3089,15 +3397,16 @@ function createUnixClientTransport(config) {
         }
       });
       const location2 = response.headers.get("location");
-      if (location2 && isRedirect(response.status)) {
-        if (request.redirect === "error" || redirectCount >= maxRedirects) {
-          await response.body?.cancel();
-          throw new UnixClientTransportError("UNIX_REDIRECT_REFUSED", redirectCount >= maxRedirects ? `Unix redirect limit ${maxRedirects} exceeded` : "Unix request redirect mode is error", "response-received");
-        }
-        if (request.redirect === "follow") {
-          await response.body?.cancel();
-          return dispatch2(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
-        }
+      let step2;
+      try {
+        step2 = redirectStep(request, response.status, location2, redirectCount, maxRedirects);
+      } catch (error) {
+        await response.body?.cancel();
+        throw error;
+      }
+      if (step2 === "follow" && location2) {
+        await response.body?.cancel();
+        return dispatch2(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
       }
       return response;
     }
@@ -3105,62 +3414,16 @@ function createUnixClientTransport(config) {
     if (!Object.keys(headers).some((name) => name.toLowerCase() === "host")) {
       headers.host = url.host;
     }
-    const incoming = await new Promise((resolve, reject) => {
-      let settled = false;
-      const resolveOnce = (response) => {
-        if (settled)
-          return;
-        settled = true;
-        resolve(response);
-      };
-      const rejectOnce = (error) => {
-        if (settled)
-          return;
-        settled = true;
-        reject(error);
-      };
-      const outgoing = httpRequest({
-        socketPath: config.socketPath,
-        path: `${url.pathname}${url.search}`,
-        method: request.method,
-        headers,
-        agent,
-        signal: request.signal,
-        maxHeaderSize: maxHeaderBytes
-      }, resolveOnce);
-      let connected = false;
-      let requestStartBytes = 0;
-      outgoing.once("socket", (socket) => {
-        requestStartBytes = socket.bytesWritten;
-        if (!socket.connecting && !socket.destroyed)
-          connected = true;
-        else {
-          socket.once("connect", () => {
-            connected = true;
-          });
-        }
-      });
-      activeRequests.add(outgoing);
-      const timer = setTimeout(() => {
-        const error = new UnixClientTransportError("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${headersTimeoutMs}ms`);
-        rejectOnce(error);
-        outgoing.destroy(error);
-      }, headersTimeoutMs);
-      timer.unref();
-      outgoing.once("response", () => clearTimeout(timer));
-      outgoing.once("error", (error) => {
-        if (isNodeHeaderOverflow(error)) {
-          rejectOnce(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${maxHeaderBytes} byte limit`, "response-received", { cause: error }));
-          return;
-        }
-        const dispatched = connected && (outgoing.socket?.bytesWritten ?? requestStartBytes) > requestStartBytes;
-        rejectOnce(new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error }));
-      });
-      outgoing.once("close", () => {
-        clearTimeout(timer);
-        activeRequests.delete(outgoing);
-      });
-      outgoing.end(body);
+    const incoming = await nodeUnixRequest({
+      socketPath: config.socketPath,
+      url,
+      request,
+      headers,
+      body,
+      agent,
+      maxHeaderBytes,
+      headersTimeoutMs,
+      activeRequests
     });
     activeResponses.add(incoming);
     const releaseResponse = () => void activeResponses.delete(incoming);
@@ -3173,17 +3436,18 @@ function createUnixClientTransport(config) {
       throw new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${maxResponseBytes} byte limit`, "response-received");
     }
     const location = responseHeadersValue.get("location");
-    if (location && isRedirect(status)) {
-      if (request.redirect === "error" || redirectCount >= maxRedirects) {
-        incoming.destroy();
-        releaseResponse();
-        throw new UnixClientTransportError("UNIX_REDIRECT_REFUSED", redirectCount >= maxRedirects ? `Unix redirect limit ${maxRedirects} exceeded` : "Unix request redirect mode is error", "response-received");
-      }
-      if (request.redirect === "follow") {
-        incoming.destroy();
-        releaseResponse();
-        return dispatch2(redirectedRequest(request, location, status, body), redirectCount + 1);
-      }
+    let step;
+    try {
+      step = redirectStep(request, status, location, redirectCount, maxRedirects);
+    } catch (error) {
+      incoming.destroy();
+      releaseResponse();
+      throw error;
+    }
+    if (step === "follow" && location) {
+      incoming.destroy();
+      releaseResponse();
+      return dispatch2(redirectedRequest(request, location, status, body), redirectCount + 1);
     }
     const bodyless = request.method === "HEAD" || status === 204 || status === 205 || status === 304;
     if (bodyless) {
@@ -3226,4 +3490,4 @@ function createUnixClientTransport(config) {
   };
 }
 
-export { parseMultipart, DEFAULT_STREAM_HEARTBEAT_MS, streamingRoute, ndjsonRoute, sseRoute, createHandler, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane, UnixClientTransportError, createUnixClientTransport };
+export { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart, DEFAULT_STREAM_HEARTBEAT_MS, streamingRoute, ndjsonRoute, sseRoute, createHandler, createScopedImplementRegistry, implementRegistry, createImplementRegistry, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane, UnixClientTransportError, createUnixClientTransport };