stitchkit 0.93.0 → 0.94.1

package/dist/index-p3vsv1fb.js

@@ -0,0 +1,3493 @@
+import {
+  RELEASE_HEADER
+} from "./index-y91ry9h2.js";
+import {
+  ShutdownOptionsSchema,
+  isStreamCancellation,
+  ownHttpStream,
+  settleStreamCleanup
+} from "./index-3z73fh2c.js";
+import {
+  createValidatedRealtimeSocket,
+  isModuleNotFound
+} from "./index-ndddxtyx.js";
+import {
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES
+} from "./index-wqgjfstn.js";
+import {
+  DEFAULT_PROCESS_SIGNALS,
+  applyCors,
+  assertCorsConfig,
+  bindContract,
+  corsPreflightResponse,
+  defaultSignalSource,
+  guardSignalCallback,
+  isOriginAllowed,
+  mediaTypeEssence,
+  reportSignalError,
+  requestCorsHeaders
+} from "./index-2gxzjvyr.js";
+import {
+  joinRoutePath,
+  parseTrailingWildcard
+} from "./index-4gcnakhx.js";
+import {
+  getRequestContext,
+  runWithRequestContext,
+  setRequestEndpoint,
+  setRequestError
+} from "./index-zfrhfn82.js";
+import {
+  extractIp,
+  getClientInfo,
+  parseQueryParams,
+  resolveSocketIp,
+  resolveTraceId
+} from "./index-35mh5bhj.js";
+import {
+  resolveTraceContext
+} from "./index-zcgf3gqf.js";
+import {
+  errorCode,
+  normalizeError,
+  recordedErrorMessage,
+  validateDeclaredOutput
+} from "./index-znfs20ss.js";
+import {
+  AppError,
+  badRequest,
+  forbidden
+} from "./index-2vtcmrj9.js";
+import {
+  isUnsafeKey,
+  safeJsonParse
+} from "./index-kzfs85xp.js";
+import {
+  isRecord,
+  transportResult
+} from "./index-hffjpmq9.js";
+
+// src/server/multipart-reader.ts
+var DEFAULT_MAX_HEADER_BYTES = 64 * 1024;
+var CRLF = new Uint8Array([13, 10]);
+var HEADER_END = new Uint8Array([13, 10, 13, 10]);
+var decoder = new TextDecoder;
+var headerDecoder = new TextDecoder("utf-8", { fatal: true });
+var encoder = new TextEncoder;
+var TOKEN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+function hasControl(value, allowTab = false) {
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 32 && !(allowTab && code === 9) || code === 127)
+      return true;
+  }
+  return false;
+}
+function trimWhitespace(value) {
+  return value.replace(/^[ \t]+|[ \t]+$/g, "");
+}
+function indexOfBytes(haystack, needle) {
+  outer:
+    for (let index = 0;index <= haystack.length - needle.length; index += 1) {
+      for (let offset = 0;offset < needle.length; offset += 1) {
+        if (haystack[index + offset] !== needle[offset])
+          continue outer;
+      }
+      return index;
+    }
+  return -1;
+}
+function startsWithBytes(value, prefix) {
+  if (value.length < prefix.length)
+    return false;
+  for (let index = 0;index < prefix.length; index += 1) {
+    if (value[index] !== prefix[index])
+      return false;
+  }
+  return true;
+}
+function concatBytes(left, right) {
+  if (left.length === 0)
+    return right.slice();
+  if (right.length === 0)
+    return left.slice();
+  const joined = new Uint8Array(left.length + right.length);
+  joined.set(left);
+  joined.set(right, left.length);
+  return joined;
+}
+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");
+  }
+  const match = /(?:^|;)\s*boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(contentType);
+  const boundary = match?.[1] ?? match?.[2];
+  if (!boundary || boundary.length > 200)
+    badRequest("Invalid multipart boundary");
+  return boundary;
+}
+function parseDisposition(value) {
+  if (!value)
+    badRequest("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");
+  }
+  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");
+    const key = match[1].toLowerCase();
+    if (!TOKEN.test(key) || parameters.has(key)) {
+      badRequest("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");
+    }
+    const decoded = quoted === undefined ? raw : quoted.replace(/\\(.)/g, "$1");
+    if (hasControl(decoded))
+      badRequest("Invalid multipart disposition parameter");
+    parameters.set(key, decoded);
+    rest = rest.slice(match[0].length);
+  }
+  const name = parameters.get("name");
+  let filename = parameters.get("filename");
+  const extended = parameters.get("filename*");
+  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");
+    try {
+      filename = decodeURIComponent(match[1] ?? "");
+    } catch {
+      badRequest("Invalid multipart extended filename");
+    }
+    if (hasControl(filename))
+      badRequest("Invalid multipart extended filename");
+  }
+  if (!name || isUnsafeKey(name))
+    badRequest("Invalid multipart field name");
+  return filename === undefined ? { name } : { name, filename };
+}
+function parsePartHeaders(bytes) {
+  let text;
+  try {
+    text = headerDecoder.decode(bytes);
+  } catch {
+    badRequest("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");
+    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");
+    }
+    if (headers.has(name))
+      badRequest("Duplicate multipart header");
+    headers.set(name, value);
+  }
+  const disposition = parseDisposition(headers.get("content-disposition") ?? undefined);
+  const rawContentType = headers.get("content-type");
+  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");
+  }
+  const declaredSize = rawSize === undefined ? undefined : Number(rawSize);
+  if (declaredSize !== undefined && (!Number.isSafeInteger(declaredSize) || declaredSize < 0)) {
+    badRequest("Invalid multipart part content-length");
+  }
+  return { ...disposition, contentType, declaredSize };
+}
+
+class MultipartStreamReader {
+  #reader;
+  #delimiter;
+  #initialBoundary;
+  #maxRequestBytes;
+  #buffer = new Uint8Array;
+  #readBytes = 0;
+  #sourceDone = false;
+  #terminal = false;
+  #activePart = false;
+  constructor(req, boundary, maxRequestBytes) {
+    if (!req.body)
+      badRequest("Multipart request body is empty");
+    this.#reader = req.body.getReader();
+    this.#delimiter = encoder.encode(`\r
+--${boundary}`);
+    this.#initialBoundary = encoder.encode(`--${boundary}`);
+    this.#maxRequestBytes = maxRequestBytes;
+  }
+  async start() {
+    await this.#ensure(this.#initialBoundary.length + 2);
+    if (!startsWithBytes(this.#buffer, this.#initialBoundary)) {
+      badRequest("Malformed multipart body");
+    }
+    this.#consume(this.#initialBoundary.length);
+    await this.#consumeBoundarySuffix();
+  }
+  async nextPart() {
+    if (this.#activePart)
+      badRequest("Multipart part stream was not fully consumed");
+    if (this.#terminal)
+      return null;
+    const header = await this.#readUntil(HEADER_END, DEFAULT_MAX_HEADER_BYTES);
+    const parsed = parsePartHeaders(header);
+    this.#activePart = true;
+    let ended = false;
+    const stream = new ReadableStream({
+      pull: async (controller) => {
+        if (ended) {
+          controller.close();
+          return;
+        }
+        try {
+          const chunk = await this.#readPartChunk();
+          if (chunk.value.length > 0)
+            controller.enqueue(chunk.value);
+          if (chunk.end) {
+            ended = true;
+            controller.close();
+          }
+        } catch (error) {
+          controller.error(error);
+          this.cancel(error);
+        }
+      },
+      cancel: (reason) => {
+        this.cancel(reason);
+      }
+    });
+    return { ...parsed, stream, consumed: () => ended };
+  }
+  cancel(reason) {
+    this.#reader.cancel(reason).catch(() => {});
+  }
+  release() {
+    this.#reader.releaseLock();
+  }
+  async#readPartChunk() {
+    while (true) {
+      const boundaryIndex = indexOfBytes(this.#buffer, this.#delimiter);
+      if (boundaryIndex >= 0) {
+        const value = this.#buffer.slice(0, boundaryIndex);
+        this.#consume(boundaryIndex + this.#delimiter.length);
+        await this.#consumeBoundarySuffix();
+        this.#activePart = false;
+        return { value, end: true };
+      }
+      const retained = this.#delimiter.length - 1;
+      if (this.#buffer.length > retained) {
+        const emitLength = this.#buffer.length - retained;
+        const value = this.#buffer.slice(0, emitLength);
+        this.#consume(emitLength);
+        return { value, end: false };
+      }
+      if (this.#sourceDone)
+        badRequest("Incomplete multipart body");
+      await this.#readMore();
+    }
+  }
+  async#consumeBoundarySuffix() {
+    await this.#ensure(2);
+    if (this.#buffer[0] === 45 && this.#buffer[1] === 45) {
+      this.#consume(2);
+      this.#terminal = true;
+      if (startsWithBytes(this.#buffer, CRLF))
+        this.#consume(2);
+      return;
+    }
+    if (!startsWithBytes(this.#buffer, CRLF))
+      badRequest("Malformed multipart boundary");
+    this.#consume(2);
+  }
+  async#readUntil(marker, maxBytes) {
+    while (true) {
+      const index = indexOfBytes(this.#buffer, marker);
+      if (index >= 0) {
+        if (index > maxBytes)
+          badRequest("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");
+      if (this.#sourceDone)
+        badRequest("Incomplete multipart headers");
+      await this.#readMore();
+    }
+  }
+  async#ensure(length) {
+    while (this.#buffer.length < length && !this.#sourceDone)
+      await this.#readMore();
+    if (this.#buffer.length < length)
+      badRequest("Incomplete multipart body");
+  }
+  async#readMore() {
+    const result = await this.#reader.read();
+    if (result.done) {
+      this.#sourceDone = true;
+      return;
+    }
+    this.#readBytes += result.value.length;
+    if (this.#readBytes > this.#maxRequestBytes) {
+      this.cancel();
+      badRequest(`Multipart request exceeds ${this.#maxRequestBytes} bytes`);
+    }
+    this.#buffer = concatBytes(this.#buffer, result.value);
+  }
+  #consume(length) {
+    this.#buffer = this.#buffer.slice(length);
+  }
+}
+
+// src/server/multipart.ts
+var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
+var DEFAULT_MAX_FIELD_BYTES = 1024 * 1024;
+var DEFAULT_MAX_PARTS = 1000;
+function matchesContentType(contentType, accepted) {
+  const normalized = contentType.toLowerCase();
+  return accepted.some((candidate) => {
+    const policy = candidate.toLowerCase();
+    return policy.endsWith("/*") ? normalized.startsWith(policy.slice(0, -1)) : normalized === policy;
+  });
+}
+function limitedStream(stream, maxBytes, label, signal) {
+  const reader = stream.getReader();
+  let total = 0;
+  const cancelReader = (reason) => {
+    reader.cancel(reason).catch(() => {});
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      if (signal.aborted) {
+        cancelReader(signal.reason);
+        controller.error(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        return;
+      }
+      try {
+        const result = await reader.read();
+        if (result.done) {
+          controller.close();
+          reader.releaseLock();
+          return;
+        }
+        total += result.value.length;
+        if (total > maxBytes) {
+          cancelReader();
+          badRequest(`${label} exceeds ${maxBytes} bytes`);
+        }
+        controller.enqueue(result.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    cancel(reason) {
+      cancelReader(reason);
+    }
+  });
+}
+async function collectFile(part, stream) {
+  const chunks = [];
+  const reader = stream.getReader();
+  while (true) {
+    const result = await reader.read();
+    if (result.done)
+      break;
+    chunks.push(Uint8Array.from(result.value).buffer);
+  }
+  return new File(chunks, part.filename ?? "upload", {
+    type: part.contentType ?? "application/octet-stream"
+  });
+}
+async function readText(stream, maxBytes) {
+  const chunks = [];
+  const reader = stream.getReader();
+  let total = 0;
+  while (true) {
+    const result = await reader.read();
+    if (result.done)
+      break;
+    total += result.value.length;
+    if (total > maxBytes) {
+      await reader.cancel();
+      badRequest(`Multipart text field exceeds ${maxBytes} bytes`);
+    }
+    chunks.push(result.value);
+  }
+  const value = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    value.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return decoder.decode(value);
+}
+function required(policy) {
+  return policy.required !== false;
+}
+async function parseMultipart(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`);
+  }
+  const boundary = parseBoundary(req);
+  const parser = new MultipartStreamReader(req, boundary, maxRequestBytes);
+  const fields = {};
+  const files = {};
+  const counts = new Map;
+  const cleanups = [];
+  let rolledBack = false;
+  const rollback = async () => {
+    if (rolledBack)
+      return;
+    rolledBack = true;
+    for (let index = cleanups.length - 1;index >= 0; index -= 1) {
+      try {
+        await cleanups[index]?.();
+      } catch (error) {
+        console.error("[stitchkit] multipart receiver cleanup failed", error);
+      }
+    }
+  };
+  try {
+    await parser.start();
+    let partCount = 0;
+    while (true) {
+      const part = await parser.nextPart();
+      if (!part)
+        break;
+      partCount += 1;
+      if (partCount > DEFAULT_MAX_PARTS)
+        badRequest("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`);
+        if (Object.hasOwn(fields, part.name)) {
+          badRequest(`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}`);
+      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}`);
+      const contentType = part.contentType ?? "";
+      if (policy.contentTypes && !matchesContentType(contentType, policy.contentTypes)) {
+        badRequest(`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`);
+      }
+      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}`);
+        const result = await receiver({
+          metadata: {
+            field: part.name,
+            filename: part.filename ?? "upload",
+            contentType: contentType || "application/octet-stream",
+            size: part.declaredSize
+          },
+          stream,
+          signal: req.signal
+        });
+        cleanups.push(result.cleanup);
+        if (!part.consumed()) {
+          await stream.cancel();
+          badRequest(`Multipart receiver for "${part.name}" did not consume its stream`);
+        }
+        value = result.value;
+      } else {
+        value = await collectFile(part, stream);
+      }
+      if (policy.multiple === true) {
+        const existing = files[part.name];
+        if (Array.isArray(existing))
+          existing.push(value);
+        else
+          files[part.name] = [value];
+      } else {
+        files[part.name] = value;
+      }
+    }
+    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}`);
+      if (policy.multiple === true && count === 0 && !required(policy))
+        files[field] = [];
+    }
+    return {
+      files,
+      fields: fieldsSchema ? fieldsSchema.parse(fields) : fields,
+      rollback
+    };
+  } catch (error) {
+    parser.cancel(error);
+    await rollback();
+    throw error;
+  } finally {
+    parser.release();
+  }
+}
+
+// src/server/streaming-pump.ts
+async function pumpFrames(p) {
+  let sinceYield = 0;
+  try {
+    for (;; ) {
+      await p.awaitDemand();
+      if (p.isClosed())
+        return;
+      const next = await p.iterator.next();
+      if (p.isClosed())
+        return;
+      if (next.done)
+        break;
+      if (!p.send(p.framing.frame(next.value)))
+        return;
+      sinceYield += 1;
+      if (sinceYield >= MAX_BUFFERED_FRAMES) {
+        sinceYield = 0;
+        await new Promise((resolve) => {
+          setTimeout(resolve, 0);
+        });
+        if (p.isClosed())
+          return;
+      }
+    }
+    if (p.framing.done)
+      p.send(p.framing.done);
+  } catch (error) {
+    if (p.isClosed()) {
+      if (!isStreamCancellation(error, p.departed))
+        p.pumped.reject(error);
+    } else
+      p.send(p.framing.frame(normalizeError(error).toJSON()));
+  } finally {
+    p.pumped.resolve();
+    p.end();
+  }
+}
+
+// src/server/streaming-route.ts
+var DEFAULT_STREAM_HEARTBEAT_MS = 5000;
+var FRAMINGS = {
+  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 streamingTimings(options) {
+  const heartbeatMs = options.heartbeatMs ?? DEFAULT_STREAM_HEARTBEAT_MS;
+  if (!Number.isFinite(heartbeatMs) || heartbeatMs <= 0) {
+    throw new TypeError("heartbeatMs must be a finite positive number of milliseconds");
+  }
+  const idleTimeoutSeconds = options.idleTimeoutSeconds ?? 0;
+  if (!Number.isInteger(idleTimeoutSeconds) || idleTimeoutSeconds < 0) {
+    throw new TypeError("idleTimeoutSeconds must be a non-negative integer");
+  }
+  return { heartbeatMs, idleTimeoutSeconds };
+}
+function streamingRoute(options) {
+  const { heartbeatMs, idleTimeoutSeconds } = streamingTimings(options);
+  const framing = FRAMINGS[options.format ?? "ndjson"];
+  return {
+    method: options.method ?? "GET",
+    path: options.path,
+    handler: async (request, context) => {
+      applyIdleTimeout(context.server, request, idleTimeoutSeconds);
+      const departed = new AbortController;
+      const settled = Promise.withResolvers();
+      settled.promise.catch(() => {
+        return;
+      });
+      const pumped = Promise.withResolvers();
+      pumped.promise.catch(() => {
+        return;
+      });
+      let cancel = () => departed.abort();
+      ownHttpStream(request, { cancel: () => cancel(), settled: settled.promise });
+      let iterator;
+      try {
+        const iterable = await options.source(request, {
+          ...context,
+          signal: departed.signal
+        });
+        iterator = iterable[Symbol.asyncIterator]();
+      } catch (error) {
+        departed.abort();
+        settled.reject(error);
+        throw error;
+      }
+      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;
+        stopHeartbeat();
+        signalDemand();
+        request.signal.removeEventListener("abort", onRequestAbort);
+        departed.abort();
+        const hook = Promise.withResolvers();
+        try {
+          options.onClose?.();
+          hook.resolve();
+        } catch (error) {
+          hook.reject(error);
+        }
+        settleStreamCleanup([
+          hook.promise,
+          pumped.promise,
+          Promise.resolve().then(() => iterator.return?.(undefined))
+        ]).then(() => settled.resolve(), (error) => settled.reject(error));
+      };
+      let demand = null;
+      const signalDemand = () => {
+        const resolve = demand;
+        demand = null;
+        resolve?.();
+      };
+      const onRequestAbort = () => cancel();
+      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 {}
+          };
+          cancel = () => {
+            release();
+            finish();
+          };
+          if (request.signal.aborted || departed.signal.aborted) {
+            pumped.resolve();
+            cancel();
+            return;
+          }
+          request.signal.addEventListener("abort", onRequestAbort, { once: true });
+          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;
+              });
+            }
+          };
+          pumpFrames({
+            iterator,
+            framing,
+            send,
+            awaitDemand,
+            isClosed: () => closed,
+            departed: departed.signal,
+            pumped,
+            end: () => {
+              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/context-contribution.ts
+var RUNTIME_CONTEXT_RESERVED_KEYS = new Set([
+  "params",
+  "input",
+  "files",
+  "rawBody",
+  "source",
+  "req",
+  "url",
+  "headers",
+  "traceId",
+  "spanId",
+  "ipAddress",
+  "userAgent",
+  "signal",
+  "mcp",
+  "reportProgress"
+]);
+function contributionError(scope, reason) {
+  return new TypeError(`[stitchkit] auth: invalid context contribution for scope ${JSON.stringify(scope)}: ${reason}`);
+}
+function descriptorsEqual(left, right) {
+  if (!left || !right)
+    return left === right;
+  if (left.enumerable !== right.enumerable || left.configurable !== right.configurable || left.writable !== right.writable) {
+    return false;
+  }
+  if ("value" in left || "value" in right) {
+    return "value" in left && "value" in right && Object.is(left.value, right.value);
+  }
+  return left.get === right.get && left.set === right.set;
+}
+function contextContributionDelta(original, shadow, scope) {
+  if (Object.getPrototypeOf(shadow) !== Object.getPrototypeOf(original)) {
+    throw contributionError(scope, "context prototype changes are not supported");
+  }
+  const originalKeys = Reflect.ownKeys(original);
+  const shadowKeys = Reflect.ownKeys(shadow);
+  const shadowKeySet = new Set(shadowKeys);
+  for (const key of originalKeys) {
+    if (!shadowKeySet.has(key)) {
+      const printable = typeof key === "string" ? JSON.stringify(key) : "a symbol key";
+      throw contributionError(scope, `context key ${printable} may not be deleted`);
+    }
+  }
+  const contribution = Object.create(null);
+  for (const key of shadowKeys) {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(original, key);
+    const shadowDescriptor = Object.getOwnPropertyDescriptor(shadow, key);
+    if (!shadowDescriptor || descriptorsEqual(originalDescriptor, shadowDescriptor))
+      continue;
+    Object.defineProperty(contribution, key, shadowDescriptor);
+  }
+  return contribution;
+}
+function prepareContextContribution(value, scope) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw contributionError(scope, "expected a plain record");
+  }
+  let prototype;
+  let descriptors;
+  let keys;
+  try {
+    prototype = Object.getPrototypeOf(value);
+    descriptors = Object.getOwnPropertyDescriptors(value);
+    keys = Reflect.ownKeys(value);
+  } catch {
+    throw contributionError(scope, "record inspection failed");
+  }
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw contributionError(scope, "expected Object.prototype or null prototype");
+  }
+  const prepared = Object.create(null);
+  for (const key of keys) {
+    if (typeof key !== "string") {
+      throw contributionError(scope, "symbol keys are not supported");
+    }
+    if (isUnsafeKey(key)) {
+      throw contributionError(scope, `unsafe key ${JSON.stringify(key)}`);
+    }
+    if (RUNTIME_CONTEXT_RESERVED_KEYS.has(key)) {
+      throw contributionError(scope, `reserved key ${JSON.stringify(key)}`);
+    }
+    const descriptor = descriptors[key];
+    if (!descriptor?.enumerable || !("value" in descriptor)) {
+      throw contributionError(scope, `key ${JSON.stringify(key)} must be enumerable data`);
+    }
+    prepared[key] = descriptor.value;
+  }
+  return prepared;
+}
+function mergeContextContribution(ctx, value, scope) {
+  Object.assign(ctx, prepareContextContribution(value, scope));
+}
+
+// src/server/request-body.ts
+function requestAbortReason(req) {
+  return req.signal.reason ?? new DOMException("The connection was closed", "AbortError");
+}
+function throwIfRequestAborted(req) {
+  if (req.signal.aborted)
+    throw requestAbortReason(req);
+}
+function assertJsonBodyLimit(maxBytes, owner) {
+  if (maxBytes !== undefined && (!Number.isSafeInteger(maxBytes) || maxBytes <= 0)) {
+    throw new Error(`${owner} must be a positive safe integer, received ${maxBytes}`);
+  }
+}
+async function readRequestText(req, maxBytes) {
+  throwIfRequestAborted(req);
+  if (maxBytes === undefined)
+    return req.text();
+  assertJsonBodyLimit(maxBytes, "maxJsonBodyBytes");
+  const reader = req.body?.getReader();
+  if (!reader)
+    return "";
+  const chunks = [];
+  let total = 0;
+  let rejectAbortedRead = (_reason) => {
+    return;
+  };
+  const abortedRead = new Promise((_resolve, reject) => {
+    rejectAbortedRead = reject;
+  });
+  const onAbort = () => {
+    const reason = requestAbortReason(req);
+    rejectAbortedRead(reason);
+    reader.cancel(reason).catch(() => {
+      return;
+    });
+  };
+  req.signal.addEventListener("abort", onAbort, { once: true });
+  if (req.signal.aborted)
+    onAbort();
+  try {
+    while (true) {
+      const { done, value } = await Promise.race([reader.read(), abortedRead]);
+      if (done)
+        break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        badRequest(`JSON body exceeds the ${maxBytes}-byte limit`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    req.signal.removeEventListener("abort", onAbort);
+    if (!req.signal.aborted)
+      reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+// src/server/context.ts
+function parseJsonBody(req, text, method, cors) {
+  if (text.trim() === "")
+    return {};
+  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");
+    }
+    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");
+    }
+    if (!origin)
+      forbidden("A text/plain body requires an Origin header");
+    if (!isOriginAllowed(cors, origin)) {
+      forbidden("A text/plain body is accepted only from an allowed origin");
+    }
+  }
+  try {
+    return safeJsonParse(text);
+  } catch {
+    badRequest("Invalid JSON body");
+  }
+}
+function buildBaseContext(req, url, pathParams, traceId, clientIp) {
+  const safePathParams = {};
+  for (const [k, v] of Object.entries(pathParams)) {
+    if (!RUNTIME_CONTEXT_RESERVED_KEYS.has(k) && !isUnsafeKey(k))
+      safePathParams[k] = v;
+  }
+  return {
+    params: pathParams,
+    input: undefined,
+    source: "http",
+    req,
+    url,
+    headers: req.headers,
+    signal: req.signal,
+    ...safePathParams,
+    traceId,
+    ...getClientInfo(req, clientIp)
+  };
+}
+function parsePathParamsInto(ctx, method) {
+  if (method.paramsSchema) {
+    ctx.params = method.paramsSchema.parse(ctx.params);
+  }
+}
+async function parseRequestPayloadInto(ctx, req, url, method, maxJsonBodyBytes, cors) {
+  if (method.multipart) {
+    const multipart = await parseMultipart(req, method.multipart, method.inputSchema, method.multipartReceivers);
+    ctx.input = multipart.fields;
+    ctx.files = multipart.files;
+    return multipart;
+  }
+  if (method.inputSchema) {
+    if (req.method === "GET") {
+      ctx.input = method.inputSchema.parse(parseQueryParams(url));
+    } else if (req.method === "DELETE") {
+      if (mediaTypeEssence(req.headers.get("content-type")) === "application/json") {
+        const text = await readRequestText(req, method.maxJsonBodyBytes ?? maxJsonBodyBytes);
+        if (method.rawBody)
+          ctx.rawBody = text;
+        ctx.input = method.inputSchema.parse(parseJsonBody(req, text, method, cors));
+      } else {
+        ctx.input = method.inputSchema.parse(parseQueryParams(url));
+      }
+    } else {
+      const text = await readRequestText(req, method.maxJsonBodyBytes ?? maxJsonBodyBytes);
+      if (method.rawBody)
+        ctx.rawBody = text;
+      ctx.input = method.inputSchema.parse(parseJsonBody(req, text, method, cors));
+    }
+  }
+  return;
+}
+function buildErrorContext(req, url, traceId, clientIp) {
+  return {
+    params: undefined,
+    input: undefined,
+    source: "http",
+    req,
+    url,
+    headers: req.headers,
+    signal: req.signal,
+    traceId,
+    ...getClientInfo(req, 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;
+  const iterator = source[Symbol.asyncIterator]();
+  let pendingNext;
+  const settled = Promise.withResolvers();
+  settled.promise.catch(() => {
+    return;
+  });
+  let lifetime;
+  let lifetimeExpired = false;
+  let closing = false;
+  const closeSource = (cancelled = operationAbort.signal.aborted) => {
+    if (closing)
+      return;
+    closing = true;
+    if (lifetime !== undefined)
+      clearTimeout(lifetime);
+    operationAbort.abort();
+    settleStreamCleanup([
+      Promise.resolve(pendingNext).catch((error) => {
+        if (cancelled && !isStreamCancellation(error, operationAbort.signal))
+          throw error;
+      }),
+      Promise.resolve().then(() => iterator.return?.(undefined))
+    ]).then(() => settled.resolve(), (error) => settled.reject(error));
+  };
+  ownHttpStream(request, { cancel: () => closeSource(true), settled: settled.promise });
+  if (descriptor.lifetimeMs !== undefined && !closing) {
+    lifetime = setTimeout(() => {
+      lifetimeExpired = true;
+      operationAbort.abort(new Error("Stream lifetime expired"));
+    }, descriptor.lifetimeMs);
+    lifetime.unref?.();
+  }
+  const frames = async function* () {
+    if (closing)
+      return;
+    const aborted = waitForAbort(operationAbort.signal);
+    let terminalSeen = descriptor.terminal === undefined;
+    try {
+      for (;; ) {
+        pendingNext = Promise.resolve(iterator.next());
+        const next = await Promise.race([pendingNext, 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;
+        const terminal = descriptor.terminal?.safeParse(item).success ?? false;
+        if (terminal)
+          terminalSeen = true;
+        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);
+        }
+        yield frame;
+        if (terminal && descriptor.completion === "terminal")
+          return;
+      }
+      if (!terminalSeen) {
+        throw new AppError("STREAM_TERMINAL_MISSING", "Stream completed before its declared terminal item", 500);
+      }
+      if (descriptor.framing !== "item")
+        yield { type: "end" };
+    } catch (error) {
+      if (operationAbort.signal.aborted && !lifetimeExpired)
+        return;
+      if (lifetimeExpired) {
+        if (descriptor.framing === "item")
+          return;
+        yield {
+          type: "error",
+          error: new AppError("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));
+        return;
+      }
+      yield { type: "error", error: normalizeError(error).toJSON().error };
+    } finally {
+      if (lifetime !== undefined)
+        clearTimeout(lifetime);
+      closeSource();
+    }
+  };
+  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/response-metadata.ts
+var RESERVED_HEADERS = new Set(["content-type", "content-length", "x-request-id"]);
+function hasGetSetCookie(headers) {
+  return "getSetCookie" in headers && typeof headers.getSetCookie === "function";
+}
+function isReservedHeader(name) {
+  const normalized = name.toLowerCase();
+  return RESERVED_HEADERS.has(normalized) || normalized.startsWith("access-control-");
+}
+function createResponseMetadata() {
+  return { headers: new Headers };
+}
+function applyResponseMetadata(target, metadata, endpointIdentity) {
+  if (!metadata)
+    return;
+  for (const [name] of metadata.headers) {
+    if (isReservedHeader(name)) {
+      throw new Error(`${endpointIdentity} cannot set framework-owned response header "${name}"`);
+    }
+  }
+  const preservesSetCookie = hasGetSetCookie(metadata.headers);
+  for (const [name, value] of metadata.headers) {
+    if (name.toLowerCase() === "set-cookie" && preservesSetCookie)
+      continue;
+    target.append(name, value);
+  }
+  if (preservesSetCookie) {
+    for (const cookie of metadata.headers.getSetCookie()) {
+      target.append("Set-Cookie", cookie);
+    }
+  }
+}
+
+// src/server/endpoint-response.ts
+function isAsyncIterable(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  return typeof Reflect.get(value, Symbol.asyncIterator) === "function";
+}
+async function endpointResponse(state, request, outcome) {
+  const { method } = outcome.match;
+  if (method.rawResponse)
+    return rawEndpointResponse(state, request, outcome);
+  if (method.stream)
+    return streamEndpointResponse(state, request, outcome);
+  return dataEndpointResponse(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);
+  }
+  const response = method.method === "HEAD" ? new Response(null, {
+    status: result.status,
+    statusText: result.statusText,
+    headers: result.headers
+  }) : result;
+  const rawRes = applyCors(response, state.cors, request.req);
+  request.complete(rawRes.status);
+  return rawRes;
+}
+async function streamEndpointResponse(state, request, { match: { method, pathParams }, result, streamAbort }) {
+  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);
+  }
+  const response = await contractStreamResponse(req, { params: pathParams, server, ipAddress: clientIp.socketIp }, result, method.stream, streamAbort);
+  const withCors = applyCors(response, state.cors, req);
+  request.complete(withCors.status);
+  return withCors;
+}
+async function dataEndpointResponse(state, request, {
+  ctx,
+  match: { method, groupHooks },
+  result: handlerResult,
+  responseMetadata
+}) {
+  const { hooks, config, cors, warn } = state;
+  const { req } = request;
+  let result = handlerResult;
+  if (groupHooks?.afterHandle) {
+    const transformed = await groupHooks.afterHandle(ctx, result, method);
+    if (transformed !== undefined)
+      result = transformed;
+  }
+  if (hooks?.afterHandle) {
+    const transformed = await hooks.afterHandle(ctx, result, method);
+    if (transformed !== undefined)
+      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);
+  }
+  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);
+  }
+  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);
+  }
+  const responseHeaders2 = new Headers(requestCorsHeaders(cors, req));
+  applyResponseMetadata(responseHeaders2, responseMetadata, `${method.serviceName}.${method.key}`);
+  if (!method.outputSchema) {
+    const empty = new Response(null, { status: responseStatus, headers: responseHeaders2 });
+    request.complete(responseStatus);
+    return empty;
+  }
+  const body = Response.json(result, { status: responseStatus, headers: responseHeaders2 });
+  request.complete(responseStatus);
+  return body;
+}
+
+// src/server/endpoint-dispatch.ts
+async function dispatchEndpoint(state, request, match) {
+  const { hooks, config, cors } = state;
+  const { req, url, traceId, clientIp } = request;
+  const { method, pathParams, groupHooks } = match;
+  const ctx = buildBaseContext(req, url, pathParams, traceId, clientIp);
+  setRequestEndpoint(method.serviceName, method.key);
+  let multipartLifecycle;
+  try {
+    parsePathParamsInto(ctx, method);
+    if (hooks?.authorize) {
+      await hooks.authorize(ctx, method);
+    }
+    if (groupHooks?.authorize) {
+      await groupHooks.authorize(ctx, method);
+    }
+    multipartLifecycle = await parseRequestPayloadInto(ctx, req, url, method, config.maxJsonBodyBytes, cors);
+    if (hooks?.beforeHandle) {
+      await hooks.beforeHandle(ctx, method);
+    }
+    if (groupHooks?.beforeHandle) {
+      await groupHooks.beforeHandle(ctx, method);
+    }
+    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;
+    }
+    const result = await method.handler(ctx);
+    return await endpointResponse(state, request, {
+      ctx,
+      match,
+      result,
+      responseMetadata,
+      streamAbort
+    });
+  } catch (err) {
+    await multipartLifecycle?.rollback();
+    return request.respondError(err, ctx, method, groupHooks);
+  }
+}
+
+// src/server/error-dispatch.ts
+var MAX_REQUEST_ABORT_CAUSE_DEPTH = 8;
+function containsRequestAbortReason(error, reason) {
+  let current = error;
+  const visited = new Set;
+  for (let depth = 0;depth <= MAX_REQUEST_ABORT_CAUSE_DEPTH; depth += 1) {
+    if (current === reason)
+      return true;
+    if (depth === MAX_REQUEST_ABORT_CAUSE_DEPTH || !isRecord(current))
+      return false;
+    if (visited.has(current))
+      return false;
+    visited.add(current);
+    current = current.cause;
+  }
+  return false;
+}
+function isClientClosedRequest(req, error) {
+  if (!req.signal.aborted)
+    return false;
+  if (isRecord(error) && error.name === "AbortError")
+    return true;
+  return req.signal.reason !== undefined && containsRequestAbortReason(error, req.signal.reason);
+}
+function createErrorResponder(state, request) {
+  const { cors, hooks, customLogger } = state;
+  const { req, url, traceId, clientIp, complete } = request;
+  return async (err, errCtx, endpoint, group) => {
+    if (isClientClosedRequest(req, err)) {
+      const response = applyCors(new Response(null, { status: 499, statusText: "Client Closed Request" }), cors, req);
+      complete(response.status, undefined, "cancelled");
+      return response;
+    }
+    const recordFailure = (normalized) => {
+      if (getRequestContext()?.error !== undefined)
+        return;
+      const known = AppError.is(err) ? err : normalized;
+      const code = known?.code ?? errorCode(err) ?? "INTERNAL_SERVER_ERROR";
+      setRequestError({
+        code,
+        message: recordedErrorMessage(code, known?.message, err),
+        details: known?.details
+      });
+    };
+    const customResponse = await dispatchErrorHooks({
+      context: errCtx ?? buildErrorContext(req, url, traceId, clientIp),
+      error: err,
+      endpoint,
+      group,
+      global: hooks,
+      logger: customLogger,
+      respond: (response) => {
+        recordFailure();
+        const withCors = applyCors(response, cors, req);
+        complete(withCors.status, errorCode(err));
+        return withCors;
+      }
+    });
+    if (customResponse)
+      return customResponse;
+    const appErr = normalizeError(err);
+    recordFailure(appErr);
+    complete(appErr.status, appErr.code);
+    return Response.json(appErr.toJSON(), {
+      status: appErr.status,
+      headers: requestCorsHeaders(cors, req)
+    });
+  };
+}
+async function dispatchErrorHooks(config) {
+  for (const [scope, hooks] of [
+    ["group", config.group],
+    ["global", config.global]
+  ]) {
+    if (!hooks?.onError)
+      continue;
+    try {
+      const response = await hooks.onError(config.context, config.error, config.endpoint);
+      if (response instanceof Response)
+        return config.respond(response);
+    } catch (error) {
+      const message = `[stitchkit] ${scope} onError failed`;
+      try {
+        if (config.logger) {
+          config.logger.error(message, { error, traceId: config.context.traceId });
+        } else
+          console.error(message, error);
+      } catch {}
+    }
+  }
+  return;
+}
+
+// src/server/logging.ts
+var LOGGER_METHODS = ["info", "warn", "error", "debug"];
+function isBareLogger(value) {
+  if (value.logger !== undefined || value.skip !== undefined || value.enrich !== undefined) {
+    return false;
+  }
+  return LOGGER_METHODS.every((method) => typeof value[method] === "function");
+}
+function resolveLoggingConfig(logging) {
+  if (logging === false)
+    return null;
+  if (logging === true)
+    return {};
+  if (isRecord(logging) && isBareLogger(logging)) {
+    throw new Error("[stitchkit] `logging` no longer takes a StitchLogger directly — nest it: " + "`logging: { logger: myLogger }`.");
+  }
+  return logging;
+}
+function shouldSkipLog(config, req, url) {
+  if (!config.skip)
+    return false;
+  try {
+    return config.skip(req, url);
+  } catch {
+    return false;
+  }
+}
+function collectExtraLogFields(config, req, url, outcome) {
+  const fields = {};
+  const enrichKeys = [];
+  const ctx = getRequestContext();
+  if (ctx) {
+    if (ctx.userId)
+      fields.userId = ctx.userId;
+    if (ctx.serviceName)
+      fields.serviceName = ctx.serviceName;
+    if (ctx.action)
+      fields.action = ctx.action;
+    if (ctx.dimensions)
+      fields.dimensions = ctx.dimensions;
+  }
+  if (config.enrich) {
+    try {
+      const extra = config.enrich(req, url, outcome);
+      if (extra) {
+        enrichKeys.push(...Object.keys(extra));
+        Object.assign(fields, extra);
+      }
+    } catch {}
+  }
+  return { fields, enrichKeys };
+}
+
+// src/server/router.ts
+function routeSegments(path) {
+  return path.split("/").filter(Boolean);
+}
+function rawRouteShape(path) {
+  parseTrailingWildcard(path);
+  const segments = routeSegments(path).map((segment) => {
+    if (segment.startsWith(":"))
+      return { kind: "param" };
+    if (segment.startsWith("*"))
+      return { kind: "wildcard" };
+    return { kind: "static", value: segment };
+  });
+  return {
+    segments,
+    signature: segments.map((segment) => segment.kind === "static" ? segment.value : `:${segment.kind}`).join("/"),
+    wildcard: segments.at(-1)?.kind === "wildcard"
+  };
+}
+function segmentCovers(earlier, later) {
+  if (earlier.kind === "param")
+    return later.kind !== "wildcard";
+  if (earlier.kind === "wildcard")
+    return true;
+  return later.kind === "static" && earlier.value === later.value;
+}
+function routeShapeCovers(earlier, later) {
+  const earlierPrefixLength = earlier.wildcard ? earlier.segments.length - 1 : earlier.segments.length;
+  const laterPrefixLength = later.wildcard ? later.segments.length - 1 : later.segments.length;
+  if (earlier.wildcard) {
+    if (earlierPrefixLength > laterPrefixLength)
+      return false;
+  } else {
+    if (later.wildcard || earlierPrefixLength !== laterPrefixLength)
+      return false;
+  }
+  for (let index = 0;index < earlierPrefixLength; index++) {
+    const earlierSegment = earlier.segments[index];
+    const laterSegment = later.segments[index];
+    if (!earlierSegment || !laterSegment || !segmentCovers(earlierSegment, laterSegment)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchSegments(patternSegments, requestSegments) {
+  const wildcardSegment = patternSegments.at(-1);
+  const wildcardName = wildcardSegment?.startsWith("*") ? wildcardSegment.slice(1) : null;
+  const prefixLength = wildcardName ? patternSegments.length - 1 : patternSegments.length;
+  if (wildcardName) {
+    if (requestSegments.length < prefixLength)
+      return null;
+  } else if (patternSegments.length !== requestSegments.length) {
+    return null;
+  }
+  const params = {};
+  for (const [i, pattern] of patternSegments.slice(0, prefixLength).entries()) {
+    const actual = requestSegments[i];
+    if (actual === undefined)
+      return null;
+    if (pattern.startsWith(":")) {
+      const decoded = decodeSegment(actual);
+      if (decoded === null)
+        return null;
+      params[pattern.slice(1)] = decoded;
+    } else if (pattern !== actual) {
+      return null;
+    }
+  }
+  if (wildcardName) {
+    const decoded = requestSegments.slice(prefixLength).map(decodeSegment);
+    if (decoded.some((segment) => segment === null))
+      return null;
+    params[wildcardName] = decoded.join("/");
+  }
+  return params;
+}
+function decodeSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return null;
+  }
+}
+function segmentRank(segment) {
+  if (segment?.startsWith("*"))
+    return 2;
+  if (segment?.startsWith(":"))
+    return 1;
+  return 0;
+}
+function buildRouteMap(groups) {
+  const map = new Map;
+  for (const { prefix, service, hooks } of groups) {
+    for (const [, method] of Object.entries(service.methods)) {
+      if (method.expose && !method.expose.includes("HTTP"))
+        continue;
+      const servicePath = joinRoutePath("/", service.prefix, method.path === "/" ? "" : method.path);
+      const fullPath = prefix ? joinRoutePath(prefix, servicePath) : servicePath;
+      const segments = routeSegments(fullPath);
+      const entries = map.get(method.method) ?? [];
+      entries.push({ method, pattern: fullPath, segments, groupHooks: hooks });
+      map.set(method.method, entries);
+    }
+  }
+  for (const [, entries] of map) {
+    entries.sort((a, b) => {
+      const len = Math.min(a.segments.length, b.segments.length);
+      for (let i = 0;i < len; i++) {
+        const rankDifference = segmentRank(a.segments[i]) - segmentRank(b.segments[i]);
+        if (rankDifference !== 0)
+          return rankDifference;
+      }
+      return a.segments.length - b.segments.length;
+    });
+  }
+  return map;
+}
+function matchRoute(routeMap, httpMethod, pathname) {
+  const entries = routeMap.get(httpMethod);
+  if (!entries)
+    return null;
+  const requestSegments = routeSegments(pathname);
+  for (const entry of entries) {
+    const pathParams = matchSegments(entry.segments, requestSegments);
+    if (pathParams) {
+      return {
+        method: entry.method,
+        pathParams,
+        groupHooks: entry.groupHooks
+      };
+    }
+  }
+  return null;
+}
+function allowedMethods(routeMap, pathname) {
+  const requestSegments = routeSegments(pathname);
+  const methods = [];
+  for (const [method, entries] of routeMap) {
+    for (const entry of entries) {
+      if (matchSegments(entry.segments, requestSegments)) {
+        methods.push(method);
+        break;
+      }
+    }
+  }
+  return methods;
+}
+function validateRoutes(routeMap) {
+  for (const [method, entries] of routeMap) {
+    const seen = new Map;
+    for (const entry of entries) {
+      parseTrailingWildcard(entry.pattern);
+      const normalized = entry.segments.map((s) => s.startsWith(":") ? ":param" : s.startsWith("*") ? "*wildcard" : s).join("/");
+      const key = `${method} /${normalized}`;
+      const existing = seen.get(key);
+      if (existing) {
+        throw new Error(`Duplicate route: ${method} ${entry.pattern} conflicts with ${existing}`);
+      }
+      seen.set(key, entry.pattern);
+    }
+  }
+}
+function findShadowedRoutes(routeMap, rawRoutes) {
+  if (!rawRoutes || rawRoutes.length === 0)
+    return [];
+  const shadowed = [];
+  for (const [httpMethod, entries] of routeMap) {
+    for (const entry of entries) {
+      const probe = `/${entry.segments.map((segment) => {
+        if (segment.startsWith(":"))
+          return "__param__";
+        if (segment.startsWith("*"))
+          return "__wildcard__";
+        return segment;
+      }).join("/")}`;
+      const match = matchRawRoute(rawRoutes, httpMethod, probe);
+      if (!match)
+        continue;
+      shadowed.push({
+        pattern: `${httpMethod} ${entry.pattern}`,
+        endpoint: `${entry.method.serviceName}.${entry.method.key}`,
+        rawRoute: `${match.route.method} ${match.route.path}`,
+        scope: entry.method.scope
+      });
+    }
+  }
+  return shadowed;
+}
+function matchRawRoute(rawRoutes, httpMethod, pathname) {
+  for (const route of rawRoutes) {
+    if (route.method !== "ALL" && route.method !== httpMethod)
+      continue;
+    if (parseTrailingWildcard(route.path)) {
+      const routeSegs = routeSegments(route.path);
+      const pathSegs = routeSegments(pathname);
+      const params = matchSegments(routeSegs, pathSegs);
+      if (params)
+        return { route, params };
+      continue;
+    }
+    if (route.path.includes("/:")) {
+      const routeSegs = routeSegments(route.path);
+      const pathSegs = routeSegments(pathname);
+      const params = matchSegments(routeSegs, pathSegs);
+      if (params)
+        return { route, params };
+      continue;
+    }
+    if (route.path === pathname)
+      return { route, params: {} };
+  }
+  return null;
+}
+function validateRawRoutes(rawRoutes) {
+  const routes = rawRoutes ?? [];
+  for (const route of routes) {
+    if (route.serviceName !== undefined && route.serviceName.trim().length === 0) {
+      throw new Error(`Raw route ${route.method} ${route.path} has an empty serviceName`);
+    }
+    if (route.action !== undefined && route.action.trim().length === 0) {
+      throw new Error(`Raw route ${route.method} ${route.path} has an empty action`);
+    }
+    if (route.action !== undefined && route.serviceName === undefined) {
+      throw new Error(`Raw route ${route.method} ${route.path} declares action without serviceName`);
+    }
+  }
+  const shapes = routes.map((route) => rawRouteShape(route.path));
+  const conflicts = [];
+  for (const [laterIndex, later] of routes.entries()) {
+    const laterShape = shapes[laterIndex];
+    if (!laterShape)
+      continue;
+    for (let earlierIndex = 0;earlierIndex < laterIndex; earlierIndex++) {
+      const earlier = routes[earlierIndex];
+      const earlierShape = shapes[earlierIndex];
+      if (!earlier || !earlierShape)
+        continue;
+      if (earlier.method === later.method && earlier.path === later.path) {
+        conflicts.push(`${later.method} ${later.path} duplicates earlier ${earlier.method} ${earlier.path}`);
+        continue;
+      }
+      if (earlier.method === later.method && earlierShape.signature === laterShape.signature) {
+        conflicts.push(`${later.method} ${later.path} has the same parameter shape as earlier ${earlier.method} ${earlier.path}`);
+        continue;
+      }
+      const methodCovered = earlier.method === "ALL" || earlier.method === later.method;
+      if (methodCovered && routeShapeCovers(earlierShape, laterShape)) {
+        conflicts.push(`${later.method} ${later.path} is unreachable because earlier ${earlier.method} ${earlier.path} matches every request it could receive`);
+      }
+    }
+  }
+  if (conflicts.length > 0) {
+    throw new Error(`[stitchkit] conflicting raw routes:
+- ${conflicts.join(`
+- `)}`);
+  }
+}
+
+// src/server/route-table.ts
+function compileRouteTable(config, warn) {
+  for (const group of config.groups ?? []) {
+    if (group.hooks && "onRequest" in group.hooks) {
+      throw new Error("[stitchkit] a route group cannot declare `onRequest` — it runs before routing, so the group it belongs to is not known yet and the hook would never be dispatched. Refuse before dispatch with the server-level `hooks.onRequest`, or gate the group with its `authorize`, which runs once the endpoint is known.");
+    }
+  }
+  const routeMap = buildRouteMap(normalizeGroups(config));
+  validateRoutes(routeMap);
+  validateRawRoutes(config.rawRoutes);
+  for (const shadow of findShadowedRoutes(routeMap, config.rawRoutes)) {
+    const gate = shadow.scope && shadow.scope !== "public" ? ` (scope "${shadow.scope}")` : "";
+    const line = `[stitchkit] raw route ${shadow.rawRoute} shadows contract route ${shadow.pattern}` + ` → ${shadow.endpoint}${gate} will never run, and its hooks never apply`;
+    warn(line);
+  }
+  return routeMap;
+}
+function normalizeGroups(config) {
+  const result = [];
+  if (config.services) {
+    for (const service of config.services) {
+      const prefix = config.scopePrefixes?.[service.scope] ?? "";
+      result.push({ prefix, service });
+    }
+  }
+  if (config.groups) {
+    for (const group of config.groups) {
+      for (const service of group.services) {
+        result.push({ prefix: group.pathPrefix ?? "", service, hooks: group.hooks });
+      }
+    }
+  }
+  return result;
+}
+
+// src/server/handler-state.ts
+function createHandlerState(config) {
+  const { cors, hooks, logging = false, observability } = config;
+  if (cors)
+    assertCorsConfig(cors);
+  assertJsonBodyLimit(config.maxJsonBodyBytes, "HandlerConfig.maxJsonBodyBytes");
+  const logConfig = resolveLoggingConfig(logging);
+  const customLogger = logConfig?.logger ?? null;
+  const useDefaultLog = logConfig !== null && !logConfig.logger;
+  const warn = (line) => {
+    try {
+      if (customLogger)
+        customLogger.warn(line);
+      else
+        console.warn(line);
+    } catch {}
+  };
+  return {
+    config,
+    cors,
+    hooks,
+    observability,
+    logConfig,
+    customLogger,
+    useDefaultLog,
+    warnedEnrichKeys: new Set,
+    warn,
+    resolveId: createTraceIdResolver(config.traceId, warn),
+    routeMap: compileRouteTable(config, warn)
+  };
+}
+function createTraceIdResolver(customTraceId, warn) {
+  let traceResolverBroken = false;
+  return (req, fallback) => {
+    if (!customTraceId)
+      return fallback ?? resolveTraceId(req);
+    try {
+      return customTraceId(req) ?? fallback ?? resolveTraceId(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);
+    }
+  };
+}
+
+// src/server/logger.ts
+var c = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+var METHOD_COLOR = {
+  GET: c.green,
+  POST: c.yellow,
+  PUT: c.blue,
+  PATCH: c.cyan,
+  DELETE: c.red,
+  OPTIONS: c.gray
+};
+var runtimeEnv = process.env;
+function resolveLogFormat(preference) {
+  if (preference)
+    return preference;
+  return runtimeEnv.NODE_ENV === "production" ? "json" : "pretty";
+}
+function timestamp() {
+  const now = new Date;
+  const t = now.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  return `${t}.${now.getMilliseconds().toString().padStart(3, "0")}`;
+}
+function safePath(pathname) {
+  let out = "";
+  for (let i = 0;i < pathname.length; i++) {
+    const code = pathname.charCodeAt(i);
+    if (code > 31 && code !== 127)
+      out += pathname.charAt(i);
+  }
+  return out;
+}
+function levelForStatus(status) {
+  if (status === 499)
+    return "info";
+  if (status >= 500)
+    return "error";
+  if (status >= 400)
+    return "warn";
+  return "info";
+}
+function buildLogFields(method, path, status, durationMs, traceId, errorCode2) {
+  const fields = { traceId, method, path, status, durationMs };
+  if (errorCode2 === undefined && status >= 400)
+    return fields;
+  return { ...fields, errorCode: errorCode2 };
+}
+function formatMs(ms) {
+  if (ms >= 1000)
+    return `${(ms / 1000).toFixed(2)}s`;
+  if (ms >= 1)
+    return `${Math.round(ms)}ms`;
+  return `${Math.round(ms * 1000)}µs`;
+}
+function durationColor(ms) {
+  if (ms >= 1000)
+    return c.red;
+  if (ms > 300)
+    return c.yellow;
+  return c.green;
+}
+function statusColor(status) {
+  if (status >= 500)
+    return c.red;
+  if (status >= 400)
+    return c.yellow;
+  if (status >= 300)
+    return c.cyan;
+  return c.green;
+}
+function ipLabel(ip) {
+  if (!ip || ip === "::1" || ip === "127.0.0.1")
+    return `${c.magenta}local${c.reset}`;
+  return `${c.dim}${ip}${c.reset}`;
+}
+var SKIP_PREFIXES = ["/_bun/", "/_bundle", "/favicon"];
+function shouldLog(pathname, method) {
+  if (method === "OPTIONS")
+    return false;
+  return !SKIP_PREFIXES.some((prefix) => pathname.startsWith(prefix));
+}
+function logIncoming(req, pathname, traceId, format, ipAddress) {
+  const log = { traceId };
+  if (format === "pretty") {
+    const mc = METHOD_COLOR[req.method] ?? c.dim;
+    console.log(`${c.gray}[${timestamp()}]${c.reset} ${mc}${req.method}${c.reset} ${c.dim}${traceId}${c.reset} ${c.cyan}→${c.reset} ${safePath(pathname)} ${ipLabel(ipAddress ?? "")}`);
+  }
+  return log;
+}
+function structuredLine(own, extra) {
+  try {
+    return JSON.stringify({ ...extra, ...own });
+  } catch {
+    return JSON.stringify(own);
+  }
+}
+function logOutgoing(entry) {
+  const { req, pathname, status, log, ipAddress, errorCode: errorCode2, 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),
+      ip: ipAddress
+    };
+    console.log(structuredLine(own, extra));
+    return;
+  }
+  const mc = METHOD_COLOR[req.method] ?? c.dim;
+  const code = errorCode2 ? ` ${c.red}${errorCode2}${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 ?? "")}`);
+}
+
+// src/server/request-completion.ts
+var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function openRequestCompletion(state, window) {
+  const { logConfig, customLogger, useDefaultLog, observability } = state;
+  const { req, url, traceId, startedAt, ipAddress } = window;
+  const shouldLogRequest = logConfig !== null && shouldLog(url.pathname, req.method) && !shouldSkipLog(logConfig, req, url);
+  const payload = observability?.includePayload && BODY_METHODS.has(req.method) ? req.clone().json().catch(() => {
+    return;
+  }) : undefined;
+  const logFormat = resolveLogFormat(logConfig?.format);
+  let reqLog;
+  if (shouldLogRequest && useDefaultLog) {
+    reqLog = logIncoming(req, url.pathname, traceId, logFormat, ipAddress);
+  }
+  if (shouldLogRequest && customLogger) {
+    reqLog = { traceId };
+    try {
+      customLogger.debug(`${req.method} ${url.pathname}`, {
+        traceId,
+        method: req.method,
+        path: url.pathname,
+        ip: ipAddress
+      });
+    } catch {}
+  }
+  let completed = false;
+  return (status, errorCode2, outcome) => {
+    if (completed)
+      return;
+    completed = true;
+    const durationMs = Math.round(Number(process.hrtime.bigint() - startedAt) / 1e6);
+    if (reqLog && logConfig) {
+      try {
+        writeCompletionLine(state, logConfig, window, {
+          reqLog,
+          status,
+          durationMs,
+          errorCode: errorCode2,
+          logFormat
+        });
+      } catch {}
+    }
+    const context = getRequestContext();
+    if (observability && context) {
+      try {
+        observability.complete({
+          context,
+          statusCode: status,
+          durationMs,
+          payload,
+          ...outcome !== undefined && { outcome }
+        });
+      } catch {}
+    }
+  };
+}
+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 collected = collectExtraLogFields(logConfig, req, url, {
+    status,
+    durationMs,
+    errorCode: errorCode2
+  });
+  const frameworkFields = buildLogFields(req.method, url.pathname, status, durationMs, reqLog.traceId, errorCode2);
+  const ownedFields = { ...frameworkFields, ip: ipAddress };
+  for (const key of collected.enrichKeys) {
+    const ownedByActiveSink = Object.hasOwn(ownedFields, key) || useDefaultLog && (key === "ts" || key === "level" || key === "msg");
+    if (ownedByActiveSink && !warnedEnrichKeys.has(key)) {
+      warnedEnrichKeys.add(key);
+      warn(`[stitchkit] logging.enrich field "${key}" was discarded because the framework owns it`);
+    }
+  }
+  const extra = collected.fields;
+  if (useDefaultLog) {
+    logOutgoing({
+      req,
+      pathname: url.pathname,
+      status,
+      log: reqLog,
+      ipAddress,
+      errorCode: errorCode2,
+      durationMs,
+      format: logFormat,
+      extra
+    });
+  }
+  if (customLogger) {
+    const level = levelForStatus(status);
+    customLogger[level](`${req.method} ${url.pathname} ${status}${errorCode2 ? ` ${errorCode2}` : ""} ${durationMs}ms`, {
+      ...extra,
+      ...frameworkFields,
+      ip: ipAddress
+    });
+  }
+}
+
+// src/server/create.ts
+function createHandler(config) {
+  const { trustProxy = false, observability } = config;
+  const state = createHandlerState(config);
+  return async (req, server) => {
+    const url = new URL(req.url, "http://localhost");
+    const requestStartedAt = process.hrtime.bigint();
+    const clientIp = {
+      trustProxy,
+      socketIp: resolveSocketIp(req, server)
+    };
+    const run = async (traceId2, startedAt) => {
+      const response = await dispatch(state, req, url, traceId2, server, clientIp, startedAt);
+      try {
+        response.headers.set("x-request-id", traceId2);
+        const buildId = config.release?.current();
+        if (buildId)
+          response.headers.set(RELEASE_HEADER, buildId);
+      } catch {}
+      return response;
+    };
+    const activeContext = getRequestContext();
+    if (activeContext) {
+      return run(activeContext.trace.traceId, activeContext.startedAt);
+    }
+    if (!observability)
+      return run(state.resolveId(req), requestStartedAt);
+    const trace = resolveTraceContext(req);
+    const traceId = state.resolveId(req, trace.traceId);
+    const ipAddress = extractIp(req, clientIp) || undefined;
+    const userAgent = req.headers.get("user-agent") ?? undefined;
+    return runWithRequestContext({
+      source: "http",
+      method: req.method,
+      path: url.pathname,
+      startedAt: requestStartedAt,
+      trace: { ...trace, traceId },
+      ...ipAddress !== undefined && { ipAddress },
+      ...userAgent !== undefined && { userAgent }
+    }, () => run(traceId, requestStartedAt));
+  };
+}
+async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
+  const { cors, hooks, config, routeMap } = state;
+  const ipAddress = extractIp(req, clientIp) || undefined;
+  const complete = openRequestCompletion(state, { req, url, traceId, startedAt, ipAddress });
+  const respondError = createErrorResponder(state, { req, url, traceId, clientIp, complete });
+  const request = {
+    req,
+    url,
+    traceId,
+    server,
+    clientIp,
+    ipAddress,
+    complete,
+    respondError
+  };
+  if (cors && req.method === "OPTIONS") {
+    const response = corsPreflightResponse(cors, req);
+    complete(response.status);
+    return response;
+  }
+  try {
+    if (hooks?.onRequest) {
+      const earlyResponse = await hooks.onRequest(req);
+      if (earlyResponse instanceof Response) {
+        const withCors = applyCors(earlyResponse, cors, req);
+        complete(withCors.status);
+        return withCors;
+      }
+    }
+  } catch (err) {
+    return respondError(err);
+  }
+  if (config.rawRoutes) {
+    const rawMatch = matchRawRoute(config.rawRoutes, req.method, url.pathname);
+    if (rawMatch) {
+      if (rawMatch.route.serviceName !== undefined) {
+        setRequestEndpoint(rawMatch.route.serviceName, rawMatch.route.action);
+      }
+      try {
+        const res = await rawMatch.route.handler(req, {
+          params: rawMatch.params,
+          server,
+          ipAddress
+        });
+        const withCors = applyCors(res, cors, req);
+        complete(withCors.status);
+        return withCors;
+      } catch (err) {
+        return respondError(err);
+      }
+    }
+  }
+  const match = matchRoute(routeMap, req.method, url.pathname);
+  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));
+      res.headers.set("Allow", allow.join(", "));
+      return res;
+    }
+    return respondError(new AppError("NOT_FOUND", "Not found", 404));
+  }
+  return dispatchEndpoint(state, request, match);
+}
+
+// src/server/implement-registry.ts
+function createScopedImplementRegistry() {
+  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
+}
+function isImplementationContract(value) {
+  return isRecord(value) && isRecord(value.meta) && typeof value.meta.prefix === "string" && isRecord(value.endpoints);
+}
+function bindRegistry(contracts, handlers, options) {
+  const contractKeys = Object.keys(contracts);
+  const handlerKeys = Object.keys(handlers);
+  const missing = contractKeys.filter((key) => !Object.hasOwn(handlers, key));
+  const extra = handlerKeys.filter((key) => !Object.hasOwn(contracts, key));
+  if (missing.length > 0 || extra.length > 0) {
+    if (options?.onMissingHandler !== "stub") {
+      throw new Error(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"})`);
+    }
+    console.warn(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"}) — missing contracts are mounted as 501 stubs and extra handlers are ignored`);
+  }
+  const prefixes = new Map;
+  const services = [];
+  const byKey = {};
+  for (const [key, candidate] of Object.entries(contracts)) {
+    if (!isImplementationContract(candidate)) {
+      throw new TypeError(`[stitchkit] implementRegistry: registry entry "${key}" must be one contract; composed arrays and namespaces are not supported`);
+    }
+    const contract = candidate;
+    const groupScope = contract.meta.scope ?? "public";
+    const identity = `${groupScope}\x00${contract.meta.prefix}`;
+    const previousKey = prefixes.get(identity);
+    if (previousKey !== undefined) {
+      throw new Error(`[stitchkit] implementRegistry: duplicate contract prefix "${contract.meta.prefix}" in scope "${groupScope}" at "${previousKey}" and "${key}"`);
+    }
+    prefixes.set(identity, key);
+    const entryHandlers = handlers[key] === undefined && options?.onMissingHandler === "stub" ? {} : handlers[key];
+    if (!isRecord(entryHandlers)) {
+      throw new TypeError(`[stitchkit] implementRegistry: handlers for "${key}" must be an object`);
+    }
+    const endpointKeys = Object.keys(contract.endpoints);
+    const handlerEntryKeys = Object.keys(entryHandlers);
+    const missingEndpoints = endpointKeys.filter((endpointKey) => !Object.hasOwn(entryHandlers, endpointKey));
+    const extraEndpoints = handlerEntryKeys.filter((endpointKey) => !Object.hasOwn(contract.endpoints, endpointKey));
+    if (missingEndpoints.length > 0 || extraEndpoints.length > 0) {
+      const detail = `handlers for "${key}" mismatch (missing: ${missingEndpoints.join(", ") || "none"}; extra: ${extraEndpoints.join(", ") || "none"})`;
+      if (options?.onMissingHandler !== "stub") {
+        throw new Error(`[stitchkit] implementRegistry: ${detail}`);
+      }
+      console.warn(`[stitchkit] implementRegistry: ${detail} — missing endpoints are mounted as 501 stubs and extra handlers are ignored`);
+    }
+    const service = bindContract(contract, entryHandlers, options);
+    services.push(service);
+    byKey[key] = service;
+  }
+  Object.defineProperty(services, "byKey", { value: byKey, enumerable: false });
+  return transportResult(services);
+}
+function implementRegistry(contracts, handlers, options) {
+  return transportResult(bindRegistry(contracts, handlers, options));
+}
+function createImplementRegistry() {
+  return (contracts, handlers, options) => transportResult(bindRegistry(contracts, handlers, options));
+}
+
+// src/server/process-signals.ts
+var bound = new WeakSet;
+function bindProcessSignals(handle, options = {}) {
+  if (bound.has(handle)) {
+    throw new Error("[stitchkit] bindProcessSignals: this server is already bound; close the first binding before creating another");
+  }
+  bound.add(handle);
+  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 budgets = {
+    ...requested.gracePeriodMs !== undefined && { gracePeriodMs: validated.gracePeriodMs },
+    ...requested.forceTimeoutMs !== undefined && {
+      forceTimeoutMs: validated.forceTimeoutMs
+    },
+    ...requested.realtimeCloseTimeoutMs !== undefined && {
+      realtimeCloseTimeoutMs: validated.realtimeCloseTimeoutMs
+    },
+    ...requested.retryAfterSeconds !== undefined && {
+      retryAfterSeconds: validated.retryAfterSeconds
+    }
+  };
+  const controller = new AbortController;
+  const handlers = [];
+  let started = false;
+  let sameTurnAsStart = false;
+  let settled = false;
+  let closed = false;
+  let resolveChain = () => {
+    return;
+  };
+  let rejectChain = () => {
+    return;
+  };
+  const promise = new Promise((resolve, reject) => {
+    resolveChain = resolve;
+    rejectChain = reject;
+  });
+  promise.catch(() => {
+    return;
+  });
+  const removeListeners = () => {
+    if (closed)
+      return;
+    closed = true;
+    for (const [signal, handler] of handlers)
+      source.off(signal, handler);
+    if (!started)
+      bound.delete(handle);
+  };
+  const close = () => {
+    const hadStarted = started;
+    removeListeners();
+    if (!hadStarted)
+      resolveChain(undefined);
+  };
+  const run = async (signal) => {
+    try {
+      await options.onShutdown?.(signal);
+    } catch (error) {
+      reportSignalError("prepare", error, options.onError);
+    }
+    let result;
+    try {
+      result = await handle.shutdown({ ...budgets, signal: controller.signal });
+    } catch (error) {
+      settled = true;
+      rejectChain(error);
+      reportSignalError("shutdown", error, options.onError);
+      removeListeners();
+      return;
+    }
+    settled = true;
+    resolveChain(result);
+    try {
+      await options.onComplete?.(result);
+    } catch (error) {
+      reportSignalError("complete", error, options.onError);
+    } finally {
+      removeListeners();
+    }
+  };
+  const onSignal = (signal) => {
+    if (!started) {
+      started = true;
+      sameTurnAsStart = true;
+      queueMicrotask(() => {
+        sameTurnAsStart = false;
+      });
+      run(signal).catch((error) => reportSignalError("shutdown", error, options.onError));
+      return;
+    }
+    if (sameTurnAsStart)
+      return;
+    if (!settled && !controller.signal.aborted) {
+      controller.abort();
+      guardSignalCallback(() => options.onRepeatedSignal?.(signal, "force"), "shutdown", options.onError);
+      return;
+    }
+    removeListeners();
+    guardSignalCallback(() => options.onRepeatedSignal?.(signal, "escalate"), "shutdown", options.onError);
+    let restored = false;
+    try {
+      restored = source.raiseDefault(signal);
+    } catch (error) {
+      reportSignalError("shutdown", error, options.onError);
+    }
+    if (!restored) {
+      guardSignalCallback(() => options.onEscalationBlocked?.(signal), "shutdown", options.onError);
+    }
+  };
+  for (const signal of signals) {
+    const handler = () => onSignal(signal);
+    handlers.push([signal, handler]);
+    source.on(signal, handler);
+  }
+  return { promise, close };
+}
+
+// src/server/realtime.ts
+function bindRealtimeServer(contract, handle, options = {}) {
+  const outbound = (target) => createValidatedRealtimeSocket({
+    target,
+    inbound: {},
+    outbound: contract.serverToClient,
+    inboundDirection: "server-inbound",
+    outboundDirection: "server-outbound",
+    onRejected: options.onRejected,
+    logger: options.logger
+  });
+  const broadcast = outbound(handle.io);
+  return {
+    onConnection: (handler) => {
+      const listener = (raw) => {
+        const events = createValidatedRealtimeSocket({
+          target: raw,
+          inbound: contract.clientToServer,
+          outbound: contract.serverToClient,
+          inboundDirection: "server-inbound",
+          outboundDirection: "server-outbound",
+          onRejected: options.onRejected,
+          logger: options.logger
+        });
+        handler({
+          raw,
+          events,
+          to: (room) => outbound(raw.to(room))
+        });
+      };
+      handle.io.on("connection", listener);
+      return () => {
+        handle.io.off("connection", listener);
+      };
+    },
+    emit: broadcast.emit,
+    to: (room) => outbound(handle.io.to(room))
+  };
+}
+
+// src/server/websocket.ts
+function webSocketLane(lane) {
+  const { match, handlers } = lane;
+  return {
+    match,
+    handlers: {
+      message(ws, message) {
+        if (match(ws))
+          handlers.message(ws, message);
+      },
+      open(ws) {
+        if (match(ws))
+          handlers.open?.(ws);
+      },
+      close(ws, code, reason) {
+        if (match(ws))
+          handlers.close?.(ws, code, reason);
+      },
+      drain(ws) {
+        if (match(ws))
+          handlers.drain?.(ws);
+      },
+      ping(ws, data) {
+        if (match(ws))
+          handlers.ping?.(ws, data);
+      },
+      pong(ws, data) {
+        if (match(ws))
+          handlers.pong?.(ws, data);
+      }
+    }
+  };
+}
+function composeWebSocketHandlers(lanes, config) {
+  const pick = (ws) => lanes.find((lane) => lane.match(ws));
+  return {
+    ...config,
+    message(ws, message) {
+      pick(ws)?.handlers.message(ws, message);
+    },
+    open(ws) {
+      pick(ws)?.handlers.open?.(ws);
+    },
+    close(ws, code, reason) {
+      pick(ws)?.handlers.close?.(ws, code, reason);
+    },
+    drain(ws) {
+      pick(ws)?.handlers.drain?.(ws);
+    },
+    ping(ws, data) {
+      pick(ws)?.handlers.ping?.(ws, data);
+    },
+    pong(ws, data) {
+      pick(ws)?.handlers.pong?.(ws, data);
+    }
+  };
+}
+
+// src/server/socket-io.ts
+var SOCKET_IO_SERVER = "socket.io";
+var SOCKET_IO_BUN_ENGINE = "@socket.io/bun-engine";
+var noop = () => {};
+async function importPeer(load, pkg, injected) {
+  try {
+    return await load();
+  } catch (err) {
+    if (isModuleNotFound(err)) {
+      throw new Error(injected ? `[stitchkit] createSocketIOServer could not load the optional peer "${pkg}" through the loader passed in \`peers\` — the artifact does not contain it. Check that the loader is a literal \`import('${pkg}')\` your bundler can follow, and that "${pkg}" is a dependency of the package being bundled.` : `[stitchkit] createSocketIOServer needs the optional peer "${pkg}" — install it: bun add ${pkg}. Shipping one self-contained artifact instead? Pass \`peers: { … }\` so your bundler puts it inside.`, { cause: err });
+    }
+    throw err;
+  }
+}
+function isBunEngineModule(value) {
+  return typeof value === "object" && value !== null && typeof Reflect.get(value, "Server") === "function";
+}
+function handshakeRejection(message) {
+  const error = new Error(message);
+  error.data = { code: "handshake_rejected" };
+  return error;
+}
+function handshakeMiddleware(handshake) {
+  return (socket, next) => {
+    let parsed;
+    try {
+      parsed = handshake.schema.safeParse(socket.handshake.auth);
+    } catch (error) {
+      console.error("[stitchkit] handshake schema threw — use a synchronous schema", error);
+      next(handshakeRejection("handshake auth failed validation"));
+      return;
+    }
+    if (!parsed.success) {
+      next(handshakeRejection("handshake auth failed validation"));
+      return;
+    }
+    const verify = handshake.verify;
+    Promise.resolve().then(() => {
+      if (verify)
+        return verify(parsed.data, { handshake: socket.handshake });
+      return transportResult(parsed.data);
+    }).then((identity) => {
+      if (identity === null || identity === undefined) {
+        next(handshakeRejection("handshake rejected"));
+        return;
+      }
+      socket.data = identity;
+      next();
+    }, (error) => {
+      console.error("[stitchkit] handshake verify rejected", error);
+      next(handshakeRejection("handshake rejected"));
+    });
+  };
+}
+async function createSocketIOServer(config) {
+  const path = config.path ?? "/socket.io/";
+  const onBun = "Bun" in globalThis;
+  const transports = config.transports ?? (onBun ? ["websocket", "polling"] : ["websocket"]);
+  const pingTimeout = config.pingTimeout ?? 20000;
+  const pingInterval = config.pingInterval ?? 1e4;
+  const cors = config.cors ? {
+    origin: config.cors.origin,
+    credentials: config.cors.credentials ?? true,
+    methods: ["GET", "POST"]
+  } : undefined;
+  let accepting = true;
+  let attached = false;
+  let closePromise;
+  const consumerAllowRequest = config.allowRequest;
+  const checkRequest = async (request) => {
+    if (onBun) {
+      const requested = new URL(request.url).searchParams.get("transport");
+      if (!transports.some((transport) => transport === requested)) {
+        throw new Error("Transport rejected by the configured Socket.IO policy");
+      }
+    }
+    if (consumerAllowRequest && !await consumerAllowRequest(request)) {
+      throw new Error("Request rejected by the configured Socket.IO policy");
+    }
+    if (!accepting)
+      throw new Error("Server is shutting down");
+  };
+  const allowRequest = (request, done) => {
+    const headers = new Headers;
+    for (const [name, value] of Object.entries(request.headers)) {
+      if (Array.isArray(value)) {
+        for (const item of value)
+          headers.append(name, item);
+      } else if (value !== undefined) {
+        headers.set(name, value);
+      }
+    }
+    const host = headers.get("host") ?? "localhost";
+    const webRequest = new Request(new URL(request.url ?? "/", `http://${host}`), {
+      method: request.method,
+      headers
+    });
+    checkRequest(webRequest).then(() => done(null, true), (error) => done(error instanceof Error ? error.message : "Request rejected", false));
+  };
+  const injectedServer = config.peers?.server;
+  const { Server } = await importPeer(injectedServer ?? (() => import(SOCKET_IO_SERVER).then((module) => module)), SOCKET_IO_SERVER, injectedServer !== undefined);
+  const io = new Server({
+    ...config.serverOptions,
+    path,
+    cors,
+    transports,
+    pingTimeout,
+    pingInterval,
+    allowRequest
+  });
+  if (config.handshake)
+    io.use(handshakeMiddleware(config.handshake));
+  const lifecycle = {
+    beginShutdown() {
+      accepting = false;
+    },
+    close() {
+      if (closePromise)
+        return closePromise;
+      closePromise = onBun || attached ? io.close() : Promise.resolve();
+      return closePromise;
+    },
+    connections() {
+      return io.engine?.clientsCount ?? 0;
+    }
+  };
+  if (onBun) {
+    const injectedEngine = config.peers?.bunEngine;
+    const engineModule = await importPeer(injectedEngine ?? (() => import(SOCKET_IO_BUN_ENGINE).then((module) => module)), SOCKET_IO_BUN_ENGINE, injectedEngine !== undefined);
+    if (!isBunEngineModule(engineModule)) {
+      throw new Error(`[stitchkit] the loader passed in \`peers.bunEngine\` did not return the "${SOCKET_IO_BUN_ENGINE}" module — it must resolve to the module itself, as \`() => import('${SOCKET_IO_BUN_ENGINE}')\`.`);
+    }
+    const { Server: Engine } = engineModule;
+    const engineOpts = {
+      path,
+      cors,
+      pingTimeout,
+      pingInterval,
+      allowRequest: checkRequest
+    };
+    if (config.serverOptions?.maxHttpBufferSize !== undefined) {
+      engineOpts.maxHttpBufferSize = config.serverOptions.maxHttpBufferSize;
+    }
+    if (config.serverOptions?.upgradeTimeout !== undefined) {
+      engineOpts.upgradeTimeout = config.serverOptions.upgradeTimeout;
+    }
+    const engine = new Engine(engineOpts);
+    io.bind(engine);
+    const { websocket } = engine.handler();
+    const route = {
+      method: "ALL",
+      path: `${path.replace(/\/+$/, "")}/*socketPath`,
+      handler: (req, ctx) => {
+        if (!ctx.server) {
+          throw new Error("[stitchkit] createSocketIOServer route needs a running Bun server — mount it via createServer.");
+        }
+        return engine.handleRequest(req, ctx.server);
+      }
+    };
+    return { io, websocket, route, attach: noop, ...lifecycle };
+  }
+  return {
+    io,
+    attach: (server) => {
+      io.attach(server);
+      attached = true;
+    },
+    websocket: { open: noop, message: noop, close: noop, maxPayloadLength: 0 },
+    route: {
+      method: "ALL",
+      path: `${path.replace(/\/+$/, "")}/*socketPath`,
+      handler: () => {
+        throw new Error("[stitchkit] On Node, Socket.IO attaches via serveNode({ socket }) — this route is not mounted.");
+      }
+    },
+    ...lifecycle
+  };
+}
+function socketIoLane(websocket) {
+  return webSocketLane({
+    match: (_ws) => true,
+    handlers: websocket
+  });
+}
+
+// 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 incomingResponseBody(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;
+        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"));
+          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-http1.ts
+var MAX_BODY_CHUNK_BYTES = 64 * 1024;
+var MAX_CHUNK_HEADER_BYTES = 1024;
+var CRLF2 = [13, 10];
+var CRLFCRLF = [13, 10, 13, 10];
+function concatBytes2(left, right) {
+  if (left.byteLength === 0)
+    return right.slice();
+  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;
+}
+
+class WireBuffer {
+  bytes = new Uint8Array;
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  append(data) {
+    this.bytes = concatBytes2(this.bytes, data);
+  }
+  take(count) {
+    const value = this.bytes.slice(0, count);
+    this.bytes = this.bytes.slice(count);
+    return value;
+  }
+  indexOf(sequence) {
+    return indexOfSequence(this.bytes, sequence);
+  }
+  startsWith(sequence) {
+    return sequence.every((byte, index) => this.bytes[index] === byte);
+  }
+}
+function requestBytes(request, body) {
+  const url = new URL(request.url);
+  const headers = new Headers(request.headers);
+  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 readResponseHead(wire, maxHeaderBytes) {
+  const headerEnd = wire.indexOf(CRLFCRLF);
+  if (headerEnd < 0) {
+    return wire.byteLength > maxHeaderBytes ? { kind: "too-large" } : { kind: "more" };
+  }
+  if (headerEnd + 4 > maxHeaderBytes)
+    return { kind: "too-large" };
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(wire.take(headerEnd));
+  } catch (error) {
+    return { kind: "malformed", error };
+  }
+  wire.take(4);
+  const lines = text.split(`\r
+`);
+  const statusLine = lines.shift() ?? "";
+  const matched = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
+  if (!matched) {
+    return {
+      kind: "malformed",
+      error: new Error("Unix response has an invalid HTTP status line")
+    };
+  }
+  const headers = new Headers;
+  let contentLength;
+  try {
+    for (const line of lines) {
+      const separator = line.indexOf(":");
+      if (separator <= 0)
+        throw new Error("Unix response has an invalid header line");
+      headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
+    }
+    contentLength = parseContentLength(headers);
+  } catch (error) {
+    return { kind: "malformed", error };
+  }
+  return {
+    kind: "head",
+    status: Number(matched[1]),
+    statusText: matched[2] ?? "",
+    headers,
+    contentLength,
+    chunked: headers.get("transfer-encoding")?.toLowerCase().includes("chunked") ?? false
+  };
+}
+var malformed = (message) => ({
+  kind: "malformed",
+  error: new Error(message)
+});
+
+class BodyDecoder {
+  chunked;
+  remainingLength;
+  maxHeaderBytes;
+  chunkRemaining;
+  expectChunkCrlf = false;
+  trailers = false;
+  constructor(chunked, remainingLength, maxHeaderBytes) {
+    this.chunked = chunked;
+    this.remainingLength = remainingLength;
+    this.maxHeaderBytes = maxHeaderBytes;
+  }
+  next(wire, peerEnded) {
+    return this.chunked ? this.nextChunked(wire, peerEnded) : this.nextPlain(wire, peerEnded);
+  }
+  nextPlain(wire, peerEnded) {
+    if (wire.byteLength > 0) {
+      const permitted = this.remainingLength ?? wire.byteLength;
+      const bytes = Math.min(permitted, wire.byteLength, MAX_BODY_CHUNK_BYTES);
+      if (this.remainingLength !== undefined)
+        this.remainingLength -= bytes;
+      return { kind: "data", value: wire.take(bytes) };
+    }
+    if (this.remainingLength === 0)
+      return { kind: "complete" };
+    if (!peerEnded)
+      return { kind: "more" };
+    return this.remainingLength !== undefined && this.remainingLength > 0 ? malformed("Unix response ended before Content-Length bytes arrived") : { kind: "complete" };
+  }
+  get plainComplete() {
+    return !this.chunked && this.remainingLength === 0;
+  }
+  nextChunked(wire, peerEnded) {
+    for (;; ) {
+      if (this.trailers)
+        return this.readTrailers(wire, peerEnded);
+      if (this.expectChunkCrlf) {
+        if (wire.byteLength < 2) {
+          return peerEnded ? malformed("Unix chunked response ended before chunk delimiter") : { kind: "more" };
+        }
+        if (!wire.startsWith(CRLF2)) {
+          return malformed("Unix chunked response has an invalid chunk delimiter");
+        }
+        wire.take(2);
+        this.expectChunkCrlf = false;
+      }
+      if (this.chunkRemaining === undefined) {
+        const header = this.readChunkHeader(wire, peerEnded);
+        if (header !== undefined)
+          return header;
+        if (this.trailers)
+          continue;
+      }
+      const remaining = this.chunkRemaining ?? 0;
+      if (wire.byteLength === 0) {
+        return peerEnded ? malformed("Unix chunked response ended inside a chunk") : { kind: "more" };
+      }
+      const bytes = Math.min(remaining, wire.byteLength, MAX_BODY_CHUNK_BYTES);
+      const value = wire.take(bytes);
+      this.chunkRemaining = remaining - bytes;
+      if (this.chunkRemaining === 0) {
+        this.chunkRemaining = undefined;
+        this.expectChunkCrlf = true;
+      }
+      return { kind: "data", value };
+    }
+  }
+  readChunkHeader(wire, peerEnded) {
+    const lineEnd = wire.indexOf(CRLF2);
+    if (lineEnd < 0) {
+      if (wire.byteLength > MAX_CHUNK_HEADER_BYTES)
+        return malformed("Unix chunk header is too large");
+      return peerEnded ? malformed("Unix chunked response ended inside chunk header") : { kind: "more" };
+    }
+    const line = new TextDecoder("ascii", { fatal: true }).decode(wire.take(lineEnd));
+    wire.take(2);
+    const sizeText = line.split(";", 1)[0]?.trim() ?? "";
+    if (!/^[0-9a-f]+$/i.test(sizeText)) {
+      return malformed("Unix chunked response has an invalid chunk size");
+    }
+    const size = Number.parseInt(sizeText, 16);
+    if (!Number.isSafeInteger(size))
+      return malformed("Unix chunk size is not a safe integer");
+    if (size === 0)
+      this.trailers = true;
+    else
+      this.chunkRemaining = size;
+    return;
+  }
+  readTrailers(wire, peerEnded) {
+    if (wire.byteLength >= 2 && wire.startsWith(CRLF2)) {
+      wire.take(2);
+      return { kind: "complete" };
+    }
+    const trailerEnd = wire.indexOf(CRLFCRLF);
+    if (trailerEnd < 0) {
+      if (wire.byteLength > this.maxHeaderBytes)
+        return { kind: "trailers-too-large" };
+      return peerEnded ? malformed("Unix chunked response ended inside trailers") : { kind: "more" };
+    }
+    wire.take(trailerEnd + 4);
+    return { kind: "complete" };
+  }
+}
+
+// src/server/unix-client-bun.ts
+function isBunUnixRuntime(candidate) {
+  if (typeof candidate !== "object" || candidate === null)
+    return false;
+  return typeof Reflect.get(candidate, "connect") === "function";
+}
+function runtimeBun() {
+  const candidate = Reflect.get(globalThis, "Bun");
+  return isBunUnixRuntime(candidate) ? candidate : undefined;
+}
+function hasBunUnixRuntime() {
+  return runtimeBun() !== undefined;
+}
+function classifyTransportFailure(error, headersReceived, dispatched) {
+  if (error instanceof UnixClientTransportError)
+    return error;
+  if (headersReceived) {
+    return new UnixClientTransportError("UNIX_RESPONSE_ABORTED", "Unix response failed before completion", "response-received", { cause: error });
+  }
+  return new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error });
+}
+function limitError(limit, what, bytes) {
+  return limit === "body" ? new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${bytes} byte limit`, "response-received") : new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response ${what} exceed the ${bytes} byte limit`, "response-received");
+}
+function socketHandlers(events) {
+  return {
+    binaryType: "uint8array",
+    open: events.open,
+    drain: events.flush,
+    data(active, data) {
+      active.pause();
+      events.data(data);
+    },
+    end: () => events.ended(undefined, "ended"),
+    close: (_active, error) => events.ended(error, "closed"),
+    error: (_active, error) => events.failed(error),
+    connectError: (_active, error) => events.failed(error)
+  };
+}
+function writeAvailable(active, bytes, offset) {
+  let written = offset;
+  while (written < bytes.byteLength) {
+    const count = active.write(bytes, written, bytes.byteLength - written);
+    if (count < 0)
+      return "closed";
+    if (count === 0)
+      break;
+    written += count;
+  }
+  return written;
+}
+function bunUnixRequest(options) {
+  const outgoing = requestBytes(options.request, options.body);
+  const bun = runtimeBun();
+  if (!bun)
+    throw new Error("Bun Unix runtime is unavailable");
+  let socket;
+  let controller;
+  const wire = new WireBuffer;
+  let decoder2;
+  let responseResolved = false;
+  let headersReceived = false;
+  let settled = false;
+  let bodyComplete = false;
+  let peerEnded = false;
+  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) => classifyTransportFailure(error, headersReceived, writeOffset > 0);
+  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 enqueue = (value) => {
+    if (options.maxResponseBytes !== undefined)
+      received += value.byteLength;
+    if (options.maxResponseBytes !== undefined && received > options.maxResponseBytes) {
+      fail(limitError("body", "body", options.maxResponseBytes));
+      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 headersTooLarge = (what) => limitError("headers", what, options.maxHeaderBytes);
+  const pump = () => {
+    while (controller && decoder2 && !settled && !bodyComplete) {
+      if ((controller.desiredSize ?? 1) <= 0)
+        return;
+      const step = decoder2.next(wire, peerEnded);
+      if (step.kind === "data") {
+        enqueue(step.value);
+        if (!settled && decoder2.plainComplete)
+          completeBody();
+      } else if (step.kind === "more")
+        resumeForData();
+      else if (step.kind === "complete")
+        completeBody();
+      else if (step.kind === "malformed")
+        fail(transportFailure(step.error));
+      else
+        fail(headersTooLarge("trailers"));
+      return;
+    }
+  };
+  const parseHeaders = () => {
+    const head = readResponseHead(wire, options.maxHeaderBytes);
+    if (head.kind !== "head") {
+      if (head.kind === "malformed")
+        headersReceived = true;
+      if (head.kind === "more")
+        socket?.resume();
+      else if (head.kind === "too-large")
+        fail(headersTooLarge("headers"));
+      else
+        fail(transportFailure(head.error));
+      return;
+    }
+    headersReceived = true;
+    const { status, statusText, headers, contentLength } = head;
+    if (options.maxResponseBytes !== undefined && contentLength !== undefined && contentLength > options.maxResponseBytes) {
+      fail(limitError("body", "body", options.maxResponseBytes));
+      return;
+    }
+    decoder2 = new BodyDecoder(head.chunked, contentLength, options.maxHeaderBytes);
+    const bodyless = options.request.method === "HEAD" || status === 204 || status === 205 || status === 304;
+    clearTimeout(timer);
+    responseResolved = true;
+    if (bodyless || contentLength === 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) => {
+    const next = writeAvailable(active, outgoing, writeOffset);
+    if (next === "closed") {
+      fail(transportFailure(new Error("Unix request socket closed while writing")));
+    } else
+      writeOffset = next;
+  };
+  if (options.request.signal.aborted) {
+    fail(options.request.signal.reason ?? new DOMException("Request aborted", "AbortError"));
+    return response;
+  }
+  options.request.signal.addEventListener("abort", abortRequest, { once: true });
+  bun.connect({
+    unix: options.socketPath,
+    socket: socketHandlers({
+      open(active) {
+        socket = active;
+        if (settled)
+          active.terminate();
+        else
+          flushRequest(active);
+      },
+      flush: flushRequest,
+      data(data) {
+        wire.append(data);
+        if (!responseResolved)
+          parseHeaders();
+        else
+          pump();
+      },
+      ended(error, how) {
+        peerEnded = true;
+        if (settled)
+          return;
+        if (error)
+          fail(transportFailure(error));
+        else if (!responseResolved) {
+          fail(transportFailure(new Error(`Unix connection ${how} before response headers`)));
+        } else
+          pump();
+      },
+      failed: (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 isNodeHeaderOverflow(error) {
+  return typeof error === "object" && error !== null && Reflect.get(error, "code") === "HPE_HEADER_OVERFLOW";
+}
+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 resolveUnixClientLimits(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");
+  if (config.responseBodyMode === "streaming" && config.maxResponseBytes !== undefined) {
+    throw new TypeError("maxResponseBytes cannot be combined with responseBodyMode streaming");
+  }
+  const maxResponseBytes = config.responseBodyMode === "streaming" ? undefined : 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");
+  return {
+    maxRequestBytes,
+    maxResponseBytes,
+    headersTimeoutMs,
+    maxConnections,
+    maxHeaderBytes,
+    maxRedirects
+  };
+}
+function redirectStep(request, status, location, redirectCount, maxRedirects) {
+  if (!location || !isRedirect(status))
+    return "return";
+  if (request.redirect === "error" || redirectCount >= maxRedirects) {
+    throw new UnixClientTransportError("UNIX_REDIRECT_REFUSED", redirectCount >= maxRedirects ? `Unix redirect limit ${maxRedirects} exceeded` : "Unix request redirect mode is error", "response-received");
+  }
+  return request.redirect === "follow" ? "follow" : "return";
+}
+function nodeUnixRequest(input) {
+  const { request, url, headersTimeoutMs, maxHeaderBytes, activeRequests } = input;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const resolveOnce = (response) => {
+      if (settled)
+        return;
+      settled = true;
+      resolve(response);
+    };
+    const rejectOnce = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      reject(error);
+    };
+    const outgoing = httpRequest({
+      socketPath: input.socketPath,
+      path: `${url.pathname}${url.search}`,
+      method: request.method,
+      headers: input.headers,
+      agent: input.agent,
+      signal: request.signal,
+      maxHeaderSize: maxHeaderBytes
+    }, resolveOnce);
+    let connected = false;
+    let requestStartBytes = 0;
+    outgoing.once("socket", (socket) => {
+      requestStartBytes = socket.bytesWritten;
+      if (!socket.connecting && !socket.destroyed)
+        connected = true;
+      else {
+        socket.once("connect", () => {
+          connected = true;
+        });
+      }
+    });
+    activeRequests.add(outgoing);
+    const timer = setTimeout(() => {
+      const error = new UnixClientTransportError("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${headersTimeoutMs}ms`);
+      rejectOnce(error);
+      outgoing.destroy(error);
+    }, headersTimeoutMs);
+    timer.unref();
+    outgoing.once("response", () => clearTimeout(timer));
+    outgoing.once("error", (error) => {
+      if (isNodeHeaderOverflow(error)) {
+        rejectOnce(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${maxHeaderBytes} byte limit`, "response-received", { cause: error }));
+        return;
+      }
+      const dispatched = connected && (outgoing.socket?.bytesWritten ?? requestStartBytes) > requestStartBytes;
+      rejectOnce(new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error }));
+    });
+    outgoing.once("close", () => {
+      clearTimeout(timer);
+      activeRequests.delete(outgoing);
+    });
+    outgoing.end(input.body);
+  });
+}
+function createUnixClientTransport(config) {
+  const {
+    maxRequestBytes,
+    maxResponseBytes,
+    headersTimeoutMs,
+    maxConnections,
+    maxHeaderBytes,
+    maxRedirects
+  } = resolveUnixClientLimits(config);
+  const agent = new Agent({ keepAlive: true, maxSockets: maxConnections });
+  const activeRequests = new Set;
+  const activeResponses = new Set;
+  const bunAborters = new Set;
+  let closed = false;
+  const dispatch2 = 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");
+      let step2;
+      try {
+        step2 = redirectStep(request, response.status, location2, redirectCount, maxRedirects);
+      } catch (error) {
+        await response.body?.cancel();
+        throw error;
+      }
+      if (step2 === "follow" && location2) {
+        await response.body?.cancel();
+        return dispatch2(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
+      }
+      return response;
+    }
+    const headers = Object.fromEntries(request.headers.entries());
+    if (!Object.keys(headers).some((name) => name.toLowerCase() === "host")) {
+      headers.host = url.host;
+    }
+    const incoming = await nodeUnixRequest({
+      socketPath: config.socketPath,
+      url,
+      request,
+      headers,
+      body,
+      agent,
+      maxHeaderBytes,
+      headersTimeoutMs,
+      activeRequests
+    });
+    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) && 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");
+    }
+    const location = responseHeadersValue.get("location");
+    let step;
+    try {
+      step = redirectStep(request, status, location, redirectCount, maxRedirects);
+    } catch (error) {
+      incoming.destroy();
+      releaseResponse();
+      throw error;
+    }
+    if (step === "follow" && location) {
+      incoming.destroy();
+      releaseResponse();
+      return dispatch2(redirectedRequest(request, location, status, body), redirectCount + 1);
+    }
+    const bodyless = request.method === "HEAD" || status === 204 || status === 205 || status === 304;
+    if (bodyless) {
+      incoming.resume();
+      incoming.once("end", releaseResponse);
+      return new Response(null, {
+        status,
+        statusText: incoming.statusMessage,
+        headers: responseHeadersValue
+      });
+    }
+    return new Response(incomingResponseBody(incoming, maxResponseBytes, releaseResponse), {
+      status,
+      statusText: incoming.statusMessage,
+      headers: responseHeadersValue
+    });
+  };
+  return {
+    fetch(input, init) {
+      return dispatch2(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 { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart, DEFAULT_STREAM_HEARTBEAT_MS, streamingRoute, ndjsonRoute, sseRoute, createHandler, createScopedImplementRegistry, implementRegistry, createImplementRegistry, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane, UnixClientTransportError, createUnixClientTransport };