stitchkit 0.66.1 → 0.68.0

package/dist/{index-s1tywej8.js → index-nymn7wbg.js}

@@ -7,35 +7,34 @@ import {
   defaultSignalSource,
   guardSignalCallback,
   reportSignalError
-} from "./index-y91zd0ch.js";
+} from "./index-pr0qsmjy.js";
 import {
   ShutdownOptionsSchema
 } from "./index-dk6e56g0.js";
 import {
-  errorCode,
   extractIp,
   getClientInfo,
   getRequestContext,
-  normalizeError,
   parseQueryParams,
-  recordedErrorMessage,
   resolveSocketIp,
   resolveTraceId,
   runWithRequestContext,
   setRequestEndpoint,
-  setRequestError,
-  validateDeclaredOutput,
-  zodIssues
-} from "./index-tvwcrx2d.js";
+  setRequestError
+} from "./index-69m2278y.js";
 import {
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
+  errorCode,
   isUnsafeKey,
-  safeJsonParse
-} from "./index-wd8g8z6e.js";
-import {
   joinRoutePath,
+  normalizeError,
   parseTrailingWildcard,
-  resolveTraceContext
-} from "./index-pzyt11ch.js";
+  recordedErrorMessage,
+  resolveTraceContext,
+  safeJsonParse,
+  validateDeclaredOutput,
+  zodIssues
+} from "./index-9ky9hhg3.js";
 import {
   isRecord,
   transportResult
@@ -43,7 +42,7 @@ import {
 import {
   AppError,
   badRequest
-} from "./index-xxye8j3k.js";
+} from "./index-0w9abg87.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
@@ -470,6 +469,195 @@ async function parseMultipart(req, descriptor, fieldsSchema, receivers) {
   }
 }
 
