stitchkit 0.100.1 → 0.100.3

package/dist/{index-hadmp193.js → index-3ct7hhq6.js}

@@ -1,71 +1,71 @@
 import {
-  RELEASE_HEADER
-} from "./index-y91ry9h2.js";
+  AppError2,
+  badRequest2,
+  forbidden2
+} from "./index-n53mswt3.js";
 import {
-  ShutdownOptionsSchema,
   isStreamCancellation,
   ownHttpStream,
-  settleStreamCleanup
-} from "./index-3z73fh2c.js";
+  settleStreamCleanup,
+  ShutdownOptionsSchema2
+} from "./index-q0th8q0z.js";
 import {
-  createValidatedRealtimeSocket,
-  isModuleNotFound
-} from "./index-ndddxtyx.js";
+  errorCode2,
+  recordedErrorMessage,
+  normalizeError2,
+  validateDeclaredOutput
+} from "./index-b2bz0kdm.js";
 import {
-  DEFAULT_CONTRACT_STREAM_FRAME_BYTES
-} from "./index-wqgjfstn.js";
+  resolveTraceContext2
+} from "./index-hby4qhax.js";
 import {
-  DEFAULT_PROCESS_SIGNALS,
-  applyCors,
-  assertCorsConfig,
-  bindContract,
-  corsPreflightResponse,
-  defaultSignalSource,
-  guardSignalCallback,
-  isOriginAllowed,
-  mediaTypeEssence,
-  reportSignalError,
-  requestCorsHeaders
-} from "./index-2gxzjvyr.js";
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES2
+} from "./index-r5c4fedv.js";
 import {
   joinRoutePath,
   parseTrailingWildcard
-} from "./index-4gcnakhx.js";
+} from "./index-m38ej7e5.js";
 import {
-  getRequestContext,
-  runWithRequestContext,
-  setRequestEndpoint,
-  setRequestError
-} from "./index-zfrhfn82.js";
+  createValidatedRealtimeSocket,
+  isModuleNotFound
+} from "./index-m79yr938.js";
 import {
-  extractIp,
-  getClientInfo,
-  parseQueryParams,
-  resolveSocketIp,
-  resolveTraceId
-} from "./index-35mh5bhj.js";
+  RELEASE_HEADER2
+} from "./index-n15jny5b.js";
 import {
-  resolveTraceContext
-} from "./index-zcgf3gqf.js";
+  assertCorsConfig,
+  isOriginAllowed,
+  corsPreflightResponse2,
+  requestCorsHeaders,
+  applyCors,
+  bindContract,
+  DEFAULT_PROCESS_SIGNALS,
+  defaultSignalSource,
+  reportSignalError,
+  guardSignalCallback,
+  mediaTypeEssence
+} from "./index-afjvjyck.js";
 import {
-  errorCode,
-  normalizeError,
-  recordedErrorMessage,
-  validateDeclaredOutput
-} from "./index-znfs20ss.js";
+  runWithRequestContext2,
+  getRequestContext2,
+  setRequestEndpoint2,
+  setRequestError2
+} from "./index-r1z0rd9c.js";
 import {
-  AppError,
-  badRequest,
-  forbidden
-} from "./index-2vtcmrj9.js";
+  resolveTraceId2,
+  resolveSocketIp2,
+  extractIp2,
+  getClientInfo2,
+  parseQueryParams
+} from "./index-kw1ws0cs.js";
 import {
   isUnsafeKey,
   safeJsonParse
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord,
   transportResult
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/server/multipart-reader.ts
 var DEFAULT_MAX_HEADER_BYTES = 64 * 1024;
@@ -119,40 +119,40 @@ function concatBytes(left, right) {
 function parseBoundary(req) {
   const contentType = req.headers.get("content-type") ?? "";
   if (!contentType.toLowerCase().startsWith("multipart/form-data")) {
-    badRequest("Request body must be multipart/form-data");
+    badRequest2("Request body must be multipart/form-data");
   }
   const match = /(?:^|;)\s*boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
   const boundary = match?.[1] ?? match?.[2];
   if (!boundary || boundary.length > 200)
-    badRequest("Invalid multipart boundary");
+    badRequest2("Invalid multipart boundary");
   return boundary;
 }
 function parseDisposition(value) {
   if (!value)
-    badRequest("Invalid multipart disposition");
+    badRequest2("Invalid multipart disposition");
   const separator = value.indexOf(";");
   const kind = separator < 0 ? value : value.slice(0, separator);
   if (trimWhitespace(kind).toLowerCase() !== "form-data") {
-    badRequest("Invalid multipart disposition");
+    badRequest2("Invalid multipart disposition");
   }
   const parameters = new Map;
   let rest = separator < 0 ? "" : value.slice(separator);
   while (rest.length > 0) {
     const match = /^;[ \t]*([^=; \t]+)[ \t]*=[ \t]*(?:"((?:[^"\\]|\\.)*)"|([^; \t]+))[ \t]*/.exec(rest);
     if (!match?.[1])
-      badRequest("Invalid multipart disposition parameter");
+      badRequest2("Invalid multipart disposition parameter");
     const key = match[1].toLowerCase();
     if (!TOKEN.test(key) || parameters.has(key)) {
-      badRequest("Invalid or duplicate multipart disposition parameter");
+      badRequest2("Invalid or duplicate multipart disposition parameter");
     }
     const quoted = match[2];
     const raw = match[3] ?? "";
     if (quoted === undefined && !TOKEN.test(raw)) {
-      badRequest("Invalid multipart disposition parameter");
+      badRequest2("Invalid multipart disposition parameter");
     }
     const decoded = quoted === undefined ? raw : quoted.replace(/\\(.)/g, "$1");
     if (hasControl(decoded))
-      badRequest("Invalid multipart disposition parameter");
+      badRequest2("Invalid multipart disposition parameter");
     parameters.set(key, decoded);
     rest = rest.slice(match[0].length);
   }
@@ -162,17 +162,17 @@ function parseDisposition(value) {
   if (extended !== undefined) {
     const match = /^utf-8'[A-Za-z0-9-]*'((?:[!#$&+.^_`|~0-9A-Za-z-]|%[0-9A-Fa-f]{2})*)$/i.exec(extended);
     if (!match)
-      badRequest("Invalid multipart extended filename");
+      badRequest2("Invalid multipart extended filename");
     try {
       filename = decodeURIComponent(match[1] ?? "");
     } catch {
-      badRequest("Invalid multipart extended filename");
+      badRequest2("Invalid multipart extended filename");
     }
     if (hasControl(filename))
-      badRequest("Invalid multipart extended filename");
+      badRequest2("Invalid multipart extended filename");
   }
   if (!name || isUnsafeKey(name))
-    badRequest("Invalid multipart field name");
+    badRequest2("Invalid multipart field name");
   return filename === undefined ? { name } : { name, filename };
 }
 function parsePartHeaders(bytes) {
@@ -180,21 +180,21 @@ function parsePartHeaders(bytes) {
   try {
     text = headerDecoder.decode(bytes);
   } catch {
-    badRequest("Invalid multipart headers");
+    badRequest2("Invalid multipart headers");
   }
   const headers = new Map;
   for (const line of text.split(`\r
 `)) {
     const separator = line.indexOf(":");
     if (separator <= 0)
-      badRequest("Invalid multipart header");
+      badRequest2("Invalid multipart header");
     const name = line.slice(0, separator).toLowerCase();
     const value = trimWhitespace(line.slice(separator + 1));
     if (!TOKEN.test(name) || hasControl(value, true)) {
-      badRequest("Invalid multipart header");
+      badRequest2("Invalid multipart header");
     }
     if (headers.has(name))
-      badRequest("Duplicate multipart header");
+      badRequest2("Duplicate multipart header");
     headers.set(name, value);
   }
   const disposition = parseDisposition(headers.get("content-disposition") ?? undefined);
@@ -202,11 +202,11 @@ function parsePartHeaders(bytes) {
   const contentType = rawContentType?.split(";", 1)[0]?.trim().toLowerCase();
   const rawSize = headers.get("content-length");
   if (rawSize !== undefined && !/^[0-9]+$/.test(rawSize)) {
-    badRequest("Invalid multipart part content-length");
+    badRequest2("Invalid multipart part content-length");
   }
   const declaredSize = rawSize === undefined ? undefined : Number(rawSize);
   if (declaredSize !== undefined && (!Number.isSafeInteger(declaredSize) || declaredSize < 0)) {
-    badRequest("Invalid multipart part content-length");
+    badRequest2("Invalid multipart part content-length");
   }
   return { ...disposition, contentType, declaredSize };
 }
@@ -223,7 +223,7 @@ class MultipartStreamReader {
   #activePart = false;
   constructor(req, boundary, maxRequestBytes) {
     if (!req.body)
-      badRequest("Multipart request body is empty");
+      badRequest2("Multipart request body is empty");
     this.#reader = req.body.getReader();
     this.#delimiter = encoder.encode(`\r
 --${boundary}`);
@@ -233,14 +233,14 @@ class MultipartStreamReader {
   async start() {
     await this.#ensure(this.#initialBoundary.length + 2);
     if (!startsWithBytes(this.#buffer, this.#initialBoundary)) {
-      badRequest("Malformed multipart body");
+      badRequest2("Malformed multipart body");
     }
     this.#consume(this.#initialBoundary.length);
     await this.#consumeBoundarySuffix();
   }
   async nextPart() {
     if (this.#activePart)
-      badRequest("Multipart part stream was not fully consumed");
+      badRequest2("Multipart part stream was not fully consumed");
     if (this.#terminal)
       return null;
     const header = await this.#readUntil(HEADER_END, DEFAULT_MAX_HEADER_BYTES);
@@ -296,7 +296,7 @@ class MultipartStreamReader {
         return { value, end: false };
       }
       if (this.#sourceDone)
-        badRequest("Incomplete multipart body");
+        badRequest2("Incomplete multipart body");
       await this.#readMore();
     }
   }
@@ -310,7 +310,7 @@ class MultipartStreamReader {
       return;
     }
     if (!startsWithBytes(this.#buffer, CRLF))
-      badRequest("Malformed multipart boundary");
+      badRequest2("Malformed multipart boundary");
     this.#consume(2);
   }
   async#readUntil(marker, maxBytes) {
@@ -318,15 +318,15 @@ class MultipartStreamReader {
       const index = indexOfBytes(this.#buffer, marker);
       if (index >= 0) {
         if (index > maxBytes)
-          badRequest("Multipart part headers are too large");
+          badRequest2("Multipart part headers are too large");
         const value = this.#buffer.slice(0, index);
         this.#consume(index + marker.length);
         return value;
       }
       if (this.#buffer.length > maxBytes)
-        badRequest("Multipart part headers are too large");
+        badRequest2("Multipart part headers are too large");
       if (this.#sourceDone)
-        badRequest("Incomplete multipart headers");
+        badRequest2("Incomplete multipart headers");
       await this.#readMore();
     }
   }
@@ -334,7 +334,7 @@ class MultipartStreamReader {
     while (this.#buffer.length < length && !this.#sourceDone)
       await this.#readMore();
     if (this.#buffer.length < length)
-      badRequest("Incomplete multipart body");
+      badRequest2("Incomplete multipart body");
   }
   async#readMore() {
     const result = await this.#reader.read();
@@ -345,7 +345,7 @@ class MultipartStreamReader {
     this.#readBytes += result.value.length;
     if (this.#readBytes > this.#maxRequestBytes) {
       this.cancel();
-      badRequest(`Multipart request exceeds ${this.#maxRequestBytes} bytes`);
+      badRequest2(`Multipart request exceeds ${this.#maxRequestBytes} bytes`);
     }
     this.#buffer = concatBytes(this.#buffer, result.value);
   }
@@ -388,7 +388,7 @@ function limitedStream(stream, maxBytes, label, signal) {
         total += result.value.length;
         if (total > maxBytes) {
           cancelReader();
-          badRequest(`${label} exceeds ${maxBytes} bytes`);
+          badRequest2(`${label} exceeds ${maxBytes} bytes`);
         }
         controller.enqueue(result.value);
       } catch (error) {
@@ -424,7 +424,7 @@ async function readText(stream, maxBytes) {
     total += result.value.length;
     if (total > maxBytes) {
       await reader.cancel();
-      badRequest(`Multipart text field exceeds ${maxBytes} bytes`);
+      badRequest2(`Multipart text field exceeds ${maxBytes} bytes`);
     }
     chunks.push(result.value);
   }
@@ -439,11 +439,11 @@ async function readText(stream, maxBytes) {
 function required(policy) {
   return policy.required !== false;
 }
-async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
+async function parseMultipart2(req, descriptor, fieldsSchema, receivers) {
   const maxRequestBytes = descriptor.maxRequestBytes ?? DEFAULT_MAX_REQUEST_BYTES;
   const contentLength = Number(req.headers.get("content-length"));
   if (Number.isFinite(contentLength) && contentLength > maxRequestBytes) {
-    badRequest(`Multipart request exceeds ${maxRequestBytes} bytes`);
+    badRequest2(`Multipart request exceeds ${maxRequestBytes} bytes`);
   }
   const boundary = parseBoundary(req);
   const parser = new MultipartStreamReader(req, boundary, maxRequestBytes);
@@ -473,39 +473,39 @@ async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
         break;
       partCount += 1;
       if (partCount > DEFAULT_MAX_PARTS)
-        badRequest("Too many multipart parts");
+        badRequest2("Too many multipart parts");
       const policy = descriptor.files[part.name];
       const isFile = part.filename !== undefined || part.contentType !== undefined;
       if (!isFile) {
         if (policy)
-          badRequest(`Multipart file field "${part.name}" must contain a file`);
+          badRequest2(`Multipart file field "${part.name}" must contain a file`);
         if (Object.hasOwn(fields, part.name)) {
-          badRequest(`Duplicate multipart text field: ${part.name}`);
+          badRequest2(`Duplicate multipart text field: ${part.name}`);
         }
         fields[part.name] = await readText(part.stream, descriptor.maxFieldBytes ?? DEFAULT_MAX_FIELD_BYTES);
         continue;
       }
       if (!policy)
-        badRequest(`Unexpected multipart file field: ${part.name}`);
+        badRequest2(`Unexpected multipart file field: ${part.name}`);
       const count = (counts.get(part.name) ?? 0) + 1;
       counts.set(part.name, count);
       const maxFiles = policy.multiple === true ? policy.maxFiles ?? DEFAULT_MAX_PARTS : 1;
       if (count > maxFiles)
-        badRequest(`Too many files for multipart field: ${part.name}`);
+        badRequest2(`Too many files for multipart field: ${part.name}`);
       const contentType = part.contentType ?? "";
       if (policy.contentTypes && !matchesContentType(contentType, policy.contentTypes)) {
-        badRequest(`Unsupported content type for multipart field "${part.name}"`);
+        badRequest2(`Unsupported content type for multipart field "${part.name}"`);
       }
       const maxFileBytes = policy.maxBytes ?? maxRequestBytes;
       if (part.declaredSize !== undefined && part.declaredSize > maxFileBytes) {
-        badRequest(`Multipart field "${part.name}" exceeds ${maxFileBytes} bytes`);
+        badRequest2(`Multipart field "${part.name}" exceeds ${maxFileBytes} bytes`);
       }
       const stream = limitedStream(part.stream, maxFileBytes, `Multipart field "${part.name}"`, req.signal);
       let value;
       if (descriptor.delivery === "stream") {
         const receiver = receivers?.[part.name];
         if (!receiver)
-          badRequest(`Missing multipart receiver for field: ${part.name}`);
+          badRequest2(`Missing multipart receiver for field: ${part.name}`);
         const result = await receiver({
           metadata: {
             field: part.name,
@@ -519,7 +519,7 @@ async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
         cleanups.push(result.cleanup);
         if (!part.consumed()) {
           await stream.cancel();
-          badRequest(`Multipart receiver for "${part.name}" did not consume its stream`);
+          badRequest2(`Multipart receiver for "${part.name}" did not consume its stream`);
         }
         value = result.value;
       } else {
@@ -538,7 +538,7 @@ async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
     for (const [field, policy] of Object.entries(descriptor.files)) {
       const count = counts.get(field) ?? 0;
       if (required(policy) && count === 0)
-        badRequest(`Missing multipart file field: ${field}`);
+        badRequest2(`Missing multipart file field: ${field}`);
       if (policy.multiple === true && count === 0 && !required(policy))
         files[field] = [];
     }
@@ -588,7 +588,7 @@ async function pumpFrames(p) {
       if (!isStreamCancellation(error, p.departed))
         p.pumped.reject(error);
     } else
-      p.send(p.framing.frame(normalizeError(error).toJSON()));
+      p.send(p.framing.frame(normalizeError2(error).toJSON()));
   } finally {
     p.pumped.resolve();
     p.end();
@@ -596,7 +596,7 @@ async function pumpFrames(p) {
 }
 
 // src/server/streaming-route.ts
-var DEFAULT_STREAM_HEARTBEAT_MS = 5000;
+var DEFAULT_STREAM_HEARTBEAT_MS2 = 5000;
 var FRAMINGS = {
   ndjson: {
     contentType: "application/x-ndjson",
@@ -645,7 +645,7 @@ function responseHeaders(framing, extra) {
   return headers;
 }
 function streamingTimings(options) {
-  const heartbeatMs = options.heartbeatMs ?? DEFAULT_STREAM_HEARTBEAT_MS;
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_STREAM_HEARTBEAT_MS2;
   if (!Number.isFinite(heartbeatMs) || heartbeatMs <= 0) {
     throw new TypeError("heartbeatMs must be a finite positive number of milliseconds");
   }
@@ -655,7 +655,7 @@ function streamingTimings(options) {
   }
   return { heartbeatMs, idleTimeoutSeconds };
 }
-function streamingRoute(options) {
+function streamingRoute2(options) {
   const { heartbeatMs, idleTimeoutSeconds } = streamingTimings(options);
   const framing = FRAMINGS[options.format ?? "ndjson"];
   return {
@@ -686,7 +686,7 @@ function streamingRoute(options) {
         settled.reject(error);
         throw error;
       }
-      const encoder2 = new TextEncoder;
+      const encoder = new TextEncoder;
       let heartbeat = null;
       let closed = false;
       const stopHeartbeat = () => {
@@ -729,7 +729,7 @@ function streamingRoute(options) {
             if (closed)
               return false;
             try {
-              controller.enqueue(encoder2.encode(text));
+              controller.enqueue(encoder.encode(text));
               return true;
             } catch {
               release();
@@ -789,11 +789,11 @@ function streamingRoute(options) {
     }
   };
 }
-function ndjsonRoute(options) {
-  return streamingRoute({ ...options, format: "ndjson" });
+function ndjsonRoute2(options) {
+  return streamingRoute2({ ...options, format: "ndjson" });
 }
-function sseRoute(options) {
-  return streamingRoute({ ...options, format: "sse" });
+function sseRoute2(options) {
+  return streamingRoute2({ ...options, format: "sse" });
 }
 
 // src/server/context-contribution.ts
@@ -938,7 +938,7 @@ async function readRequestText(req, maxBytes) {
       total += value.byteLength;
       if (total > maxBytes) {
         await reader.cancel();
-        badRequest(`JSON body exceeds the ${maxBytes}-byte limit`);
+        badRequest2(`JSON body exceeds the ${maxBytes}-byte limit`);
       }
       chunks.push(value);
     }
@@ -963,22 +963,22 @@ function parseJsonBody(req, text, method, cors) {
   const essence = mediaTypeEssence(req.headers.get("content-type"));
   if (essence !== "application/json") {
     if (!method.safelistedBody || essence !== "text/plain") {
-      badRequest("Request body must be application/json");
+      badRequest2("Request body must be application/json");
     }
     const origin = req.headers.get("origin");
     if (!cors || cors.origin === undefined || cors.origin === "*") {
-      forbidden("A text/plain body requires an explicit cors.origin allow-list on the server");
+      forbidden2("A text/plain body requires an explicit cors.origin allow-list on the server");
     }
     if (!origin)
-      forbidden("A text/plain body requires an Origin header");
+      forbidden2("A text/plain body requires an Origin header");
     if (!isOriginAllowed(cors, origin)) {
-      forbidden("A text/plain body is accepted only from an allowed origin");
+      forbidden2("A text/plain body is accepted only from an allowed origin");
     }
   }
   try {
     return safeJsonParse(text);
   } catch {
-    badRequest("Invalid JSON body");
+    badRequest2("Invalid JSON body");
   }
 }
 function buildBaseContext(req, url, pathParams, traceId, clientIp) {
@@ -997,7 +997,7 @@ function buildBaseContext(req, url, pathParams, traceId, clientIp) {
     signal: req.signal,
     ...safePathParams,
     traceId,
-    ...getClientInfo(req, clientIp)
+    ...getClientInfo2(req, clientIp)
   };
 }
 function parsePathParamsInto(ctx, method) {
@@ -1007,7 +1007,7 @@ function parsePathParamsInto(ctx, method) {
 }
 async function parseRequestPayloadInto(ctx, req, url, method, maxJsonBodyBytes, cors) {
   if (method.multipart) {
-    const multipart = await parseMultipart(req, method.multipart, method.inputSchema, method.multipartReceivers);
+    const multipart = await parseMultipart2(req, method.multipart, method.inputSchema, method.multipartReceivers);
     ctx.input = multipart.fields;
     ctx.files = multipart.files;
     return multipart;
@@ -1043,7 +1043,7 @@ function buildErrorContext(req, url, traceId, clientIp) {
     headers: req.headers,
     signal: req.signal,
     traceId,
-    ...getClientInfo(req, clientIp)
+    ...getClientInfo2(req, clientIp)
   };
 }
 
@@ -1069,7 +1069,7 @@ function waitForAbort(signal) {
 }
 function contractStreamResponse(request, context, source, descriptor, operationAbort) {
   const format = descriptor.format ?? "ndjson";
-  const maxFrameBytes = descriptor.maxFrameBytes ?? DEFAULT_CONTRACT_STREAM_FRAME_BYTES;
+  const maxFrameBytes = descriptor.maxFrameBytes ?? DEFAULT_CONTRACT_STREAM_FRAME_BYTES2;
   const iterator = source[Symbol.asyncIterator]();
   let pendingNext;
   const settled = Promise.withResolvers();
@@ -1116,7 +1116,7 @@ function contractStreamResponse(request, context, source, descriptor, operationA
         const parsed = descriptor.item.safeParse(next.value);
         if (!parsed.success) {
           console.error("[stitchkit] contract stream item failed validation:", parsed.error);
-          throw new AppError("STREAM_ITEM_INVALID", "Stream item did not match its contract", 500);
+          throw new AppError2("STREAM_ITEM_INVALID", "Stream item did not match its contract", 500);
         }
         const item = parsed.data;
         const terminal = descriptor.terminal?.safeParse(item).success ?? false;
@@ -1125,14 +1125,14 @@ function contractStreamResponse(request, context, source, descriptor, operationA
         const frame = descriptor.framing === "item" ? item : { type: "data", data: item };
         if (encodedBytes(frame, format) > maxFrameBytes) {
           console.error(`[stitchkit] contract stream frame exceeded its ${maxFrameBytes} byte limit`);
-          throw new AppError("STREAM_FRAME_TOO_LARGE", "Stream item exceeded its declared frame limit", 500);
+          throw new AppError2("STREAM_FRAME_TOO_LARGE", "Stream item exceeded its declared frame limit", 500);
         }
         yield frame;
         if (terminal && descriptor.completion === "terminal")
           return;
       }
       if (!terminalSeen) {
-        throw new AppError("STREAM_TERMINAL_MISSING", "Stream completed before its declared terminal item", 500);
+        throw new AppError2("STREAM_TERMINAL_MISSING", "Stream completed before its declared terminal item", 500);
       }
       if (descriptor.framing !== "item")
         yield { type: "end" };
@@ -1144,22 +1144,22 @@ function contractStreamResponse(request, context, source, descriptor, operationA
           return;
         yield {
           type: "error",
-          error: new AppError("STREAM_LIFETIME_EXCEEDED", "Stream exceeded its declared lifetime", 408).toJSON().error
+          error: new AppError2("STREAM_LIFETIME_EXCEEDED", "Stream exceeded its declared lifetime", 408).toJSON().error
         };
         return;
       }
       if (descriptor.framing === "item") {
-        console.error("[stitchkit] item-framed contract stream failed:", normalizeError(error));
+        console.error("[stitchkit] item-framed contract stream failed:", normalizeError2(error));
         return;
       }
-      yield { type: "error", error: normalizeError(error).toJSON().error };
+      yield { type: "error", error: normalizeError2(error).toJSON().error };
     } finally {
       if (lifetime !== undefined)
         clearTimeout(lifetime);
       closeSource();
     }
   };
-  const route = streamingRoute({
+  const route = streamingRoute2({
     path: "/",
     format,
     heartbeatMs: descriptor.heartbeatMs,
@@ -1220,7 +1220,7 @@ async function endpointResponse(state, request, outcome) {
 }
 function rawEndpointResponse(state, request, { match: { method }, result }) {
   if (!(result instanceof Response)) {
-    throw new AppError("INTERNAL_SERVER_ERROR", `Raw endpoint ${method.serviceName}.${method.key} must return a Response`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", `Raw endpoint ${method.serviceName}.${method.key} must return a Response`, 500);
   }
   const response = method.method === "HEAD" ? new Response(null, {
     status: result.status,
@@ -1235,7 +1235,7 @@ async function streamEndpointResponse(state, request, { match: { method, pathPar
   const { req, server, clientIp } = request;
   if (!method.stream || !streamAbort || !isAsyncIterable(result)) {
     streamAbort?.abort();
-    throw new AppError("INTERNAL_SERVER_ERROR", `Streaming endpoint ${method.serviceName}.${method.key} must return an AsyncIterable`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", `Streaming endpoint ${method.serviceName}.${method.key} must return an AsyncIterable`, 500);
   }
   const response = await contractStreamResponse(req, { params: pathParams, server, ipAddress: clientIp.socketIp }, result, method.stream, streamAbort);
   const withCors = applyCors(response, state.cors, req);
@@ -1262,27 +1262,27 @@ async function dataEndpointResponse(state, request, {
       result = transformed;
   }
   if (result instanceof Response) {
-    throw new AppError("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} produced a Response on the data path — only a \`rawResponse: true\` endpoint may return one (an afterHandle hook must return data)`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} produced a Response on the data path — only a \`rawResponse: true\` endpoint may return one (an afterHandle hook must return data)`, 500);
   }
   const checked = validateDeclaredOutput(method.outputSchema, result, config.warnOnOutputStrip && method.outputSchema ? (paths) => {
     warn(`[stitchkit] output strip ${method.serviceName}.${method.key}: ${paths.join(", ")}`);
   } : undefined);
   if (!checked.ok) {
-    throw new AppError("INTERNAL_SERVER_ERROR", checked.message, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", checked.message, 500);
   }
   result = checked.data;
   const responseStatus = method.responseMeta?.status ?? (method.outputSchema ? 200 : 204);
   if (method.outputSchema && (responseStatus === 204 || responseStatus === 205)) {
-    throw new AppError("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} cannot combine output with bodyless status ${responseStatus}`, 500);
+    throw new AppError2("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} cannot combine output with bodyless status ${responseStatus}`, 500);
   }
-  const responseHeaders2 = new Headers(requestCorsHeaders(cors, req));
-  applyResponseMetadata(responseHeaders2, responseMetadata, `${method.serviceName}.${method.key}`);
+  const responseHeaders = new Headers(requestCorsHeaders(cors, req));
+  applyResponseMetadata(responseHeaders, responseMetadata, `${method.serviceName}.${method.key}`);
   if (!method.outputSchema) {
-    const empty = new Response(null, { status: responseStatus, headers: responseHeaders2 });
+    const empty = new Response(null, { status: responseStatus, headers: responseHeaders });
     request.complete(responseStatus);
     return empty;
   }
-  const body = Response.json(result, { status: responseStatus, headers: responseHeaders2 });
+  const body = Response.json(result, { status: responseStatus, headers: responseHeaders });
   request.complete(responseStatus);
   return body;
 }
@@ -1293,7 +1293,7 @@ async function dispatchEndpoint(state, request, match) {
   const { req, url, traceId, clientIp } = request;
   const { method, pathParams, groupHooks } = match;
   const ctx = buildBaseContext(req, url, pathParams, traceId, clientIp);
-  setRequestEndpoint(method.serviceName, method.key);
+  setRequestEndpoint2(method.serviceName, method.key);
   let multipartLifecycle;
   try {
     parsePathParamsInto(ctx, method);
@@ -1372,11 +1372,11 @@ function createErrorResponder(state, request) {
       return response;
     }
     const recordFailure = (normalized) => {
-      if (getRequestContext()?.error !== undefined)
+      if (getRequestContext2()?.error !== undefined)
         return;
-      const known = AppError.is(err) ? err : normalized;
-      const code = known?.code ?? errorCode(err) ?? "INTERNAL_SERVER_ERROR";
-      setRequestError({
+      const known = AppError2.is(err) ? err : normalized;
+      const code = known?.code ?? errorCode2(err) ?? "INTERNAL_SERVER_ERROR";
+      setRequestError2({
         code,
         message: recordedErrorMessage(code, known?.message, err),
         details: known?.details
@@ -1392,13 +1392,13 @@ function createErrorResponder(state, request) {
       respond: (response) => {
         recordFailure();
         const withCors = applyCors(response, cors, req);
-        complete(withCors.status, errorCode(err));
+        complete(withCors.status, errorCode2(err));
         return withCors;
       }
     });
     if (customResponse)
       return customResponse;
-    const appErr = normalizeError(err);
+    const appErr = normalizeError2(err);
     recordFailure(appErr);
     complete(appErr.status, appErr.code);
     return Response.json(appErr.toJSON(), {
@@ -1461,7 +1461,7 @@ function shouldSkipLog(config, req, url) {
 function collectExtraLogFields(config, req, url, outcome) {
   const fields = {};
   const enrichKeys = [];
-  const ctx = getRequestContext();
+  const ctx = getRequestContext2();
   if (ctx) {
     if (ctx.userId)
       fields.userId = ctx.userId;
@@ -1813,15 +1813,15 @@ function createTraceIdResolver(customTraceId, warn) {
   let traceResolverBroken = false;
   return (req, fallback) => {
     if (!customTraceId)
-      return fallback ?? resolveTraceId(req);
+      return fallback ?? resolveTraceId2(req);
     try {
-      return customTraceId(req) ?? fallback ?? resolveTraceId(req);
+      return customTraceId(req) ?? fallback ?? resolveTraceId2(req);
     } catch (err) {
       if (!traceResolverBroken) {
         traceResolverBroken = true;
         warn("[stitchkit] `traceId` resolver threw — falling back to the framework resolver. " + "Ids will not match your observability context until it is fixed: " + `${err instanceof Error ? err.message : String(err)}`);
       }
-      return fallback ?? resolveTraceId(req);
+      return fallback ?? resolveTraceId2(req);
     }
   };
 }
@@ -1880,11 +1880,11 @@ function levelForStatus(status) {
     return "warn";
   return "info";
 }
-function buildLogFields(method, path, status, durationMs, traceId, errorCode2) {
+function buildLogFields(method, path, status, durationMs, traceId, errorCode) {
   const fields = { traceId, method, path, status, durationMs };
-  if (errorCode2 === undefined && status >= 400)
+  if (errorCode === undefined && status >= 400)
     return fields;
-  return { ...fields, errorCode: errorCode2 };
+  return { ...fields, errorCode };
 }
 function formatMs(ms) {
   if (ms >= 1000)
@@ -1936,21 +1936,21 @@ function structuredLine(own, extra) {
   }
 }
 function logOutgoing(entry) {
-  const { req, pathname, status, log, ipAddress, errorCode: errorCode2, durationMs, format, extra } = entry;
+  const { req, pathname, status, log, ipAddress, errorCode, durationMs, format, extra } = entry;
   const ms = durationMs;
   if (format === "json") {
     const own = {
       ts: new Date().toISOString(),
       level: levelForStatus(status),
       msg: `${req.method} ${pathname} ${status}`,
-      ...buildLogFields(req.method, pathname, status, durationMs, log.traceId, errorCode2),
+      ...buildLogFields(req.method, pathname, status, durationMs, log.traceId, errorCode),
       ip: ipAddress
     };
     console.log(structuredLine(own, extra));
     return;
   }
   const mc = METHOD_COLOR[req.method] ?? c.dim;
-  const code = errorCode2 ? ` ${c.red}${errorCode2}${c.reset}` : "";
+  const code = errorCode ? ` ${c.red}${errorCode}${c.reset}` : "";
   console.log(`${c.gray}[${timestamp()}]${c.reset} ${mc}${req.method}${c.reset} ${c.dim}${log.traceId}${c.reset} ${c.cyan}←${c.reset} ${safePath(pathname)} ${statusColor(status)}${status}${c.reset}${code} ${durationColor(ms)}${formatMs(ms)}${c.reset} ${ipLabel(ipAddress ?? "")}`);
 }
 
@@ -1980,7 +1980,7 @@ function openRequestCompletion(state, window) {
     } catch {}
   }
   let completed = false;
-  return (status, errorCode2, outcome) => {
+  return (status, errorCode, outcome) => {
     if (completed)
       return;
     completed = true;
@@ -1991,12 +1991,12 @@ function openRequestCompletion(state, window) {
           reqLog,
           status,
           durationMs,
-          errorCode: errorCode2,
+          errorCode,
           logFormat
         });
       } catch {}
     }
-    const context = getRequestContext();
+    const context = getRequestContext2();
     if (observability && context) {
       try {
         observability.complete({
@@ -2013,13 +2013,13 @@ function openRequestCompletion(state, window) {
 function writeCompletionLine(state, logConfig, window, line) {
   const { customLogger, useDefaultLog, warnedEnrichKeys, warn } = state;
   const { req, url, ipAddress } = window;
-  const { reqLog, status, durationMs, errorCode: errorCode2, logFormat } = line;
+  const { reqLog, status, durationMs, errorCode, logFormat } = line;
   const collected = collectExtraLogFields(logConfig, req, url, {
     status,
     durationMs,
-    errorCode: errorCode2
+    errorCode
   });
-  const frameworkFields = buildLogFields(req.method, url.pathname, status, durationMs, reqLog.traceId, errorCode2);
+  const frameworkFields = buildLogFields(req.method, url.pathname, status, durationMs, reqLog.traceId, errorCode);
   const ownedFields = { ...frameworkFields, ip: ipAddress };
   for (const key of collected.enrichKeys) {
     const ownedByActiveSink = Object.hasOwn(ownedFields, key) || useDefaultLog && (key === "ts" || key === "level" || key === "msg");
@@ -2036,7 +2036,7 @@ function writeCompletionLine(state, logConfig, window, line) {
       status,
       log: reqLog,
       ipAddress,
-      errorCode: errorCode2,
+      errorCode,
       durationMs,
       format: logFormat,
       extra
@@ -2044,7 +2044,7 @@ function writeCompletionLine(state, logConfig, window, line) {
   }
   if (customLogger) {
     const level = levelForStatus(status);
-    customLogger[level](`${req.method} ${url.pathname} ${status}${errorCode2 ? ` ${errorCode2}` : ""} ${durationMs}ms`, {
+    customLogger[level](`${req.method} ${url.pathname} ${status}${errorCode ? ` ${errorCode}` : ""} ${durationMs}ms`, {
       ...extra,
       ...frameworkFields,
       ip: ipAddress
@@ -2053,7 +2053,7 @@ function writeCompletionLine(state, logConfig, window, line) {
 }
 
 // src/server/create.ts
-function createHandler(config) {
+function createHandler2(config) {
   const { trustProxy = false, observability } = config;
   const state = createHandlerState(config);
   return async (req, server) => {
@@ -2061,29 +2061,29 @@ function createHandler(config) {
     const requestStartedAt = process.hrtime.bigint();
     const clientIp = {
       trustProxy,
-      socketIp: resolveSocketIp(req, server)
+      socketIp: resolveSocketIp2(req, server)
     };
-    const run = async (traceId2, startedAt) => {
-      const response = await dispatch(state, req, url, traceId2, server, clientIp, startedAt);
+    const run = async (traceId, startedAt) => {
+      const response = await dispatch(state, req, url, traceId, server, clientIp, startedAt);
       try {
-        response.headers.set("x-request-id", traceId2);
+        response.headers.set("x-request-id", traceId);
         const buildId = config.release?.current();
         if (buildId)
-          response.headers.set(RELEASE_HEADER, buildId);
+          response.headers.set(RELEASE_HEADER2, buildId);
       } catch {}
       return response;
     };
-    const activeContext = getRequestContext();
+    const activeContext = getRequestContext2();
     if (activeContext) {
       return run(activeContext.trace.traceId, activeContext.startedAt);
     }
     if (!observability)
       return run(state.resolveId(req), requestStartedAt);
-    const trace = resolveTraceContext(req);
+    const trace = resolveTraceContext2(req);
     const traceId = state.resolveId(req, trace.traceId);
-    const ipAddress = extractIp(req, clientIp) || undefined;
+    const ipAddress = extractIp2(req, clientIp) || undefined;
     const userAgent = req.headers.get("user-agent") ?? undefined;
-    return runWithRequestContext({
+    return runWithRequestContext2({
       source: "http",
       method: req.method,
       path: url.pathname,
@@ -2096,7 +2096,7 @@ function createHandler(config) {
 }
 async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
   const { cors, hooks, config, routeMap } = state;
-  const ipAddress = extractIp(req, clientIp) || undefined;
+  const ipAddress = extractIp2(req, clientIp) || undefined;
   const complete = openRequestCompletion(state, { req, url, traceId, startedAt, ipAddress });
   const respondError = createErrorResponder(state, { req, url, traceId, clientIp, complete });
   const request = {
@@ -2110,7 +2110,7 @@ async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
     respondError
   };
   if (cors && req.method === "OPTIONS") {
-    const response = corsPreflightResponse(cors, req);
+    const response = corsPreflightResponse2(cors, req);
     complete(response.status);
     return response;
   }
@@ -2130,7 +2130,7 @@ async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
     const rawMatch = matchRawRoute(config.rawRoutes, req.method, url.pathname);
     if (rawMatch) {
       if (rawMatch.route.serviceName !== undefined) {
-        setRequestEndpoint(rawMatch.route.serviceName, rawMatch.route.action);
+        setRequestEndpoint2(rawMatch.route.serviceName, rawMatch.route.action);
       }
       try {
         const res = await rawMatch.route.handler(req, {
@@ -2150,17 +2150,17 @@ async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
   if (!match) {
     const allow = allowedMethods(routeMap, url.pathname);
     if (allow.length > 0) {
-      const res = await respondError(new AppError("METHOD_NOT_ALLOWED", `Method ${req.method} not allowed`, 405));
+      const res = await respondError(new AppError2("METHOD_NOT_ALLOWED", `Method ${req.method} not allowed`, 405));
       res.headers.set("Allow", allow.join(", "));
       return res;
     }
-    return respondError(new AppError("NOT_FOUND", "Not found", 404));
+    return respondError(new AppError2("NOT_FOUND", "Not found", 404));
   }
   return dispatchEndpoint(state, request, match);
 }
 
 // src/server/implement-registry.ts
-function createScopedImplementRegistry() {
+function createScopedImplementRegistry2() {
   return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
 }
 function isImplementationContract(value) {
@@ -2214,16 +2214,16 @@ function bindRegistry(contracts, handlers, options) {
   Object.defineProperty(services, "byKey", { value: byKey, enumerable: false });
   return transportResult(services);
 }
-function implementRegistry(contracts, handlers, options) {
+function implementRegistry2(contracts, handlers, options) {
   return transportResult(bindRegistry(contracts, handlers, options));
 }
-function createImplementRegistry() {
+function createImplementRegistry2() {
   return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
 }
 
 // src/server/process-signals.ts
 var bound = new WeakSet;
-function bindProcessSignals(handle, options = {}) {
+function bindProcessSignals2(handle, options = {}) {
   if (bound.has(handle)) {
     throw new Error("[stitchkit] bindProcessSignals: this server is already bound; close the first binding before creating another");
   }
@@ -2231,7 +2231,7 @@ function bindProcessSignals(handle, options = {}) {
   const signals = [...new Set(options.signals ?? DEFAULT_PROCESS_SIGNALS)];
   const source = options.signalSource ?? defaultSignalSource;
   const requested = options.shutdown ?? {};
-  const validated = ShutdownOptionsSchema.omit({ signal: true }).parse(requested);
+  const validated = ShutdownOptionsSchema2.omit({ signal: true }).parse(requested);
   const budgets = {
     ...requested.gracePeriodMs !== undefined && { gracePeriodMs: validated.gracePeriodMs },
     ...requested.forceTimeoutMs !== undefined && {
@@ -2342,7 +2342,7 @@ function bindProcessSignals(handle, options = {}) {
 }
 
 // src/server/realtime.ts
-function bindRealtimeServer(contract, handle, options = {}) {
+function bindRealtimeServer2(contract, handle, options = {}) {
   const outbound = (target) => createValidatedRealtimeSocket({
     target,
     inbound: {},
@@ -2391,7 +2391,7 @@ function bindRealtimeServer(contract, handle, options = {}) {
 }
 
 // src/server/websocket.ts
-function webSocketLane(lane) {
+function webSocketLane2(lane) {
   const { match, handlers } = lane;
   return {
     match,
@@ -2423,7 +2423,7 @@ function webSocketLane(lane) {
     }
   };
 }
-function composeWebSocketHandlers(lanes, config) {
+function composeWebSocketHandlers2(lanes, config) {
   const pick = (ws) => lanes.find((lane) => lane.match(ws));
   return {
     ...config,
@@ -2502,7 +2502,7 @@ function handshakeMiddleware(handshake) {
     });
   };
 }
-async function createSocketIOServer(config) {
+async function createSocketIOServer2(config) {
   const path = config.path ?? "/socket.io/";
   const onBun = "Bun" in globalThis;
   const transports = config.transports ?? (onBun ? ["websocket", "polling"] : ["websocket"]);
@@ -2626,15 +2626,15 @@ async function createSocketIOServer(config) {
     ...lifecycle
   };
 }
-function socketIoLane(websocket) {
-  return webSocketLane({
+function socketIoLane2(websocket) {
+  return webSocketLane2({
     match: (_ws) => true,
     handlers: websocket
   });
 }
 
 // src/server/unix-client-error.ts
-class UnixClientTransportError extends Error {
+class UnixClientTransportError2 extends Error {
   code;
   delivery;
   constructor(code, message, delivery = "possibly-dispatched", options) {
@@ -2658,7 +2658,7 @@ async function readBoundedRequestBody(request, maxBytes) {
     return;
   const declared = request.headers.get("content-length");
   if (declared !== null && Number(declared) > maxBytes) {
-    throw new UnixClientTransportError("UNIX_REQUEST_TOO_LARGE", `Unix request body exceeds the ${maxBytes} byte limit`, "not-dispatched");
+    throw new UnixClientTransportError2("UNIX_REQUEST_TOO_LARGE", `Unix request body exceeds the ${maxBytes} byte limit`, "not-dispatched");
   }
   const reader = body.getReader();
   const chunks = [];
@@ -2672,7 +2672,7 @@ async function readBoundedRequestBody(request, maxBytes) {
         break;
       total += chunk.value.byteLength;
       if (total > maxBytes) {
-        throw new UnixClientTransportError("UNIX_REQUEST_TOO_LARGE", `Unix request body exceeds the ${maxBytes} byte limit`, "not-dispatched");
+        throw new UnixClientTransportError2("UNIX_REQUEST_TOO_LARGE", `Unix request body exceeds the ${maxBytes} byte limit`, "not-dispatched");
       }
       chunks.push(chunk.value);
     }
@@ -2705,7 +2705,7 @@ function incomingResponseBody(response, maxBytes, onDone) {
         if (maxBytes !== undefined)
           received += chunk.byteLength;
         if (maxBytes !== undefined && received > maxBytes) {
-          controller.error(new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${maxBytes} byte limit`, "response-received"));
+          controller.error(new UnixClientTransportError2("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${maxBytes} byte limit`, "response-received"));
           response.destroy();
           finish();
           return;
@@ -2722,13 +2722,13 @@ function incomingResponseBody(response, maxBytes, onDone) {
       response.once("aborted", () => {
         if (finished)
           return;
-        controller.error(new UnixClientTransportError("UNIX_RESPONSE_ABORTED", "Unix response was aborted before completion", "response-received"));
+        controller.error(new UnixClientTransportError2("UNIX_RESPONSE_ABORTED", "Unix response was aborted before completion", "response-received"));
         finish();
       });
       response.once("error", (error) => {
         if (finished)
           return;
-        controller.error(new UnixClientTransportError("UNIX_RESPONSE_ABORTED", "Unix response failed before completion", "response-received", { cause: error }));
+        controller.error(new UnixClientTransportError2("UNIX_RESPONSE_ABORTED", "Unix response failed before completion", "response-received", { cause: error }));
         finish();
       });
     },
@@ -2988,15 +2988,15 @@ function hasBunUnixRuntime() {
   return runtimeBun() !== undefined;
 }
 function classifyTransportFailure(error, headersReceived, dispatched) {
-  if (error instanceof UnixClientTransportError)
+  if (error instanceof UnixClientTransportError2)
     return error;
   if (headersReceived) {
-    return new UnixClientTransportError("UNIX_RESPONSE_ABORTED", "Unix response failed before completion", "response-received", { cause: error });
+    return new UnixClientTransportError2("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 });
+  return new UnixClientTransportError2(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");
+  return limit === "body" ? new UnixClientTransportError2("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${bytes} byte limit`, "response-received") : new UnixClientTransportError2("UNIX_HEADERS_TOO_LARGE", `Unix response ${what} exceed the ${bytes} byte limit`, "response-received");
 }
 function socketHandlers(events) {
   return {
@@ -3033,7 +3033,7 @@ function bunUnixRequest(options) {
   let socket;
   let controller;
   const wire = new WireBuffer;
-  let decoder2;
+  let decoder;
   let responseResolved = false;
   let headersReceived = false;
   let settled = false;
@@ -3053,10 +3053,10 @@ function bunUnixRequest(options) {
   });
   const transportFailure = (error) => classifyTransportFailure(error, headersReceived, writeOffset > 0);
   const clearRegistration = options.registerAbort(() => {
-    fail(new UnixClientTransportError("UNIX_CLIENT_CLOSED", "Unix client transport is closed"));
+    fail(new UnixClientTransportError2("UNIX_CLIENT_CLOSED", "Unix client transport is closed"));
   });
   const timer = setTimeout(() => {
-    fail(new UnixClientTransportError("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${options.headersTimeoutMs}ms`));
+    fail(new UnixClientTransportError2("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${options.headersTimeoutMs}ms`));
   }, options.headersTimeoutMs);
   timer.unref();
   const removeRequestAbort = () => {
@@ -3107,13 +3107,13 @@ function bunUnixRequest(options) {
   };
   const headersTooLarge = (what) => limitError("headers", what, options.maxHeaderBytes);
   const pump = () => {
-    while (controller && decoder2 && !settled && !bodyComplete) {
+    while (controller && decoder && !settled && !bodyComplete) {
       if ((controller.desiredSize ?? 1) <= 0)
         return;
-      const step = decoder2.next(wire, peerEnded);
+      const step = decoder.next(wire, peerEnded);
       if (step.kind === "data") {
         enqueue(step.value);
-        if (!settled && decoder2.plainComplete)
+        if (!settled && decoder.plainComplete)
           completeBody();
       } else if (step.kind === "more")
         resumeForData();
@@ -3145,7 +3145,7 @@ function bunUnixRequest(options) {
       fail(limitError("body", "body", options.maxResponseBytes));
       return;
     }
-    decoder2 = new BodyDecoder(head.chunked, contentLength, options.maxHeaderBytes);
+    decoder = new BodyDecoder(head.chunked, contentLength, options.maxHeaderBytes);
     const bodyless = options.request.method === "HEAD" || status === 204 || status === 205 || status === 304;
     clearTimeout(timer);
     responseResolved = true;
@@ -3300,7 +3300,7 @@ 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");
+    throw new UnixClientTransportError2("UNIX_REDIRECT_REFUSED", redirectCount >= maxRedirects ? `Unix redirect limit ${maxRedirects} exceeded` : "Unix request redirect mode is error", "response-received");
   }
   return request.redirect === "follow" ? "follow" : "return";
 }
@@ -3343,7 +3343,7 @@ function nodeUnixRequest(input) {
     });
     activeRequests.add(outgoing);
     const timer = setTimeout(() => {
-      const error = new UnixClientTransportError("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${headersTimeoutMs}ms`);
+      const error = new UnixClientTransportError2("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${headersTimeoutMs}ms`);
       rejectOnce(error);
       outgoing.destroy(error);
     }, headersTimeoutMs);
@@ -3351,11 +3351,11 @@ function nodeUnixRequest(input) {
     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 }));
+        rejectOnce(new UnixClientTransportError2("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 }));
+      rejectOnce(new UnixClientTransportError2(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);
@@ -3364,7 +3364,7 @@ function nodeUnixRequest(input) {
     outgoing.end(input.body);
   });
 }
-function createUnixClientTransport(config) {
+function createUnixClientTransport2(config) {
   const {
     maxRequestBytes,
     maxResponseBytes,
@@ -3378,9 +3378,9 @@ function createUnixClientTransport(config) {
   const activeResponses = new Set;
   const bunAborters = new Set;
   let closed = false;
-  const dispatch2 = async (request, redirectCount) => {
+  const dispatch = async (request, redirectCount) => {
     if (closed) {
-      throw new UnixClientTransportError("UNIX_CLIENT_CLOSED", "Unix client transport is closed", "not-dispatched");
+      throw new UnixClientTransportError2("UNIX_CLIENT_CLOSED", "Unix client transport is closed", "not-dispatched");
     }
     if (request.signal.aborted)
       throw request.signal.reason;
@@ -3391,7 +3391,7 @@ function createUnixClientTransport(config) {
     const body = await readBoundedRequestBody(request, maxRequestBytes);
     if (hasBunUnixRuntime()) {
       if (bunAborters.size >= maxConnections) {
-        throw new UnixClientTransportError("UNIX_CONNECTION_LIMIT", `Unix client connection limit ${maxConnections} reached`, "not-dispatched");
+        throw new UnixClientTransportError2("UNIX_CONNECTION_LIMIT", `Unix client connection limit ${maxConnections} reached`, "not-dispatched");
       }
       const response = await bunUnixRequest({
         socketPath: config.socketPath,
@@ -3405,17 +3405,17 @@ function createUnixClientTransport(config) {
           return () => void bunAborters.delete(abort);
         }
       });
-      const location2 = response.headers.get("location");
-      let step2;
+      const location = response.headers.get("location");
+      let step;
       try {
-        step2 = redirectStep(request, response.status, location2, redirectCount, maxRedirects);
+        step = redirectStep(request, response.status, location, redirectCount, maxRedirects);
       } catch (error) {
         await response.body?.cancel();
         throw error;
       }
-      if (step2 === "follow" && location2) {
+      if (step === "follow" && location) {
         await response.body?.cancel();
-        return dispatch2(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
+        return dispatch(redirectedRequest(request, location, response.status, body), redirectCount + 1);
       }
       return response;
     }
@@ -3442,7 +3442,7 @@ function createUnixClientTransport(config) {
     if (declaredResponseBytes !== null && /^\d+$/.test(declaredResponseBytes) && maxResponseBytes !== undefined && Number(declaredResponseBytes) > maxResponseBytes) {
       incoming.destroy();
       releaseResponse();
-      throw new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${maxResponseBytes} byte limit`, "response-received");
+      throw new UnixClientTransportError2("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${maxResponseBytes} byte limit`, "response-received");
     }
     const location = responseHeadersValue.get("location");
     let step;
@@ -3456,7 +3456,7 @@ function createUnixClientTransport(config) {
     if (step === "follow" && location) {
       incoming.destroy();
       releaseResponse();
-      return dispatch2(redirectedRequest(request, location, status, body), redirectCount + 1);
+      return dispatch(redirectedRequest(request, location, status, body), redirectCount + 1);
     }
     const bodyless = request.method === "HEAD" || status === 204 || status === 205 || status === 304;
     if (bodyless) {
@@ -3476,7 +3476,7 @@ function createUnixClientTransport(config) {
   };
   return {
     fetch(input, init) {
-      return dispatch2(new Request(input, init), 0);
+      return dispatch(new Request(input, init), 0);
     },
     get closed() {
       return closed;
@@ -3499,4 +3499,4 @@ function createUnixClientTransport(config) {
   };
 }
 
-export { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart, DEFAULT_STREAM_HEARTBEAT_MS, streamingRoute, ndjsonRoute, sseRoute, createHandler, createScopedImplementRegistry, implementRegistry, createImplementRegistry, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane, UnixClientTransportError, createUnixClientTransport };
+export { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart2, DEFAULT_STREAM_HEARTBEAT_MS2, streamingRoute2, ndjsonRoute2, sseRoute2, createHandler2, createScopedImplementRegistry2, implementRegistry2, createImplementRegistry2, bindProcessSignals2, bindRealtimeServer2, webSocketLane2, composeWebSocketHandlers2, createSocketIOServer2, socketIoLane2, UnixClientTransportError2, createUnixClientTransport2 };