stitchkit 0.92.0 → 0.94.0

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

@@ -10,46 +10,49 @@ import {
 import {
   createValidatedRealtimeSocket,
   isModuleNotFound
-} from "./index-f477k430.js";
+} from "./index-x4799c19.js";
+import {
+  DEFAULT_CONTRACT_STREAM_FRAME_BYTES
+} from "./index-wqgjfstn.js";
 import {
   DEFAULT_PROCESS_SIGNALS,
   RUNTIME_CONTEXT_RESERVED_KEYS,
+  applyCors,
   assertCorsConfig,
-  corsHeaders,
   corsPreflightResponse,
   defaultSignalSource,
   guardSignalCallback,
   isOriginAllowed,
   mediaTypeEssence,
-  reportSignalError
-} from "./index-cxqhvq21.js";
+  reportSignalError,
+  requestCorsHeaders
+} from "./index-xnj9bgxe.js";
+import {
+  joinRoutePath,
+  parseTrailingWildcard
+} from "./index-gyr48nzg.js";
 import {
   getRequestContext,
   runWithRequestContext,
   setRequestEndpoint,
   setRequestError
-} from "./index-tmwcrptx.js";
+} from "./index-zfrhfn82.js";
 import {
   extractIp,
   getClientInfo,
   parseQueryParams,
   resolveSocketIp,
   resolveTraceId
-} from "./index-f9mb610r.js";
+} from "./index-35mh5bhj.js";
+import {
+  resolveTraceContext
+} from "./index-zcgf3gqf.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";
+} from "./index-znfs20ss.js";
 import {
   AppError,
   badRequest,
@@ -62,7 +65,7 @@ import {
 import {
   isRecord,
   transportResult
-} from "./index-77fekveh.js";
+} from "./index-hffjpmq9.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
@@ -1052,7 +1055,243 @@ function contractStreamResponse(request, context, source, descriptor, operationA
   return Promise.resolve(route.handler(request, context));
 }
 
+// src/server/response-metadata.ts
+var RESERVED_HEADERS = new Set(["content-type", "content-length", "x-request-id"]);
+function hasGetSetCookie(headers) {
+  return "getSetCookie" in headers && typeof headers.getSetCookie === "function";
+}
+function isReservedHeader(name) {
+  const normalized = name.toLowerCase();
+  return RESERVED_HEADERS.has(normalized) || normalized.startsWith("access-control-");
+}
+function createResponseMetadata() {
+  return { headers: new Headers };
+}
+function applyResponseMetadata(target, metadata, endpointIdentity) {
+  if (!metadata)
+    return;
+  for (const [name] of metadata.headers) {
+    if (isReservedHeader(name)) {
+      throw new Error(`${endpointIdentity} cannot set framework-owned response header "${name}"`);
+    }
+  }
+  const preservesSetCookie = hasGetSetCookie(metadata.headers);
+  for (const [name, value] of metadata.headers) {
+    if (name.toLowerCase() === "set-cookie" && preservesSetCookie)
+      continue;
+    target.append(name, value);
+  }
+  if (preservesSetCookie) {
+    for (const cookie of metadata.headers.getSetCookie()) {
+      target.append("Set-Cookie", cookie);
+    }
+  }
+}
+
+// src/server/endpoint-response.ts
+function isAsyncIterable(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return false;
+  }
+  return typeof Reflect.get(value, Symbol.asyncIterator) === "function";
+}
+async function endpointResponse(state, request, outcome) {
+  const { method } = outcome.match;
+  if (method.rawResponse)
+    return rawEndpointResponse(state, request, outcome);
+  if (method.stream)
+    return streamEndpointResponse(state, request, outcome);
+  return dataEndpointResponse(state, request, outcome);
+}
+function rawEndpointResponse(state, request, { match: { method }, result }) {
+  if (!(result instanceof Response)) {
+    throw new AppError("INTERNAL_SERVER_ERROR", `Raw endpoint ${method.serviceName}.${method.key} must return a Response`, 500);
+  }
+  const response = method.method === "HEAD" ? new Response(null, {
+    status: result.status,
+    statusText: result.statusText,
+    headers: result.headers
+  }) : result;
+  const rawRes = applyCors(response, state.cors, request.req);
+  request.complete(rawRes.status);
+  return rawRes;
+}
+async function streamEndpointResponse(state, request, { match: { method, pathParams }, result, streamAbort }) {
+  const { req, server, clientIp } = request;
+  if (!method.stream || !streamAbort || !isAsyncIterable(result)) {
+    streamAbort?.abort();
+    throw new AppError("INTERNAL_SERVER_ERROR", `Streaming endpoint ${method.serviceName}.${method.key} must return an AsyncIterable`, 500);
+  }
+  const response = await contractStreamResponse(req, { params: pathParams, server, ipAddress: clientIp.socketIp }, result, method.stream, streamAbort);
+  const withCors = applyCors(response, state.cors, req);
+  request.complete(withCors.status);
+  return withCors;
+}
+async function dataEndpointResponse(state, request, {
+  ctx,
+  match: { method, groupHooks },
+  result: handlerResult,
+  responseMetadata
+}) {
+  const { hooks, config, cors, warn } = state;
+  const { req } = request;
+  let result = handlerResult;
+  if (groupHooks?.afterHandle) {
+    const transformed = await groupHooks.afterHandle(ctx, result, method);
+    if (transformed !== undefined)
+      result = transformed;
+  }
+  if (hooks?.afterHandle) {
+    const transformed = await hooks.afterHandle(ctx, result, method);
+    if (transformed !== undefined)
+      result = transformed;
+  }
+  if (result instanceof Response) {
+    throw new AppError("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} produced a Response on the data path — only a \`rawResponse: true\` endpoint may return one (an afterHandle hook must return data)`, 500);
+  }
+  const checked = validateDeclaredOutput(method.outputSchema, result, config.warnOnOutputStrip && method.outputSchema ? (paths) => {
+    warn(`[stitchkit] output strip ${method.serviceName}.${method.key}: ${paths.join(", ")}`);
+  } : undefined);
+  if (!checked.ok) {
+    throw new AppError("INTERNAL_SERVER_ERROR", checked.message, 500);
+  }
+  result = checked.data;
+  const responseStatus = method.responseMeta?.status ?? (method.outputSchema ? 200 : 204);
+  if (method.outputSchema && (responseStatus === 204 || responseStatus === 205)) {
+    throw new AppError("INTERNAL_SERVER_ERROR", `${method.serviceName}.${method.key} cannot combine output with bodyless status ${responseStatus}`, 500);
+  }
+  const responseHeaders2 = new Headers(requestCorsHeaders(cors, req));
+  applyResponseMetadata(responseHeaders2, responseMetadata, `${method.serviceName}.${method.key}`);
+  if (!method.outputSchema) {
+    const empty = new Response(null, { status: responseStatus, headers: responseHeaders2 });
+    request.complete(responseStatus);
+    return empty;
+  }
+  const body = Response.json(result, { status: responseStatus, headers: responseHeaders2 });
+  request.complete(responseStatus);
+  return body;
+}
+
+// src/server/endpoint-dispatch.ts
+async function dispatchEndpoint(state, request, match) {
+  const { hooks, config, cors } = state;
+  const { req, url, traceId, clientIp } = request;
+  const { method, pathParams, groupHooks } = match;
+  const ctx = buildBaseContext(req, url, pathParams, traceId, clientIp);
+  setRequestEndpoint(method.serviceName, method.key);
+  let multipartLifecycle;
+  try {
+    parsePathParamsInto(ctx, method);
+    if (hooks?.authorize) {
+      await hooks.authorize(ctx, method);
+    }
+    if (groupHooks?.authorize) {
+      await groupHooks.authorize(ctx, method);
+    }
+    multipartLifecycle = await parseRequestPayloadInto(ctx, req, url, method, config.maxJsonBodyBytes, cors);
+    if (hooks?.beforeHandle) {
+      await hooks.beforeHandle(ctx, method);
+    }
+    if (groupHooks?.beforeHandle) {
+      await groupHooks.beforeHandle(ctx, method);
+    }
+    const responseMetadata = method.responseMeta ? createResponseMetadata() : undefined;
+    if (responseMetadata)
+      ctx.response = responseMetadata;
+    const streamAbort = method.stream ? new AbortController : undefined;
+    if (streamAbort) {
+      if (req.signal.aborted)
+        streamAbort.abort(req.signal.reason);
+      else {
+        req.signal.addEventListener("abort", () => streamAbort.abort(req.signal.reason), {
+          once: true
+        });
+      }
+      ctx.signal = streamAbort.signal;
+    }
+    const result = await method.handler(ctx);
+    return await endpointResponse(state, request, {
+      ctx,
+      match,
+      result,
+      responseMetadata,
+      streamAbort
+    });
+  } catch (err) {
+    await multipartLifecycle?.rollback();
+    return request.respondError(err, ctx, method, groupHooks);
+  }
+}
+
 // src/server/error-dispatch.ts
+var MAX_REQUEST_ABORT_CAUSE_DEPTH = 8;
+function containsRequestAbortReason(error, reason) {
+  let current = error;
+  const visited = new Set;
+  for (let depth = 0;depth <= MAX_REQUEST_ABORT_CAUSE_DEPTH; depth += 1) {
+    if (current === reason)
+      return true;
+    if (depth === MAX_REQUEST_ABORT_CAUSE_DEPTH || !isRecord(current))
+      return false;
+    if (visited.has(current))
+      return false;
+    visited.add(current);
+    current = current.cause;
+  }
+  return false;
+}
+function isClientClosedRequest(req, error) {
+  if (!req.signal.aborted)
+    return false;
+  if (isRecord(error) && error.name === "AbortError")
+    return true;
+  return req.signal.reason !== undefined && containsRequestAbortReason(error, req.signal.reason);
+}
+function createErrorResponder(state, request) {
+  const { cors, hooks, customLogger } = state;
+  const { req, url, traceId, clientIp, complete } = request;
+  return async (err, errCtx, endpoint, group) => {
+    if (isClientClosedRequest(req, err)) {
+      const response = applyCors(new Response(null, { status: 499, statusText: "Client Closed Request" }), cors, req);
+      complete(response.status, undefined, "cancelled");
+      return response;
+    }
+    const recordFailure = (normalized) => {
+      if (getRequestContext()?.error !== undefined)
+        return;
+      const known = AppError.is(err) ? err : normalized;
+      const code = known?.code ?? errorCode(err) ?? "INTERNAL_SERVER_ERROR";
+      setRequestError({
+        code,
+        message: recordedErrorMessage(code, known?.message, err),
+        details: known?.details
+      });
+    };
+    const customResponse = await dispatchErrorHooks({
+      context: errCtx ?? buildErrorContext(req, url, traceId, clientIp),
+      error: err,
+      endpoint,
+      group,
+      global: hooks,
+      logger: customLogger,
+      respond: (response) => {
+        recordFailure();
+        const withCors = applyCors(response, cors, req);
+        complete(withCors.status, errorCode(err));
+        return withCors;
+      }
+    });
+    if (customResponse)
+      return customResponse;
+    const appErr = normalizeError(err);
+    recordFailure(appErr);
+    complete(appErr.status, appErr.code);
+    return Response.json(appErr.toJSON(), {
+      status: appErr.status,
+      headers: requestCorsHeaders(cors, req)
+    });
+  };
+}
 async function dispatchErrorHooks(config) {
   for (const [scope, hooks] of [
     ["group", config.group],
@@ -1077,134 +1316,6 @@ async function dispatchErrorHooks(config) {
   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) {
@@ -1258,57 +1369,24 @@ function collectExtraLogFields(config, req, url, outcome) {
   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-");
+// src/server/router.ts
+function routeSegments(path) {
+  return path.split("/").filter(Boolean);
 }
-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 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")
@@ -1550,46 +1628,50 @@ function validateRawRoutes(rawRoutes) {
   }
 }
 
-// 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;
+// src/server/route-table.ts
+function compileRouteTable(config, warn) {
+  for (const group of config.groups ?? []) {
+    if (group.hooks && "onRequest" in group.hooks) {
+      throw new Error("[stitchkit] a route group cannot declare `onRequest` — it runs before routing, so the group it belongs to is not known yet and the hook would never be dispatched. Refuse before dispatch with the server-level `hooks.onRequest`, or gate the group with its `authorize`, which runs once the endpoint is known.");
+    }
   }
-  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);
+  const routeMap = buildRouteMap(normalizeGroups(config));
+  validateRoutes(routeMap);
+  validateRawRoutes(config.rawRoutes);
+  for (const shadow of findShadowedRoutes(routeMap, config.rawRoutes)) {
+    const gate = shadow.scope && shadow.scope !== "public" ? ` (scope "${shadow.scope}")` : "";
+    const line = `[stitchkit] raw route ${shadow.rawRoute} shadows contract route ${shadow.pattern}` + ` → ${shadow.endpoint}${gate} will never run, and its hooks never apply`;
+    warn(line);
+  }
+  return routeMap;
 }
-function isAsyncIterable(value) {
-  if (typeof value !== "object" && typeof value !== "function" || value === null) {
-    return false;
+function normalizeGroups(config) {
+  const result = [];
+  if (config.services) {
+    for (const service of config.services) {
+      const prefix = config.scopePrefixes?.[service.scope] ?? "";
+      result.push({ prefix, service });
+    }
   }
-  return typeof Reflect.get(value, Symbol.asyncIterator) === "function";
+  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 createHandler(config) {
-  const { cors, hooks, logging = false, observability, trustProxy = false } = config;
+
+// src/server/handler-state.ts
+function createHandlerState(config) {
+  const { cors, hooks, logging = false, observability } = config;
   if (cors)
     assertCorsConfig(cors);
   assertJsonBodyLimit(config.maxJsonBodyBytes, "HandlerConfig.maxJsonBodyBytes");
   const logConfig = resolveLoggingConfig(logging);
   const customLogger = logConfig?.logger ?? null;
   const useDefaultLog = logConfig !== null && !logConfig.logger;
-  const customTraceId = config.traceId;
   const warn = (line) => {
     try {
       if (customLogger)
@@ -1598,9 +1680,23 @@ function createHandler(config) {
         console.warn(line);
     } catch {}
   };
+  return {
+    config,
+    cors,
+    hooks,
+    observability,
+    logConfig,
+    customLogger,
+    useDefaultLog,
+    warnedEnrichKeys: new Set,
+    warn,
+    resolveId: createTraceIdResolver(config.traceId, warn),
+    routeMap: compileRouteTable(config, warn)
+  };
+}
+function createTraceIdResolver(customTraceId, warn) {
   let traceResolverBroken = false;
-  const warnedEnrichKeys = new Set;
-  const resolveId = (req, fallback) => {
+  return (req, fallback) => {
     if (!customTraceId)
       return fallback ?? resolveTraceId(req);
     try {
@@ -1613,281 +1709,238 @@ function createHandler(config) {
       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.");
-    }
+}
+
+// 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);
   }
-  const routeMap = buildRouteMap(normalizeGroups(config));
-  validateRoutes(routeMap);
-  validateRawRoutes(config.rawRoutes);
-  for (const shadow of findShadowedRoutes(routeMap, config.rawRoutes)) {
-    const gate = shadow.scope && shadow.scope !== "public" ? ` (scope "${shadow.scope}")` : "";
-    const line = `[stitchkit] raw route ${shadow.rawRoute} shadows contract route ${shadow.pattern}` + ` → ${shadow.endpoint}${gate} will never run, and its hooks never apply`;
-    warn(line);
+  return 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 ?? "")}`);
   }
-  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 log;
+}
+function structuredLine(own, extra) {
+  try {
+    return JSON.stringify({ ...extra, ...own });
+  } catch {
+    return JSON.stringify(own);
+  }
+}
+function logOutgoing(entry) {
+  const { req, pathname, status, log, ipAddress, errorCode: errorCode2, durationMs, format, extra } = entry;
+  const ms = durationMs;
+  if (format === "json") {
+    const own = {
+      ts: new Date().toISOString(),
+      level: levelForStatus(status),
+      msg: `${req.method} ${pathname} ${status}`,
+      ...buildLogFields(req.method, pathname, status, durationMs, log.traceId, errorCode2),
+      ip: ipAddress
+    };
+    console.log(structuredLine(own, extra));
+    return;
+  }
+  const mc = METHOD_COLOR[req.method] ?? c.dim;
+  const code = errorCode2 ? ` ${c.red}${errorCode2}${c.reset}` : "";
+  console.log(`${c.gray}[${timestamp()}]${c.reset} ${mc}${req.method}${c.reset} ${c.dim}${log.traceId}${c.reset} ${c.cyan}←${c.reset} ${safePath(pathname)} ${statusColor(status)}${status}${c.reset}${code} ${durationColor(ms)}${formatMs(ms)}${c.reset} ${ipLabel(ipAddress ?? "")}`);
+}
+
+// src/server/request-completion.ts
+var BODY_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+function openRequestCompletion(state, window) {
+  const { logConfig, customLogger, useDefaultLog, observability } = state;
+  const { req, url, traceId, startedAt, ipAddress } = window;
+  const shouldLogRequest = logConfig !== null && shouldLog(url.pathname, req.method) && !shouldSkipLog(logConfig, req, url);
+  const payload = observability?.includePayload && BODY_METHODS.has(req.method) ? req.clone().json().catch(() => {
+    return;
+  }) : undefined;
+  const logFormat = resolveLogFormat(logConfig?.format);
+  let reqLog;
+  if (shouldLogRequest && useDefaultLog) {
+    reqLog = logIncoming(req, url.pathname, traceId, logFormat, ipAddress);
+  }
+  if (shouldLogRequest && customLogger) {
+    reqLog = { traceId };
+    try {
+      customLogger.debug(`${req.method} ${url.pathname}`, {
+        traceId,
+        method: req.method,
+        path: url.pathname,
+        ip: ipAddress
+      });
+    } catch {}
+  }
+  let completed = false;
+  return (status, errorCode2, outcome) => {
+    if (completed)
       return;
-    }) : undefined;
-    const logFormat = resolveLogFormat(logConfig?.format);
-    let reqLog;
-    if (shouldLogRequest && useDefaultLog) {
-      reqLog = logIncoming(req, url.pathname, traceId, logFormat, ipAddress);
-    }
-    if (shouldLogRequest && customLogger) {
-      reqLog = { traceId };
+    completed = true;
+    const durationMs = Math.round(Number(process.hrtime.bigint() - startedAt) / 1e6);
+    if (reqLog && logConfig) {
       try {
-        customLogger.debug(`${req.method} ${url.pathname}`, {
-          traceId,
-          method: req.method,
-          path: url.pathname,
-          ip: ipAddress
+        writeCompletionLine(state, logConfig, window, {
+          reqLog,
+          status,
+          durationMs,
+          errorCode: errorCode2,
+          logFormat
         });
       } 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 context = getRequestContext();
+    if (observability && context) {
+      try {
+        observability.complete({
+          context,
+          statusCode: status,
+          durationMs,
+          payload,
+          ...outcome !== undefined && { outcome }
         });
-      };
-      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);
+      } catch {}
     }
+  };
+}
+function writeCompletionLine(state, logConfig, window, line) {
+  const { customLogger, useDefaultLog, warnedEnrichKeys, warn } = state;
+  const { req, url, ipAddress } = window;
+  const { reqLog, status, durationMs, errorCode: errorCode2, logFormat } = line;
+  const collected = collectExtraLogFields(logConfig, req, url, {
+    status,
+    durationMs,
+    errorCode: errorCode2
+  });
+  const frameworkFields = buildLogFields(req.method, url.pathname, status, durationMs, reqLog.traceId, errorCode2);
+  const ownedFields = { ...frameworkFields, ip: ipAddress };
+  for (const key of collected.enrichKeys) {
+    const ownedByActiveSink = Object.hasOwn(ownedFields, key) || useDefaultLog && (key === "ts" || key === "level" || key === "msg");
+    if (ownedByActiveSink && !warnedEnrichKeys.has(key)) {
+      warnedEnrichKeys.add(key);
+      warn(`[stitchkit] logging.enrich field "${key}" was discarded because the framework owns it`);
+    }
+  }
+  const extra = collected.fields;
+  if (useDefaultLog) {
+    logOutgoing({
+      req,
+      pathname: url.pathname,
+      status,
+      log: reqLog,
+      ipAddress,
+      errorCode: errorCode2,
+      durationMs,
+      format: logFormat,
+      extra
+    });
   }
+  if (customLogger) {
+    const level = levelForStatus(status);
+    customLogger[level](`${req.method} ${url.pathname} ${status}${errorCode2 ? ` ${errorCode2}` : ""} ${durationMs}ms`, {
+      ...extra,
+      ...frameworkFields,
+      ip: ipAddress
+    });
+  }
+}
+
+// src/server/create.ts
+function createHandler(config) {
+  const { trustProxy = false, observability } = config;
+  const state = createHandlerState(config);
   return async (req, server) => {
     const url = new URL(req.url, "http://localhost");
     const requestStartedAt = process.hrtime.bigint();
@@ -1896,7 +1949,7 @@ function createHandler(config) {
       socketIp: resolveSocketIp(req, server)
     };
     const run = async (traceId2, startedAt) => {
-      const response = await dispatch(req, url, traceId2, server, clientIp, startedAt);
+      const response = await dispatch(state, req, url, traceId2, server, clientIp, startedAt);
       try {
         response.headers.set("x-request-id", traceId2);
         const buildId = config.release?.current();
@@ -1910,9 +1963,9 @@ function createHandler(config) {
       return run(activeContext.trace.traceId, activeContext.startedAt);
     }
     if (!observability)
-      return run(resolveId(req), requestStartedAt);
+      return run(state.resolveId(req), requestStartedAt);
     const trace = resolveTraceContext(req);
-    const traceId = resolveId(req, trace.traceId);
+    const traceId = state.resolveId(req, trace.traceId);
     const ipAddress = extractIp(req, clientIp) || undefined;
     const userAgent = req.headers.get("user-agent") ?? undefined;
     return runWithRequestContext({
@@ -1926,63 +1979,69 @@ function createHandler(config) {
     }, () => 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 });
-    }
+async function dispatch(state, req, url, traceId, server, clientIp, startedAt) {
+  const { cors, hooks, config, routeMap } = state;
+  const ipAddress = extractIp(req, clientIp) || undefined;
+  const complete = openRequestCompletion(state, { req, url, traceId, startedAt, ipAddress });
+  const respondError = createErrorResponder(state, { req, url, traceId, clientIp, complete });
+  const request = {
+    req,
+    url,
+    traceId,
+    server,
+    clientIp,
+    ipAddress,
+    complete,
+    respondError
+  };
+  if (cors && req.method === "OPTIONS") {
+    const response = corsPreflightResponse(cors, req);
+    complete(response.status);
+    return response;
   }
-  if (config.groups) {
-    for (const group of config.groups) {
-      for (const service of group.services) {
-        result.push({ prefix: group.pathPrefix ?? "", service, hooks: group.hooks });
+  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);
   }
-  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;
+  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 existing = headers.get("Vary");
-  if (existing === null || existing.trim() === "") {
-    headers.set("Vary", value);
-    return;
+  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 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) });
+  return dispatchEndpoint(state, request, match);
 }
 
 // src/server/process-signals.ts
@@ -3002,7 +3061,7 @@ function createUnixClientTransport(config) {
   const activeResponses = new Set;
   const bunAborters = new Set;
   let closed = false;
-  const dispatch = async (request, redirectCount) => {
+  const dispatch2 = async (request, redirectCount) => {
     if (closed) {
       throw new UnixClientTransportError("UNIX_CLIENT_CLOSED", "Unix client transport is closed", "not-dispatched");
     }
@@ -3037,7 +3096,7 @@ function createUnixClientTransport(config) {
         }
         if (request.redirect === "follow") {
           await response.body?.cancel();
-          return dispatch(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
+          return dispatch2(redirectedRequest(request, location2, response.status, body), redirectCount + 1);
         }
       }
       return response;
@@ -3123,7 +3182,7 @@ function createUnixClientTransport(config) {
       if (request.redirect === "follow") {
         incoming.destroy();
         releaseResponse();
-        return dispatch(redirectedRequest(request, location, status, body), redirectCount + 1);
+        return dispatch2(redirectedRequest(request, location, status, body), redirectCount + 1);
       }
     }
     const bodyless = request.method === "HEAD" || status === 204 || status === 205 || status === 304;
@@ -3144,7 +3203,7 @@ function createUnixClientTransport(config) {
   };
   return {
     fetch(input, init) {
-      return dispatch(new Request(input, init), 0);
+      return dispatch2(new Request(input, init), 0);
     },
     get closed() {
       return closed;