+// src/server/streaming-route.ts
+var DEFAULT_STREAM_HEARTBEAT_MS = 5000;
+var FRAMINGS = {
+  ndjson: {
+    contentType: "application/x-ndjson",
+    keepAlive: `
+`,
+    frame: (value) => `${JSON.stringify(value)}
+`
+  },
+  sse: {
+    contentType: "text/event-stream",
+    keepAlive: `: keep-alive
+
+`,
+    frame: (value) => `data: ${JSON.stringify(value)}
+
+`,
+    done: `data: [DONE]
+
+`
+  }
+};
+function applyIdleTimeout(server, request, seconds) {
+  if (typeof server !== "object" || server === null)
+    return;
+  const timeout = Reflect.get(server, "timeout");
+  if (typeof timeout !== "function")
+    return;
+  try {
+    Reflect.apply(timeout, server, [request, seconds]);
+  } catch {}
+}
+function unrefTimer(timer) {
+  if (typeof timer !== "object" || timer === null)
+    return;
+  const unref = Reflect.get(timer, "unref");
+  if (typeof unref === "function")
+    Reflect.apply(unref, timer, []);
+}
+var MAX_BUFFERED_FRAMES = 16;
+function responseHeaders(framing, extra) {
+  const headers = new Headers(extra);
+  headers.set("Content-Type", framing.contentType);
+  headers.set("Cache-Control", "no-cache");
+  headers.set("Connection", "keep-alive");
+  headers.set("X-Accel-Buffering", "no");
+  return headers;
+}
+function streamingRoute(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");
+  }
+  const idleTimeoutSeconds = options.idleTimeoutSeconds ?? 0;
+  if (!Number.isInteger(idleTimeoutSeconds) || idleTimeoutSeconds < 0) {
+    throw new TypeError("idleTimeoutSeconds must be a non-negative integer");
+  }
+  const framing = FRAMINGS[options.format ?? "ndjson"];
+  return {
+    method: options.method ?? "GET",
+    path: options.path,
+    handler: async (request, context) => {
+      applyIdleTimeout(context.server, request, idleTimeoutSeconds);
+      const departed = new AbortController;
+      const iterable = await options.source(request, { ...context, signal: departed.signal });
+      const iterator = iterable[Symbol.asyncIterator]();
+      const encoder2 = new TextEncoder;
+      let heartbeat = null;
+      let closed = false;
+      const stopHeartbeat = () => {
+        if (heartbeat === null)
+          return;
+        clearInterval(heartbeat);
+        heartbeat = null;
+      };
+      const release = () => {
+        if (closed)
+          return;
+        closed = true;
+        try {
+          options.onClose?.();
+          stopHeartbeat();
+          signalDemand();
+          departed.abort();
+          Promise.resolve(iterator.return?.(undefined)).catch(() => {
+            return;
+          });
+        } catch {}
+      };
+      let demand = null;
+      const signalDemand = () => {
+        const resolve = demand;
+        demand = null;
+        resolve?.();
+      };
+      const stream = new ReadableStream({
+        start(controller) {
+          const send = (text) => {
+            if (closed)
+              return false;
+            try {
+              controller.enqueue(encoder2.encode(text));
+              return true;
+            } catch {
+              release();
+              return false;
+            }
+          };
+          const finish = () => {
+            try {
+              controller.close();
+            } catch {}
+          };
+          if (request.signal.aborted) {
+            release();
+            finish();
+            return;
+          }
+          request.signal.addEventListener("abort", () => {
+            release();
+            finish();
+          });
+          send(framing.keepAlive);
+          heartbeat = setInterval(() => {
+            if ((controller.desiredSize ?? 1) > 0)
+              send(framing.keepAlive);
+          }, heartbeatMs);
+          unrefTimer(heartbeat);
+          const awaitDemand = async () => {
+            while (!closed && (controller.desiredSize ?? 1) <= 0) {
+              await new Promise((resolve) => {
+                demand = resolve;
+              });
+            }
+          };
+          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)
+                send(framing.frame(normalizeError(error).toJSON()));
+            } finally {
+              release();
+              finish();
+            }
+          })();
+        },
+        pull() {
+          signalDemand();
+        },
+        cancel() {
+          release();
+        }
+      }, { highWaterMark: MAX_BUFFERED_FRAMES });
+      return new Response(stream, { headers: responseHeaders(framing, options.headers) });
+    }
+  };
+}
+function ndjsonRoute(options) {
+  return streamingRoute({ ...options, format: "ndjson" });
+}
+function sseRoute(options) {
+  return streamingRoute({ ...options, format: "sse" });
+}
+
 // src/server/request-body.ts
 function requestAbortReason(req) {
   return req.signal.reason ?? new DOMException("The connection was closed", "AbortError");
@@ -615,6 +803,97 @@ function buildErrorContext(req, url, traceId, clientIp) {
   };
 }
 
