stitchkit 0.93.0 → 0.94.1

package/dist/index-n0f51dfn.js

@@ -1,3170 +0,0 @@
-import {
-  RELEASE_HEADER
-} from "./index-y91ry9h2.js";
-import {
-  ShutdownOptionsSchema,
-  isStreamCancellation,
-  ownHttpStream,
-  settleStreamCleanup
-} from "./index-3z73fh2c.js";
-import {
-  createValidatedRealtimeSocket,
-  isModuleNotFound
-} from "./index-f477k430.js";
-import {
-  DEFAULT_PROCESS_SIGNALS,
-  RUNTIME_CONTEXT_RESERVED_KEYS,
-  assertCorsConfig,
-  corsHeaders,
-  corsPreflightResponse,
-  defaultSignalSource,
-  guardSignalCallback,
-  isOriginAllowed,
-  mediaTypeEssence,
-  reportSignalError
-} from "./index-cxqhvq21.js";
-import {
-  getRequestContext,
-  runWithRequestContext,
-  setRequestEndpoint,
-  setRequestError
-} from "./index-tmwcrptx.js";
-import {
-  extractIp,
-  getClientInfo,
-  parseQueryParams,
-  resolveSocketIp,
-  resolveTraceId
-} from "./index-f9mb610r.js";
-import {
-  errorCode,
-  normalizeError,
-  recordedErrorMessage,
-  validateDeclaredOutput
-} from "./index-e0znv5gn.js";
-import {
-  DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
-  joinRoutePath,
-  parseTrailingWildcard
-} from "./index-0a349c33.js";
-import {
-  resolveTraceContext
-} from "./index-zcgf3gqf.js";
-import {
-  AppError,
-  badRequest,
-  forbidden
-} from "./index-2vtcmrj9.js";
-import {
-  isUnsafeKey,
-  safeJsonParse
-} from "./index-kzfs85xp.js";
-import {
-  isRecord,
-  transportResult
-} from "./index-77fekveh.js";
-
-// src/server/multipart.ts
-var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
-var DEFAULT_MAX_FIELD_BYTES = 1024 * 1024;
-var DEFAULT_MAX_HEADER_BYTES = 64 * 1024;
-var DEFAULT_MAX_PARTS = 1000;
-var CRLF = new Uint8Array([13, 10]);
-var HEADER_END = new Uint8Array([13, 10, 13, 10]);
-var decoder = new TextDecoder;
-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);
-  }
-}
-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-route.ts
-var DEFAULT_STREAM_HEARTBEAT_MS = 5000;
-var FRAMINGS = {
-  ndjson: {
-    contentType: "application/x-ndjson",
-    keepAlive: `
-`,
-    frame: (value) => `${JSON.stringify(value)}
-`
-  },
-  sse: {
-    contentType: "text/event-stream",
-    keepAlive: `: keep-alive
-
-`,
-    frame: (value) => `data: ${JSON.stringify(value)}
-
-`,
-    done: `data: [DONE]
-
-`
-  }
-};
-function applyIdleTimeout(server, request, seconds) {
-  if (typeof server !== "object" || server === null)
-    return;
-  const timeout = Reflect.get(server, "timeout");
-  if (typeof timeout !== "function")
-    return;
-  try {
-    Reflect.apply(timeout, server, [request, seconds]);
-  } catch {}
-}
-function unrefTimer(timer) {
-  if (typeof timer !== "object" || timer === null)
-    return;
-  const unref = Reflect.get(timer, "unref");
-  if (typeof unref === "function")
-    Reflect.apply(unref, timer, []);
-}
-var MAX_BUFFERED_FRAMES = 16;
-function responseHeaders(framing, extra) {
-  const headers = new Headers(extra);
-  headers.set("Content-Type", framing.contentType);
-  headers.set("Cache-Control", "no-cache");
-  headers.set("Connection", "keep-alive");
-  headers.set("X-Accel-Buffering", "no");
-  return headers;
-}
-function streamingRoute(options) {
-  const heartbeatMs = options.heartbeatMs ?? DEFAULT_STREAM_HEARTBEAT_MS;
-  if (!Number.isFinite(heartbeatMs) || heartbeatMs <= 0) {
-    throw new TypeError("heartbeatMs must be a finite positive number of milliseconds");
-  }
-  const idleTimeoutSeconds = options.idleTimeoutSeconds ?? 0;
-  if (!Number.isInteger(idleTimeoutSeconds) || idleTimeoutSeconds < 0) {
-    throw new TypeError("idleTimeoutSeconds must be a non-negative integer");
-  }
-  const framing = FRAMINGS[options.format ?? "ndjson"];
-  return {
-    method: options.method ?? "GET",
-    path: options.path,
-    handler: async (request, context) => {
-      applyIdleTimeout(context.server, request, idleTimeoutSeconds);
-      const departed = new AbortController;
-      const 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;
-              });
-            }
-          };
-          let sinceYield = 0;
-          (async () => {
-            try {
-              for (;; ) {
-                await awaitDemand();
-                if (closed)
-                  return;
-                const next = await iterator.next();
-                if (closed)
-                  return;
-                if (next.done)
-                  break;
-                if (!send(framing.frame(next.value)))
-                  return;
-                sinceYield += 1;
-                if (sinceYield >= MAX_BUFFERED_FRAMES) {
-                  sinceYield = 0;
-                  await new Promise((resolve) => {
-                    setTimeout(resolve, 0);
-                  });
-                  if (closed)
-                    return;
-                }
-              }
-              if (framing.done)
-                send(framing.done);
-            } catch (error) {
-              if (closed) {
-                if (!isStreamCancellation(error, departed.signal))
-                  pumped.reject(error);
-              } else
-                send(framing.frame(normalizeError(error).toJSON()));
-            } finally {
-              pumped.resolve();
-              release();
-              finish();
-            }
-          })();
-        },
-        pull() {
-          signalDemand();
-        },
-        cancel() {
-          release();
-        }
-      }, { highWaterMark: MAX_BUFFERED_FRAMES });
-      return new Response(stream, { headers: responseHeaders(framing, options.headers) });
-    }
-  };
-}
-function ndjsonRoute(options) {
-  return streamingRoute({ ...options, format: "ndjson" });
-}
-function sseRoute(options) {
-  return streamingRoute({ ...options, format: "sse" });
-}
-
-// src/server/request-body.ts
-function requestAbortReason(req) {
-  return req.signal.reason ?? new DOMException("The connection was closed", "AbortError");
-}
-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/error-dispatch.ts
-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/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/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/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/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/create.ts
-var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
-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 isAsyncIterable(value) {
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return false;
-  }
-  return typeof Reflect.get(value, Symbol.asyncIterator) === "function";
-}
-function createHandler(config) {
-  const { cors, hooks, logging = false, observability, trustProxy = false } = config;
-  if (cors)
-    assertCorsConfig(cors);
-  assertJsonBodyLimit(config.maxJsonBodyBytes, "HandlerConfig.maxJsonBodyBytes");
-  const logConfig = resolveLoggingConfig(logging);
-  const customLogger = logConfig?.logger ?? null;
-  const useDefaultLog = logConfig !== null && !logConfig.logger;
-  const customTraceId = config.traceId;
-  const warn = (line) => {
-    try {
-      if (customLogger)
-        customLogger.warn(line);
-      else
-        console.warn(line);
-    } catch {}
-  };
-  let traceResolverBroken = false;
-  const warnedEnrichKeys = new Set;
-  const resolveId = (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);
-    }
-  };
-  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);
-  }
-  async function dispatch(req, url, traceId, server, clientIp, startedAt) {
-    const shouldLogRequest = logConfig !== null && shouldLog(url.pathname, req.method) && !shouldSkipLog(logConfig, req, url);
-    const ipAddress = extractIp(req, clientIp) || undefined;
-    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;
-    const complete = (status, errorCode2, outcome) => {
-      if (completed)
-        return;
-      completed = true;
-      const durationMs = Math.round(Number(process.hrtime.bigint() - startedAt) / 1e6);
-      if (reqLog && logConfig) {
-        try {
-          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
-            });
-          }
-        } catch {}
-      }
-      const context = getRequestContext();
-      if (observability && context) {
-        try {
-          observability.complete({
-            context,
-            statusCode: status,
-            durationMs,
-            payload,
-            ...outcome !== undefined && { outcome }
-          });
-        } catch {}
-      }
-    };
-    const respondError = 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 json(appErr.toJSON(), appErr.status, cors, req);
-    };
-    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));
-    }
-    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;
-      }
-      let result = await method.handler(ctx);
-      if (method.rawResponse) {
-        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, cors, req);
-        complete(rawRes.status);
-        return rawRes;
-      }
-      if (method.stream) {
-        if (!streamAbort || !isAsyncIterable(result)) {
-          streamAbort?.abort();
-          throw new AppError("INTERNAL_SERVER_ERROR", `Streaming endpoint ${method.serviceName}.${method.key} must return an AsyncIterable`, 500);
-        }
-        const response = await contractStreamResponse(req, { params: pathParams, server, ipAddress: clientIp.socketIp }, result, method.stream, streamAbort);
-        const withCors = applyCors(response, cors, req);
-        complete(withCors.status);
-        return withCors;
-      }
-      if (groupHooks?.afterHandle) {
-        const transformed = await groupHooks.afterHandle(ctx, result, method);
-        if (transformed !== undefined)
-          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(corsHeaders2(cors, req));
-      applyResponseMetadata(responseHeaders2, responseMetadata, `${method.serviceName}.${method.key}`);
-      if (!method.outputSchema) {
-        const empty = new Response(null, { status: responseStatus, headers: responseHeaders2 });
-        complete(responseStatus);
-        return empty;
-      }
-      const body = Response.json(result, { status: responseStatus, headers: responseHeaders2 });
-      complete(responseStatus);
-      return body;
-    } catch (err) {
-      await multipartLifecycle?.rollback();
-      return respondError(err, ctx, method, groupHooks);
-    }
-  }
-  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(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(resolveId(req), requestStartedAt);
-    const trace = resolveTraceContext(req);
-    const traceId = 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));
-  };
-}
-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;
-}
-function corsHeaders2(cors, req) {
-  if (!cors)
-    return {};
-  return corsHeaders(cors, req.headers.get("origin"));
-}
-function applyCors(res, cors, req) {
-  const extra = corsHeaders2(cors, req);
-  if (Object.keys(extra).length === 0)
-    return res;
-  try {
-    for (const [key, value] of Object.entries(extra))
-      setCorsHeader(res.headers, key, value);
-    return res;
-  } catch {
-    const headers = new Headers(res.headers);
-    for (const [key, value] of Object.entries(extra))
-      setCorsHeader(headers, key, value);
-    return new Response(res.body, {
-      status: res.status,
-      statusText: res.statusText,
-      headers
-    });
-  }
-}
-function setCorsHeader(headers, key, value) {
-  if (key !== "Vary") {
-    headers.set(key, value);
-    return;
-  }
-  const existing = headers.get("Vary");
-  if (existing === null || existing.trim() === "") {
-    headers.set("Vary", value);
-    return;
-  }
-  const present = existing.split(",").some((field) => field.trim().toLowerCase() === "origin");
-  if (!present)
-    headers.set("Vary", `${existing}, ${value}`);
-}
-function json(data, status, cors, req) {
-  return Response.json(data, { status, headers: corsHeaders2(cors, req) });
-}
-
-// 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-bun.ts
-var MAX_BODY_CHUNK_BYTES = 64 * 1024;
-function isBunUnixRuntime(candidate) {
-  if (typeof candidate !== "object" || candidate === null)
-    return false;
-  return typeof Reflect.get(candidate, "connect") === "function";
-}
-function runtimeBun() {
-  const candidate = Reflect.get(globalThis, "Bun");
-  return isBunUnixRuntime(candidate) ? candidate : undefined;
-}
-function hasBunUnixRuntime() {
-  return runtimeBun() !== undefined;
-}
-function concatBytes2(left, right) {
-  if (left.byteLength === 0)
-    return right.slice();
-  const combined = new Uint8Array(left.byteLength + right.byteLength);
-  combined.set(left);
-  combined.set(right, left.byteLength);
-  return combined;
-}
-function indexOfSequence(bytes, sequence) {
-  outer:
-    for (let index = 0;index <= bytes.byteLength - sequence.length; index += 1) {
-      for (let offset = 0;offset < sequence.length; offset += 1) {
-        if (bytes[index + offset] !== sequence[offset])
-          continue outer;
-      }
-      return index;
-    }
-  return -1;
-}
-function requestBytes(request, body) {
-  const url = new URL(request.url);
-  const headers = new Headers(request.headers);
-  headers.set("host", url.host);
-  headers.set("connection", "close");
-  headers.set("accept-encoding", "identity");
-  headers.delete("transfer-encoding");
-  headers.delete("content-length");
-  if (body !== undefined)
-    headers.set("content-length", String(body.byteLength));
-  const lines = [`${request.method} ${url.pathname}${url.search} HTTP/1.1`];
-  for (const [name, value] of headers)
-    lines.push(`${name}: ${value}`);
-  const head = new TextEncoder().encode(`${lines.join(`\r
-`)}\r
-\r
-`);
-  return body === undefined ? head : concatBytes2(head, body);
-}
-function parseContentLength(headers) {
-  const raw = headers.get("content-length");
-  if (raw === null)
-    return;
-  if (!/^\d+$/.test(raw))
-    throw new Error("Unix response has an invalid Content-Length");
-  const value = Number(raw);
-  if (!Number.isSafeInteger(value)) {
-    throw new Error("Unix response Content-Length is not a safe integer");
-  }
-  return value;
-}
-function bunUnixRequest(options) {
-  const outgoing = requestBytes(options.request, options.body);
-  const bun = runtimeBun();
-  if (!bun)
-    throw new Error("Bun Unix runtime is unavailable");
-  let socket;
-  let controller;
-  let wire = new Uint8Array;
-  let responseResolved = false;
-  let headersReceived = false;
-  let settled = false;
-  let bodyComplete = false;
-  let peerEnded = false;
-  let chunked = false;
-  let chunkRemaining;
-  let expectChunkCrlf = false;
-  let trailers = false;
-  let remainingLength;
-  let received = 0;
-  let writeOffset = 0;
-  let resolveResponse = () => {
-    return;
-  };
-  let rejectResponse = () => {
-    return;
-  };
-  const response = new Promise((resolve, reject) => {
-    resolveResponse = resolve;
-    rejectResponse = reject;
-  });
-  const transportFailure = (error) => {
-    if (error instanceof UnixClientTransportError)
-      return error;
-    if (headersReceived) {
-      return new UnixClientTransportError("UNIX_RESPONSE_ABORTED", "Unix response failed before completion", "response-received", { cause: error });
-    }
-    const dispatched = writeOffset > 0;
-    return new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error });
-  };
-  const clearRegistration = options.registerAbort(() => {
-    fail(new UnixClientTransportError("UNIX_CLIENT_CLOSED", "Unix client transport is closed"));
-  });
-  const timer = setTimeout(() => {
-    fail(new UnixClientTransportError("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${options.headersTimeoutMs}ms`));
-  }, options.headersTimeoutMs);
-  timer.unref();
-  const removeRequestAbort = () => {
-    options.request.signal.removeEventListener("abort", abortRequest);
-  };
-  const finish = (terminate = true) => {
-    if (settled)
-      return;
-    settled = true;
-    clearTimeout(timer);
-    clearRegistration();
-    removeRequestAbort();
-    if (terminate)
-      socket?.terminate();
-  };
-  function fail(error) {
-    if (settled)
-      return;
-    if (responseResolved)
-      controller?.error(error);
-    else
-      rejectResponse(error);
-    finish();
-  }
-  function abortRequest() {
-    fail(options.request.signal.reason ?? new DOMException("Request aborted", "AbortError"));
-  }
-  const takeWire = (bytes) => {
-    const value = wire.slice(0, bytes);
-    wire = wire.slice(bytes);
-    return value;
-  };
-  const enqueue = (value) => {
-    if (options.maxResponseBytes !== undefined)
-      received += value.byteLength;
-    if (options.maxResponseBytes !== undefined && received > options.maxResponseBytes) {
-      fail(new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${options.maxResponseBytes} byte limit`, "response-received"));
-      return;
-    }
-    controller?.enqueue(value);
-  };
-  const completeBody = () => {
-    if (bodyComplete || settled)
-      return;
-    bodyComplete = true;
-    controller?.close();
-    finish();
-  };
-  const resumeForData = () => {
-    if (settled || bodyComplete || peerEnded)
-      return;
-    socket?.resume();
-  };
-  const pumpChunked = () => {
-    if (!controller || settled || bodyComplete)
-      return;
-    for (;; ) {
-      if ((controller.desiredSize ?? 1) <= 0)
-        return;
-      if (trailers) {
-        if (wire.byteLength >= 2 && wire[0] === 13 && wire[1] === 10) {
-          takeWire(2);
-          completeBody();
-          return;
-        }
-        const trailerEnd = indexOfSequence(wire, [13, 10, 13, 10]);
-        if (trailerEnd < 0) {
-          if (wire.byteLength > options.maxHeaderBytes) {
-            fail(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response trailers exceed the ${options.maxHeaderBytes} byte limit`, "response-received"));
-          } else if (peerEnded) {
-            fail(transportFailure(new Error("Unix chunked response ended inside trailers")));
-          } else {
-            resumeForData();
-          }
-          return;
-        }
-        takeWire(trailerEnd + 4);
-        completeBody();
-        return;
-      }
-      if (expectChunkCrlf) {
-        if (wire.byteLength < 2) {
-          if (peerEnded) {
-            fail(transportFailure(new Error("Unix chunked response ended before chunk delimiter")));
-          } else
-            resumeForData();
-          return;
-        }
-        if (wire[0] !== 13 || wire[1] !== 10) {
-          fail(transportFailure(new Error("Unix chunked response has an invalid chunk delimiter")));
-          return;
-        }
-        takeWire(2);
-        expectChunkCrlf = false;
-      }
-      if (chunkRemaining === undefined) {
-        const lineEnd = indexOfSequence(wire, [13, 10]);
-        if (lineEnd < 0) {
-          if (wire.byteLength > 1024) {
-            fail(transportFailure(new Error("Unix chunk header is too large")));
-          } else if (peerEnded) {
-            fail(transportFailure(new Error("Unix chunked response ended inside chunk header")));
-          } else
-            resumeForData();
-          return;
-        }
-        const line = new TextDecoder("ascii", { fatal: true }).decode(takeWire(lineEnd));
-        takeWire(2);
-        const sizeText = line.split(";", 1)[0]?.trim() ?? "";
-        if (!/^[0-9a-f]+$/i.test(sizeText)) {
-          fail(transportFailure(new Error("Unix chunked response has an invalid chunk size")));
-          return;
-        }
-        chunkRemaining = Number.parseInt(sizeText, 16);
-        if (!Number.isSafeInteger(chunkRemaining)) {
-          fail(transportFailure(new Error("Unix chunk size is not a safe integer")));
-          return;
-        }
-        if (chunkRemaining === 0) {
-          chunkRemaining = undefined;
-          trailers = true;
-          continue;
-        }
-      }
-      if (wire.byteLength === 0) {
-        if (peerEnded) {
-          fail(transportFailure(new Error("Unix chunked response ended inside a chunk")));
-        } else
-          resumeForData();
-        return;
-      }
-      const bytes = Math.min(chunkRemaining, wire.byteLength, MAX_BODY_CHUNK_BYTES);
-      const value = takeWire(bytes);
-      chunkRemaining -= bytes;
-      if (chunkRemaining === 0) {
-        chunkRemaining = undefined;
-        expectChunkCrlf = true;
-      }
-      enqueue(value);
-      return;
-    }
-  };
-  const pumpPlain = () => {
-    if (!controller || settled || bodyComplete)
-      return;
-    if ((controller.desiredSize ?? 1) <= 0)
-      return;
-    if (wire.byteLength > 0) {
-      const permitted = remainingLength ?? wire.byteLength;
-      const bytes = Math.min(permitted, wire.byteLength, MAX_BODY_CHUNK_BYTES);
-      enqueue(takeWire(bytes));
-      if (settled)
-        return;
-      if (remainingLength !== undefined) {
-        remainingLength -= bytes;
-        if (remainingLength === 0) {
-          completeBody();
-          return;
-        }
-      }
-      return;
-    }
-    if (peerEnded) {
-      if (remainingLength !== undefined && remainingLength > 0) {
-        fail(transportFailure(new Error("Unix response ended before Content-Length bytes arrived")));
-      } else {
-        completeBody();
-      }
-      return;
-    }
-    resumeForData();
-  };
-  const pump = () => {
-    if (chunked)
-      pumpChunked();
-    else
-      pumpPlain();
-  };
-  const parseHeaders = () => {
-    const headerEnd = indexOfSequence(wire, [13, 10, 13, 10]);
-    if (headerEnd < 0) {
-      if (wire.byteLength > options.maxHeaderBytes) {
-        fail(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${options.maxHeaderBytes} byte limit`, "response-received"));
-      } else {
-        socket?.resume();
-      }
-      return;
-    }
-    if (headerEnd + 4 > options.maxHeaderBytes) {
-      fail(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${options.maxHeaderBytes} byte limit`, "response-received"));
-      return;
-    }
-    headersReceived = true;
-    let text;
-    try {
-      text = new TextDecoder("utf-8", { fatal: true }).decode(takeWire(headerEnd));
-    } catch (error) {
-      fail(transportFailure(error));
-      return;
-    }
-    takeWire(4);
-    const lines = text.split(`\r
-`);
-    const statusLine = lines.shift() ?? "";
-    const matched = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
-    if (!matched) {
-      fail(transportFailure(new Error("Unix response has an invalid HTTP status line")));
-      return;
-    }
-    const status = Number(matched[1]);
-    const statusText = matched[2] ?? "";
-    const headers = new Headers;
-    try {
-      for (const line of lines) {
-        const separator = line.indexOf(":");
-        if (separator <= 0)
-          throw new Error("Unix response has an invalid header line");
-        headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim());
-      }
-      remainingLength = parseContentLength(headers);
-    } catch (error) {
-      fail(transportFailure(error));
-      return;
-    }
-    if (options.maxResponseBytes !== undefined && remainingLength !== undefined && remainingLength > options.maxResponseBytes) {
-      fail(new UnixClientTransportError("UNIX_RESPONSE_TOO_LARGE", `Unix response body exceeds the ${options.maxResponseBytes} byte limit`, "response-received"));
-      return;
-    }
-    chunked = headers.get("transfer-encoding")?.toLowerCase().includes("chunked") ?? false;
-    const bodyless = options.request.method === "HEAD" || status === 204 || status === 205 || status === 304;
-    clearTimeout(timer);
-    responseResolved = true;
-    if (bodyless || remainingLength === 0) {
-      resolveResponse(new Response(null, { status, statusText, headers }));
-      finish();
-      return;
-    }
-    const body = new ReadableStream({
-      start(value) {
-        controller = value;
-        pump();
-      },
-      pull() {
-        pump();
-      },
-      cancel() {
-        finish();
-      }
-    }, { highWaterMark: 1 });
-    resolveResponse(new Response(body, { status, statusText, headers }));
-  };
-  const flushRequest = (active) => {
-    while (writeOffset < outgoing.byteLength) {
-      const written = active.write(outgoing, writeOffset, outgoing.byteLength - writeOffset);
-      if (written < 0) {
-        fail(transportFailure(new Error("Unix request socket closed while writing")));
-        return;
-      }
-      if (written === 0)
-        return;
-      writeOffset += written;
-    }
-  };
-  if (options.request.signal.aborted) {
-    fail(options.request.signal.reason ?? new DOMException("Request aborted", "AbortError"));
-    return response;
-  }
-  options.request.signal.addEventListener("abort", abortRequest, { once: true });
-  bun.connect({
-    unix: options.socketPath,
-    socket: {
-      binaryType: "uint8array",
-      open(active) {
-        socket = active;
-        if (settled) {
-          active.terminate();
-          return;
-        }
-        flushRequest(active);
-      },
-      drain(active) {
-        flushRequest(active);
-      },
-      data(active, data) {
-        active.pause();
-        wire = concatBytes2(wire, data);
-        if (!responseResolved)
-          parseHeaders();
-        else
-          pump();
-      },
-      end() {
-        peerEnded = true;
-        if (!responseResolved) {
-          fail(transportFailure(new Error("Unix connection ended before response headers")));
-        } else
-          pump();
-      },
-      close(_active, error) {
-        peerEnded = true;
-        if (settled)
-          return;
-        if (error)
-          fail(transportFailure(error));
-        else if (!responseResolved) {
-          fail(transportFailure(new Error("Unix connection closed before response headers")));
-        } else
-          pump();
-      },
-      error(_active, error) {
-        fail(transportFailure(error));
-      },
-      connectError(_active, error) {
-        fail(transportFailure(error));
-      }
-    }
-  }).catch((error) => fail(transportFailure(error)));
-  return response;
-}
-
-// src/server/unix-client.ts
-var DEFAULT_MAX_BODY_BYTES = 16 * 1024 * 1024;
-var DEFAULT_HEADERS_TIMEOUT_MS = 30000;
-var DEFAULT_MAX_CONNECTIONS = 8;
-var DEFAULT_MAX_REDIRECTS = 5;
-var DEFAULT_MAX_HEADER_BYTES2 = 64 * 1024;
-function positiveInteger(value, fallback, name) {
-  const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
-    throw new TypeError(`${name} must be a positive safe integer`);
-  }
-  return resolved;
-}
-function nonNegativeInteger(value, fallback, name) {
-  const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved < 0) {
-    throw new TypeError(`${name} must be a non-negative safe integer`);
-  }
-  return resolved;
-}
-function isRedirect(status) {
-  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-function requestBody(body) {
-  if (body === undefined)
-    return;
-  const copy = new ArrayBuffer(body.byteLength);
-  new Uint8Array(copy).set(body);
-  return copy;
-}
-function responseHeaders2(response) {
-  const headers = new Headers;
-  for (let index = 0;index < response.rawHeaders.length; index += 2) {
-    const name = response.rawHeaders[index];
-    const value = response.rawHeaders[index + 1];
-    if (name !== undefined && value !== undefined)
-      headers.append(name, value);
-  }
-  return headers;
-}
-function 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 createUnixClientTransport(config) {
-  if (!config.socketPath.startsWith("/") || config.socketPath.includes("\x00")) {
-    throw new TypeError("socketPath must be an absolute Unix socket path");
-  }
-  const maxRequestBytes = positiveInteger(config.maxRequestBytes, DEFAULT_MAX_BODY_BYTES, "maxRequestBytes");
-  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");
-  const agent = new Agent({ keepAlive: true, maxSockets: maxConnections });
-  const activeRequests = new Set;
-  const activeResponses = new Set;
-  const bunAborters = new Set;
-  let closed = false;
-  const dispatch = async (request, redirectCount) => {
-    if (closed) {
-      throw new UnixClientTransportError("UNIX_CLIENT_CLOSED", "Unix client transport is closed", "not-dispatched");
-    }
-    if (request.signal.aborted)
-      throw request.signal.reason;
-    const url = new URL(request.url);
-    if (url.protocol !== "http:") {
-      throw new TypeError("Unix client transport accepts only http: request URLs");
-    }
-    const body = await readBoundedRequestBody(request, maxRequestBytes);
-    if (hasBunUnixRuntime()) {
-      if (bunAborters.size >= maxConnections) {
-        throw new UnixClientTransportError("UNIX_CONNECTION_LIMIT", `Unix client connection limit ${maxConnections} reached`, "not-dispatched");
-      }
-      const response = await bunUnixRequest({
-        socketPath: config.socketPath,
-        request,
-        body,
-        maxResponseBytes,
-        maxHeaderBytes,
-        headersTimeoutMs,
-        registerAbort(abort) {
-          bunAborters.add(abort);
-          return () => void bunAborters.delete(abort);
-        }
-      });
-      const location2 = response.headers.get("location");
-      if (location2 && isRedirect(response.status)) {
-        if (request.redirect === "error" || redirectCount >= maxRedirects) {
-          await response.body?.cancel();
-          throw new UnixClientTransportError("UNIX_REDIRECT_REFUSED", redirectCount >= maxRedirects ? `Unix redirect limit ${maxRedirects} exceeded` : "Unix request redirect mode is error", "response-received");
-        }
-        if (request.redirect === "follow") {
-          await response.body?.cancel();
-          return dispatch(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
-        }
-      }
-      return response;
-    }
-    const headers = Object.fromEntries(request.headers.entries());
-    if (!Object.keys(headers).some((name) => name.toLowerCase() === "host")) {
-      headers.host = url.host;
-    }
-    const incoming = await new Promise((resolve, reject) => {
-      let settled = false;
-      const resolveOnce = (response) => {
-        if (settled)
-          return;
-        settled = true;
-        resolve(response);
-      };
-      const rejectOnce = (error) => {
-        if (settled)
-          return;
-        settled = true;
-        reject(error);
-      };
-      const outgoing = httpRequest({
-        socketPath: config.socketPath,
-        path: `${url.pathname}${url.search}`,
-        method: request.method,
-        headers,
-        agent,
-        signal: request.signal,
-        maxHeaderSize: maxHeaderBytes
-      }, resolveOnce);
-      let connected = false;
-      let requestStartBytes = 0;
-      outgoing.once("socket", (socket) => {
-        requestStartBytes = socket.bytesWritten;
-        if (!socket.connecting && !socket.destroyed)
-          connected = true;
-        else {
-          socket.once("connect", () => {
-            connected = true;
-          });
-        }
-      });
-      activeRequests.add(outgoing);
-      const timer = setTimeout(() => {
-        const error = new UnixClientTransportError("UNIX_HEADERS_TIMEOUT", `Unix response headers did not arrive within ${headersTimeoutMs}ms`);
-        rejectOnce(error);
-        outgoing.destroy(error);
-      }, headersTimeoutMs);
-      timer.unref();
-      outgoing.once("response", () => clearTimeout(timer));
-      outgoing.once("error", (error) => {
-        if (isNodeHeaderOverflow(error)) {
-          rejectOnce(new UnixClientTransportError("UNIX_HEADERS_TOO_LARGE", `Unix response headers exceed the ${maxHeaderBytes} byte limit`, "response-received", { cause: error }));
-          return;
-        }
-        const dispatched = connected && (outgoing.socket?.bytesWritten ?? requestStartBytes) > requestStartBytes;
-        rejectOnce(new UnixClientTransportError(dispatched ? "UNIX_DELIVERY_UNCERTAIN" : "UNIX_CONNECT_FAILED", dispatched ? "Unix request transport failed after dispatch may have begun" : "Unix socket connection failed before request dispatch", dispatched ? "possibly-dispatched" : "not-dispatched", { cause: error }));
-      });
-      outgoing.once("close", () => {
-        clearTimeout(timer);
-        activeRequests.delete(outgoing);
-      });
-      outgoing.end(body);
-    });
-    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");
-    if (location && isRedirect(status)) {
-      if (request.redirect === "error" || redirectCount >= maxRedirects) {
-        incoming.destroy();
-        releaseResponse();
-        throw new UnixClientTransportError("UNIX_REDIRECT_REFUSED", redirectCount >= maxRedirects ? `Unix redirect limit ${maxRedirects} exceeded` : "Unix request redirect mode is error", "response-received");
-      }
-      if (request.redirect === "follow") {
-        incoming.destroy();
-        releaseResponse();
-        return dispatch(redirectedRequest(request, location, status, body), redirectCount + 1);
-      }
-    }
-    const bodyless = request.method === "HEAD" || status === 204 || status === 205 || status === 304;
-    if (bodyless) {
-      incoming.resume();
-      incoming.once("end", releaseResponse);
-      return new Response(null, {
-        status,
-        statusText: incoming.statusMessage,
-        headers: responseHeadersValue
-      });
-    }
-    return new Response(incomingResponseBody(incoming, maxResponseBytes, releaseResponse), {
-      status,
-      statusText: incoming.statusMessage,
-      headers: responseHeadersValue
-    });
-  };
-  return {
-    fetch(input, init) {
-      return dispatch(new Request(input, init), 0);
-    },
-    get closed() {
-      return closed;
-    },
-    async close() {
-      if (closed)
-        return;
-      closed = true;
-      for (const request of activeRequests)
-        request.destroy();
-      for (const response of activeResponses)
-        response.destroy();
-      for (const abort of [...bunAborters])
-        abort();
-      activeRequests.clear();
-      activeResponses.clear();
-      bunAborters.clear();
-      agent.destroy();
-    }
-  };
-}
-
-export { parseMultipart, DEFAULT_STREAM_HEARTBEAT_MS, streamingRoute, ndjsonRoute, sseRoute, createHandler, bindProcessSignals, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane, UnixClientTransportError, createUnixClientTransport };