+// src/server/contract-stream.ts
+function encodedBytes(value, format) {
+  const json = JSON.stringify(value);
+  if (json === undefined)
+    throw new TypeError("Streaming item is not JSON serializable");
+  const framing = format === "sse" ? `data: ${json}
+
+` : `${json}
+`;
+  return new TextEncoder().encode(framing).byteLength;
+}
+function waitForAbort(signal) {
+  return new Promise((_resolve, reject) => {
+    const rejectAborted = () => reject(signal.reason ?? new Error("Stream aborted"));
+    if (signal.aborted)
+      rejectAborted();
+    else
+      signal.addEventListener("abort", rejectAborted, { once: true });
+  });
+}
+function contractStreamResponse(request, context, source, descriptor, operationAbort) {
+  const format = descriptor.format ?? "ndjson";
+  const maxFrameBytes = descriptor.maxFrameBytes ?? DEFAULT_CONTRACT_STREAM_FRAME_BYTES;
+  let lifetime;
+  let lifetimeExpired = false;
+  if (descriptor.lifetimeMs !== undefined) {
+    lifetime = setTimeout(() => {
+      lifetimeExpired = true;
+      operationAbort.abort(new Error("Stream lifetime expired"));
+    }, descriptor.lifetimeMs);
+    lifetime.unref?.();
+  }
+  const frames = async function* () {
+    const iterator = source[Symbol.asyncIterator]();
+    const aborted = waitForAbort(operationAbort.signal);
+    let terminalSeen = descriptor.terminal === undefined;
+    try {
+      for (;; ) {
+        const next = await Promise.race([iterator.next(), aborted]);
+        if (next.done)
+          break;
+        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);
+        }
+        const item = parsed.data;
+        if (descriptor.terminal?.safeParse(item).success)
+          terminalSeen = true;
+        const frame = { 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);
+        }
+        yield frame;
+      }
+      if (!terminalSeen) {
+        throw new AppError("STREAM_TERMINAL_MISSING", "Stream completed before its declared terminal item", 500);
+      }
+      yield { type: "end" };
+    } catch (error) {
+      if (operationAbort.signal.aborted && !lifetimeExpired)
+        return;
+      if (lifetimeExpired) {
+        yield {
+          type: "error",
+          error: new AppError("STREAM_LIFETIME_EXCEEDED", "Stream exceeded its declared lifetime", 408).toJSON().error
+        };
+        return;
+      }
+      yield { type: "error", error: normalizeError(error).toJSON().error };
+    } finally {
+      if (lifetime !== undefined)
+        clearTimeout(lifetime);
+      operationAbort.abort();
+      Promise.resolve(iterator.return?.(undefined)).catch(() => {
+        return;
+      });
+    }
+  };
+  const route = streamingRoute({
+    path: "/",
+    format,
+    heartbeatMs: descriptor.heartbeatMs,
+    idleTimeoutSeconds: descriptor.idleTimeoutSeconds,
+    source: () => frames(),
+    onClose: () => operationAbort.abort()
+  });
+  return Promise.resolve(route.handler(request, context));
+}
+
 // src/server/logger.ts
 var c = {
   reset: "\x1B[0m",
@@ -1089,6 +1368,12 @@ function isClientClosedRequest(req, error) {
     return true;
   return req.signal.reason !== undefined && containsRequestAbortReason(error, req.signal.reason);
 }
+function isAsyncIterable(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  return typeof Reflect.get(value, Symbol.asyncIterator) === "function";
+}
 function createHandler(config) {
   const { cors, hooks, logging = false, observability, trustProxy = false } = config;
   if (cors)
@@ -1309,6 +1594,17 @@ function createHandler(config) {
       const responseMetadata = method.responseMeta ? createResponseMetadata() : undefined;
       if (responseMetadata)
         ctx.response = responseMetadata;
+      const streamAbort = method.stream ? new AbortController : undefined;
+      if (streamAbort) {
+        if (req.signal.aborted)
+          streamAbort.abort(req.signal.reason);
+        else {
+          req.signal.addEventListener("abort", () => streamAbort.abort(req.signal.reason), {
+            once: true
+          });
+        }
+        ctx.signal = streamAbort.signal;
+      }
       let result = await method.handler(ctx);
       if (method.rawResponse) {
         if (!(result instanceof Response)) {
@@ -1323,6 +1619,16 @@ function createHandler(config) {
         complete(rawRes.status);
         return rawRes;
       }
+      if (method.stream) {
+        if (!streamAbort || !isAsyncIterable(result)) {
+          streamAbort?.abort();
+          throw new AppError("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, cors, req);
+        complete(withCors.status);
+        return withCors;
+      }
       if (groupHooks?.afterHandle) {
         const transformed = await groupHooks.afterHandle(ctx, result, method);
         if (transformed !== undefined)
@@ -1347,14 +1653,14 @@ function createHandler(config) {
       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);
       }
-      const responseHeaders = new Headers(corsHeaders2(cors, req));
-      applyResponseMetadata(responseHeaders, responseMetadata, `${method.serviceName}.${method.key}`);
+      const responseHeaders2 = new Headers(corsHeaders2(cors, req));
+      applyResponseMetadata(responseHeaders2, responseMetadata, `${method.serviceName}.${method.key}`);
       if (!method.outputSchema) {
-        const empty = new Response(null, { status: responseStatus, headers: responseHeaders });
+        const empty = new Response(null, { status: responseStatus, headers: responseHeaders2 });
         complete(responseStatus);
         return empty;
       }
-      const body = Response.json(result, { status: responseStatus, headers: responseHeaders });
+      const body = Response.json(result, { status: responseStatus, headers: responseHeaders2 });
       complete(responseStatus);
       return body;
     } catch (err) {
@@ -1465,7 +1771,17 @@ function bindProcessSignals(handle, options = {}) {
   bound.add(handle);
   const signals = [...new Set(options.signals ?? DEFAULT_PROCESS_SIGNALS)];
   const source = options.signalSource ?? defaultSignalSource;
-  const budgets = ShutdownOptionsSchema.omit({ signal: true }).parse(options.shutdown ?? {});
+  const requested = options.shutdown ?? {};
+  const validated = ShutdownOptionsSchema.omit({ signal: true }).parse(requested);
+  const budgets = {
+    ...requested.gracePeriodMs !== undefined && { gracePeriodMs: validated.gracePeriodMs },
+    ...requested.forceTimeoutMs !== undefined && {
+      forceTimeoutMs: validated.forceTimeoutMs
+    },
+    ...requested.retryAfterSeconds !== undefined && {
+      retryAfterSeconds: validated.retryAfterSeconds
+    }
+  };
   const controller = new AbortController;
   const handlers = [];
   let started = false;
@@ -2096,4 +2412,771 @@ function socketIoLane(websocket) {
   });
 }
 
-export { parseMultipart, createHandler, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };
+// src/server/unix-client-error.ts
+class UnixClientTransportError extends Error {
+  code;
+  delivery;
+  constructor(code, message, delivery = "possibly-dispatched", options) {
+    super(message, options);
+    this.code = code;
+    this.delivery = delivery;
+    this.name = "UnixClientTransportError";
+  }
+}
+
+// src/server/unix-client.ts
+import {
+  Agent,
+  request as httpRequest
+} from "node:http";
+
+// src/server/unix-client-body.ts
+async function readBoundedRequestBody(request, maxBytes) {
+  const body = request.body;
+  if (!body)
+    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");
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (;; ) {
+      if (request.signal.aborted)
+        throw request.signal.reason;
+      const chunk = await reader.read();
+      if (chunk.done)
+        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");
+      }
+      chunks.push(chunk.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+function boundedIncomingBody(response, maxBytes, onDone) {
+  let finished = false;
+  let received = 0;
+  const finish = () => {
+    if (finished)
+      return;
+    finished = true;
+    onDone();
+  };
+  return new ReadableStream({
+    start(controller) {
+      response.pause();
+      response.on("data", (chunk) => {
+        if (finished)
+          return;
+        received += chunk.byteLength;
+        if (received > maxBytes) {
+          controller.error(new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${maxBytes} byte limit`, "response-received"));
+          response.destroy();
+          finish();
+          return;
+        }
+        controller.enqueue(new Uint8Array(chunk));
+        response.pause();
+      });
+      response.once("end", () => {
+        if (finished)
+          return;
+        controller.close();
+        finish();
+      });
+      response.once("aborted", () => {
+        if (finished)
+          return;
+        controller.error(new UnixClientTransportError("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 }));
+        finish();
+      });
+    },
+    pull() {
+      response.resume();
+    },
+    cancel() {
+      response.destroy();
+      finish();
+    }
+  }, { highWaterMark: 1 });
+}
+
+// src/server/unix-client-bun.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;
+}
+function concatBytes2(left, right) {
+  if (left.byteLength === 0)
+    return right.slice();
+  const combined = new Uint8Array(left.byteLength + right.byteLength);
+  combined.set(left);
+  combined.set(right, left.byteLength);
+  return combined;
+}
+function indexOfSequence(bytes, sequence) {
+  outer:
+    for (let index = 0;index <= bytes.byteLength - sequence.length; index += 1) {
+      for (let offset = 0;offset < sequence.length; offset += 1) {
+        if (bytes[index + offset] !== sequence[offset])
+          continue outer;
+      }
+      return index;
+    }
+  return -1;
+}
+function requestBytes(request, body) {
+  const url = new URL(request.url);
+  const headers = new Headers(request.headers);
+  headers.set("host", url.host);
+  headers.set("connection", "close");
+  headers.set("accept-encoding", "identity");
+  headers.delete("transfer-encoding");
+  headers.delete("content-length");
+  if (body !== undefined)
+    headers.set("content-length", String(body.byteLength));
+  const lines = [`${request.method} ${url.pathname}${url.search} HTTP/1.1`];
+  for (const [name, value] of headers)
+    lines.push(`${name}: ${value}`);
+  const head = new TextEncoder().encode(`${lines.join(`\r
+`)}\r
+\r
+`);
+  return body === undefined ? head : concatBytes2(head, body);
+}
+function parseContentLength(headers) {
+  const raw = headers.get("content-length");
+  if (raw === null)
+    return;
+  if (!/^\d+$/.test(raw))
+    throw new Error("Unix response has an invalid Content-Length");
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value)) {
+    throw new Error("Unix response Content-Length is not a safe integer");
+  }
+  return value;
+}
+function bunUnixRequest(options) {
+  const outgoing = requestBytes(options.request, options.body);
+  const bun = runtimeBun();
+  if (!bun)
+    throw new Error("Bun Unix runtime is unavailable");
+  let socket;
+  let controller;
+  let wire = new Uint8Array;
+  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 = () => {
+    return;
+  };
+  let rejectResponse = () => {
+    return;
+  };
+  const response = new Promise((resolve, reject) => {
+    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 clearRegistration = options.registerAbort(() => {
+    fail(new UnixClientTransportError("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`));
+  }, options.headersTimeoutMs);
+  timer.unref();
+  const removeRequestAbort = () => {
+    options.request.signal.removeEventListener("abort", abortRequest);
+  };
+  const finish = (terminate = true) => {
+    if (settled)
+      return;
+    settled = true;
+    clearTimeout(timer);
+    clearRegistration();
+    removeRequestAbort();
+    if (terminate)
+      socket?.terminate();
+  };
+  function fail(error) {
+    if (settled)
+      return;
+    if (responseResolved)
+      controller?.error(error);
+    else
+      rejectResponse(error);
+    finish();
+  }
+  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) => {
+    received += value.byteLength;
+    if (received > options.maxResponseBytes) {
+      fail(new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${options.maxResponseBytes} byte limit`, "response-received"));
+      return;
+    }
+    controller?.enqueue(value);
+  };
+  const completeBody = () => {
+    if (bodyComplete || settled)
+      return;
+    bodyComplete = true;
+    controller?.close();
+    finish();
+  };
+  const resumeForData = () => {
+    if (settled || bodyComplete || peerEnded)
+      return;
+    socket?.resume();
+  };
+  const pumpChunked = () => {
+    if (!controller || settled || bodyComplete)
+      return;
+    for (;; ) {
+      if ((controller.desiredSize ?? 1) <= 0)
+        return;
+      if (trailers) {
+        if (wire.byteLength >= 2 && wire[0] === 13 && wire[1] === 10) {
+          takeWire(2);
+          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);
+        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);
+      enqueue(takeWire(bytes));
+      if (settled)
+        return;
+      chunkRemaining -= bytes;
+      if (chunkRemaining === 0) {
+        chunkRemaining = undefined;
+        expectChunkCrlf = true;
+      }
+      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();
+      }
+      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 {
+        socket?.resume();
+      }
+      return;
+    }
+    if (headerEnd > options.maxHeaderBytes) {
+      fail(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${options.maxHeaderBytes} byte limit`, "response-received"));
+      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")));
+      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 (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;
+    const bodyless = options.request.method === "HEAD" || status === 204 || status === 205 || status === 304;
+    clearTimeout(timer);
+    responseResolved = true;
+    if (bodyless || remainingLength === 0) {
+      resolveResponse(new Response(null, { status, statusText, headers }));
+      finish();
+      return;
+    }
+    const body = new ReadableStream({
+      start(value) {
+        controller = value;
+        pump();
+      },
+      pull() {
+        pump();
+      },
+      cancel() {
+        finish();
+      }
+    }, { highWaterMark: 1 });
+    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;
+    }
+  };
+  if (options.request.signal.aborted) {
+    fail(options.request.signal.reason ?? new DOMException("Request aborted", "AbortError"));
+    return response;
+  }
+  options.request.signal.addEventListener("abort", abortRequest, { once: true });
+  bun.connect({
+    unix: options.socketPath,
+    socket: {
+      binaryType: "uint8array",
+      open(active) {
+        socket = active;
+        if (settled) {
+          active.terminate();
+          return;
+        }
+        flushRequest(active);
+      },
+      drain(active) {
+        flushRequest(active);
+      },
+      data(active, data) {
+        active.pause();
+        wire = concatBytes2(wire, 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) {
+        peerEnded = true;
+        if (settled)
+          return;
+        if (error)
+          fail(transportFailure(error));
+        else if (!responseResolved) {
+          fail(transportFailure(new Error("Unix connection closed before response headers")));
+        } else
+          pump();
+      },
+      error(_active, error) {
+        fail(transportFailure(error));
+      },
+      connectError(_active, error) {
+        fail(transportFailure(error));
+      }
+    }
+  }).catch((error) => fail(transportFailure(error)));
+  return response;
+}
+
+// src/server/unix-client.ts
+var DEFAULT_MAX_BODY_BYTES = 16 * 1024 * 1024;
+var DEFAULT_HEADERS_TIMEOUT_MS = 30000;
+var DEFAULT_MAX_CONNECTIONS = 8;
+var DEFAULT_MAX_REDIRECTS = 5;
+var DEFAULT_MAX_HEADER_BYTES2 = 64 * 1024;
+function positiveInteger(value, fallback, name) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+    throw new TypeError(`${name} must be a positive safe integer`);
+  }
+  return resolved;
+}
+function nonNegativeInteger(value, fallback, name) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < 0) {
+    throw new TypeError(`${name} must be a non-negative safe integer`);
+  }
+  return resolved;
+}
+function isRedirect(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function requestBody(body) {
+  if (body === undefined)
+    return;
+  const copy = new ArrayBuffer(body.byteLength);
+  new Uint8Array(copy).set(body);
+  return copy;
+}
+function responseHeaders2(response) {
+  const headers = new Headers;
+  for (let index = 0;index < response.rawHeaders.length; index += 2) {
+    const name = response.rawHeaders[index];
+    const value = response.rawHeaders[index + 1];
+    if (name !== undefined && value !== undefined)
+      headers.append(name, value);
+  }
+  return headers;
+}
+function redirectedRequest(request, location, status, body) {
+  const url = new URL(location, request.url);
+  const changesToGet = status === 303 || (status === 301 || status === 302) && request.method === "POST";
+  const headers = new Headers(request.headers);
+  if (changesToGet) {
+    headers.delete("content-length");
+    headers.delete("content-type");
+  }
+  return new Request(url, {
+    method: changesToGet ? "GET" : request.method,
+    headers,
+    ...!changesToGet && body !== undefined && { body: requestBody(body) },
+    redirect: request.redirect,
+    signal: request.signal
+  });
+}
+function createUnixClientTransport(config) {
+  if (!config.socketPath.startsWith("/") || config.socketPath.includes("\x00")) {
+    throw new TypeError("socketPath must be an absolute Unix socket path");
+  }
+  const maxRequestBytes = positiveInteger(config.maxRequestBytes, DEFAULT_MAX_BODY_BYTES, "maxRequestBytes");
+  const maxResponseBytes = positiveInteger(config.maxResponseBytes, DEFAULT_MAX_BODY_BYTES, "maxResponseBytes");
+  const headersTimeoutMs = positiveInteger(config.headersTimeoutMs, DEFAULT_HEADERS_TIMEOUT_MS, "headersTimeoutMs");
+  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");
+  const agent = new Agent({ keepAlive: true, maxSockets: maxConnections });
+  const activeRequests = new Set;
+  const activeResponses = new Set;
+  const bunAborters = new Set;
+  let closed = false;
+  const dispatch = async (request, redirectCount) => {
+    if (closed) {
+      throw new UnixClientTransportError("UNIX_CLIENT_CLOSED", "Unix client transport is closed", "not-dispatched");
+    }
+    if (request.signal.aborted)
+      throw request.signal.reason;
+    const url = new URL(request.url);
+    if (url.protocol !== "http:") {
+      throw new TypeError("Unix client transport accepts only http: request URLs");
+    }
+    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");
+      }
+      const response = await bunUnixRequest({
+        socketPath: config.socketPath,
+        request,
+        body,
+        maxResponseBytes,
+        maxHeaderBytes,
+        headersTimeoutMs,
+        registerAbort(abort) {
+          bunAborters.add(abort);
+          return () => void bunAborters.delete(abort);
+        }
+      });
+      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 dispatch(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
+        }
+      }
+      return response;
+    }
+    const headers = Object.fromEntries(request.headers.entries());
+    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
+      }, 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) => {
+        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);
+    });
+    activeResponses.add(incoming);
+    const releaseResponse = () => void activeResponses.delete(incoming);
+    const status = incoming.statusCode ?? 0;
+    const responseHeadersValue = responseHeaders2(incoming);
+    const declaredResponseBytes = responseHeadersValue.get("content-length");
+    if (declaredResponseBytes !== null && /^\d+$/.test(declaredResponseBytes) && Number(declaredResponseBytes) > maxResponseBytes) {
+      incoming.destroy();
+      releaseResponse();
+      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 dispatch(redirectedRequest(request, location, status, body), redirectCount + 1);
+      }
+    }
+    const bodyless = request.method === "HEAD" || status === 204 || status === 205 || status === 304;
+    if (bodyless) {
+      incoming.resume();
+      incoming.once("end", releaseResponse);
+      return new Response(null, {
+        status,
+        statusText: incoming.statusMessage,
+        headers: responseHeadersValue
+      });
+    }
+    return new Response(boundedIncomingBody(incoming, maxResponseBytes, releaseResponse), {
+      status,
+      statusText: incoming.statusMessage,
+      headers: responseHeadersValue
+    });
+  };
+  return {
+    fetch(input, init) {
+      return dispatch(new Request(input, init), 0);
+    },
+    get closed() {
+      return closed;
+    },
+    async close() {
+      if (closed)
+        return;
+      closed = true;
+      for (const request of activeRequests)
+        request.destroy();
+      for (const response of activeResponses)
+        response.destroy();
+      for (const abort of [...bunAborters])
+        abort();
+      activeRequests.clear();
+      activeResponses.clear();
+      bunAborters.clear();
+      agent.destroy();
+    }
+  };
+}
+
+export { parseMultipart, DEFAULT_STREAM_HEARTBEAT_MS, streamingRoute, ndjsonRoute, sseRoute, createHandler, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane, UnixClientTransportError, createUnixClientTransport };