stitchkit 0.48.0 → 0.49.0

package/dist/{index-44xysy8r.js → index-fjfzsq6y.js}

@@ -5,31 +5,33 @@ import {
 } from "./index-r1qp4rve.js";
 import {
   AppError,
-  __require,
   badRequest,
-  callRuntimeHandler,
   errorCode,
   extractIp,
   getClientInfo,
   getRequestContext,
-  isRecord,
   isUnsafeKey,
   mergeMeta,
   normalizeError,
   parseQueryParams,
-  parseTrailingWildcard,
   recordedErrorMessage,
   resolveSocketIp,
-  resolveTraceContext,
   resolveTraceId,
   runWithRequestContext,
   safeJsonParse,
   setRequestEndpoint,
   setRequestError,
-  typedEntries,
   validateDeclaredOutput,
   zodIssues
-} from "./index-ee621cmy.js";
+} from "./index-jewp9r0a.js";
+import {
+  __require,
+  callRuntimeHandler,
+  isRecord,
+  parseTrailingWildcard,
+  resolveTraceContext,
+  typedEntries
+} from "./index-h05ygjqx.js";
 
 // src/server/multipart.ts
 var DEFAULT_MAX_REQUEST_BYTES = 25 * 1024 * 1024;
@@ -803,6 +805,50 @@ function joinPath(...parts) {
   const joined = parts.filter(Boolean).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
   return `/${joined}`;
 }
+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;
@@ -844,7 +890,7 @@ function buildRouteMap(groups) {
         continue;
       const servicePath = joinPath("/", service.prefix, method.path === "/" ? "" : method.path);
       const fullPath = prefix ? joinPath(prefix, servicePath) : servicePath;
-      const segments = fullPath.split("/").filter(Boolean);
+      const segments = routeSegments(fullPath);
       const entries = map.get(method.method) ?? [];
       entries.push({ method, pattern: fullPath, segments, groupHooks: hooks });
       map.set(method.method, entries);
@@ -867,7 +913,7 @@ function matchRoute(routeMap, httpMethod, pathname) {
   const entries = routeMap.get(httpMethod);
   if (!entries)
     return null;
-  const requestSegments = pathname.split("/").filter(Boolean);
+  const requestSegments = routeSegments(pathname);
   for (const entry of entries) {
     const pathParams = matchSegments(entry.segments, requestSegments);
     if (pathParams) {
@@ -881,7 +927,7 @@ function matchRoute(routeMap, httpMethod, pathname) {
   return null;
 }
 function allowedMethods(routeMap, pathname) {
-  const requestSegments = pathname.split("/").filter(Boolean);
+  const requestSegments = routeSegments(pathname);
   const methods = [];
   for (const [method, entries] of routeMap) {
     for (const entry of entries) {
@@ -939,16 +985,16 @@ function matchRawRoute(rawRoutes, httpMethod, pathname) {
     if (route.method !== "ALL" && route.method !== httpMethod)
       continue;
     if (parseTrailingWildcard(route.path)) {
-      const routeSegs = route.path.split("/").filter(Boolean);
-      const pathSegs = pathname.split("/").filter(Boolean);
+      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 = route.path.split("/").filter(Boolean);
-      const pathSegs = pathname.split("/").filter(Boolean);
+      const routeSegs = routeSegments(route.path);
+      const pathSegs = routeSegments(pathname);
       const params = matchSegments(routeSegs, pathSegs);
       if (params)
         return { route, params };
@@ -960,8 +1006,37 @@ function matchRawRoute(rawRoutes, httpMethod, pathname) {
   return null;
 }
 function validateRawRoutes(rawRoutes) {
-  for (const route of rawRoutes ?? [])
-    parseTrailingWildcard(route.path);
+  const routes = rawRoutes ?? [];
+  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
@@ -1322,6 +1397,193 @@ function json(data, status, cors, req) {
   return Response.json(data, { status, headers: corsHeaders2(cors, req) });
 }
 
+// src/server/shutdown.ts
+import { z } from "zod";
+var ShutdownStateSchema = z.enum([
+  "running",
+  "draining-http",
+  "closing-realtime",
+  "stopping-runtime",
+  "clean",
+  "forced"
+]);
+var ShutdownOptionsSchema = z.object({
+  gracePeriodMs: z.number().int().nonnegative().default(30000),
+  retryAfterSeconds: z.number().int().nonnegative().default(5),
+  signal: z.custom((value) => typeof value === "object" && value !== null && ("aborted" in value) && ("addEventListener" in value), "Expected an AbortSignal").optional()
+});
+var ShutdownStatusSchema = z.object({
+  state: ShutdownStateSchema,
+  acceptedRequests: z.number().int().nonnegative(),
+  completedRequests: z.number().int().nonnegative(),
+  pendingRequests: z.number().int().nonnegative(),
+  pendingWebSockets: z.number().int().nonnegative()
+});
+var ShutdownResultSchema = z.object({
+  outcome: z.enum(["clean", "forced"]),
+  reason: z.enum(["deadline", "signal"]).optional(),
+  acceptedRequests: z.number().int().nonnegative(),
+  completedRequests: z.number().int().nonnegative(),
+  pendingRequests: z.number().int().nonnegative(),
+  pendingWebSockets: z.number().int().nonnegative(),
+  pendingRequestsAtForce: z.number().int().nonnegative(),
+  pendingWebSocketsAtForce: z.number().int().nonnegative(),
+  abortedRequests: z.number().int().nonnegative(),
+  forcedWebSockets: z.number().int().nonnegative(),
+  durationMs: z.number().nonnegative()
+});
+function rejectedResponse(retryAfterSeconds) {
+  return Response.json({ error: { code: "SERVER_SHUTTING_DOWN", message: "Server is shutting down" } }, {
+    status: 503,
+    headers: {
+      Connection: "close",
+      "Retry-After": String(retryAfterSeconds)
+    }
+  });
+}
+function waitForZero(read, signal) {
+  if (read() === 0)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    const check = () => {
+      if (read() === 0 || signal.aborted) {
+        clearInterval(timer);
+        signal.removeEventListener("abort", check);
+        resolve();
+      }
+    };
+    const timer = setInterval(check, 5);
+    signal.addEventListener("abort", check, { once: true });
+  });
+}
+function untilAbort(signal) {
+  if (signal.aborted)
+    return Promise.resolve();
+  return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+}
+function createServerLifecycle(getAdapter) {
+  let state = "running";
+  let acceptedRequests = 0;
+  let completedRequests = 0;
+  let pendingApplicationRequests = 0;
+  let retryAfterSeconds = 5;
+  let shutdownPromise;
+  const status = () => {
+    const adapter = getAdapter();
+    return ShutdownStatusSchema.parse({
+      state,
+      acceptedRequests,
+      completedRequests,
+      pendingRequests: adapter.pendingRequests(),
+      pendingWebSockets: adapter.pendingWebSockets()
+    });
+  };
+  const wrapFetch = (handler) => {
+    return async (request, server) => {
+      if (state !== "running")
+        return rejectedResponse(retryAfterSeconds);
+      acceptedRequests += 1;
+      pendingApplicationRequests += 1;
+      try {
+        return await handler(request, server);
+      } finally {
+        pendingApplicationRequests -= 1;
+        completedRequests += 1;
+      }
+    };
+  };
+  const shutdown = (options) => {
+    if (shutdownPromise)
+      return shutdownPromise;
+    const parsed = ShutdownOptionsSchema.parse(options ?? {});
+    retryAfterSeconds = parsed.retryAfterSeconds;
+    const startedAt = performance.now();
+    const adapter = getAdapter();
+    state = "draining-http";
+    adapter.beginShutdown(retryAfterSeconds);
+    shutdownPromise = new Promise((resolve, reject) => {
+      const phaseAbort = new AbortController;
+      let forcedReason;
+      const force = (reason) => {
+        if (forcedReason)
+          return;
+        forcedReason = reason;
+        phaseAbort.abort();
+      };
+      const timer = setTimeout(() => force("deadline"), parsed.gracePeriodMs);
+      const onExternalAbort = () => force("signal");
+      parsed.signal?.addEventListener("abort", onExternalAbort, { once: true });
+      if (parsed.signal?.aborted)
+        force("signal");
+      const cleanup = () => {
+        clearTimeout(timer);
+        parsed.signal?.removeEventListener("abort", onExternalAbort);
+      };
+      (async () => {
+        await waitForZero(() => pendingApplicationRequests, phaseAbort.signal);
+        if (!forcedReason) {
+          state = "closing-realtime";
+          const closeRealtime = adapter.closeRealtime();
+          await Promise.race([
+            closeRealtime.catch((error) => {
+              if (!forcedReason)
+                throw error;
+            }),
+            untilAbort(phaseAbort.signal)
+          ]);
+        }
+        if (!forcedReason) {
+          state = "stopping-runtime";
+          const stopGracefully = adapter.stopGracefully();
+          await Promise.race([
+            stopGracefully.catch((error) => {
+              if (!forcedReason)
+                throw error;
+            }),
+            untilAbort(phaseAbort.signal)
+          ]);
+        }
+        let pendingRequestsAtForce = 0;
+        let pendingWebSocketsAtForce = 0;
+        if (forcedReason) {
+          state = "stopping-runtime";
+          pendingRequestsAtForce = adapter.pendingRequests();
+          pendingWebSocketsAtForce = adapter.pendingWebSockets();
+          await adapter.forceStop();
+          state = "forced";
+        } else {
+          state = "clean";
+        }
+        cleanup();
+        resolve(ShutdownResultSchema.parse({
+          outcome: forcedReason ? "forced" : "clean",
+          ...forcedReason && { reason: forcedReason },
+          acceptedRequests,
+          completedRequests,
+          pendingRequests: adapter.pendingRequests(),
+          pendingWebSockets: adapter.pendingWebSockets(),
+          pendingRequestsAtForce,
+          pendingWebSocketsAtForce,
+          abortedRequests: pendingRequestsAtForce,
+          forcedWebSockets: pendingWebSocketsAtForce,
+          durationMs: performance.now() - startedAt
+        }));
+      })().catch((error) => {
+        cleanup();
+        reject(error);
+      });
+    });
+    return shutdownPromise;
+  };
+  return {
+    wrapFetch,
+    get status() {
+      return status();
+    },
+    shutdown
+  };
+}
+
 // src/server/implement.ts
 function isStreamingImplementation(value) {
   return typeof value === "object" && value !== null && "kind" in value && value.kind === "stitchkit.multipart.stream";
@@ -1345,11 +1607,11 @@ function defineMultipartStream(endpoint, config) {
   };
 }
 var HTTP_ONLY = Object.freeze(["HTTP"]);
-function implement(contract, handlers) {
+function bindContract(contract, handlers) {
   const methods = {};
   const groupScope = contract.meta.scope ?? "public";
   for (const [key, endpoint] of typedEntries(contract.endpoints)) {
-    const typedHandler = handlers[key];
+    const typedHandler = handlers[String(key)];
     const isStreaming = endpoint.multipart?.delivery === "stream";
     if (!isStreaming && typeof typedHandler !== "function") {
       throw new Error(`[stitchkit] implement: missing handler for "${contract.meta.prefix}.${String(key)}"`);
@@ -1398,14 +1660,61 @@ function implement(contract, handlers) {
     methods
   };
 }
+function implement(contract, handlers) {
+  return bindContract(contract, handlers);
+}
 function createImplement() {
   return (contract, handlers) => implement(contract, handlers);
 }
+function isImplementationContract(value) {
+  return isRecord(value) && isRecord(value.meta) && typeof value.meta.prefix === "string" && isRecord(value.endpoints);
+}
+function bindRegistry(contracts, handlers) {
+  const contractKeys = Object.keys(contracts);
+  const handlerKeys = Object.keys(handlers);
+  const missing = contractKeys.filter((key) => !Object.hasOwn(handlers, key));
+  const extra = handlerKeys.filter((key) => !Object.hasOwn(contracts, key));
+  if (missing.length > 0 || extra.length > 0) {
+    throw new Error(`[stitchkit] implementRegistry: registry mismatch (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"})`);
+  }
+  const prefixes = new Map;
+  const services = [];
+  for (const [key, candidate] of Object.entries(contracts)) {
+    if (!isImplementationContract(candidate)) {
+      throw new TypeError(`[stitchkit] implementRegistry: registry entry "${key}" must be one contract; composed arrays and namespaces are not supported`);
+    }
+    const contract = candidate;
+    const previousKey = prefixes.get(contract.meta.prefix);
+    if (previousKey !== undefined) {
+      throw new Error(`[stitchkit] implementRegistry: duplicate contract prefix "${contract.meta.prefix}" at "${previousKey}" and "${key}"`);
+    }
+    prefixes.set(contract.meta.prefix, key);
+    const entryHandlers = handlers[key];
+    if (!isRecord(entryHandlers)) {
+      throw new TypeError(`[stitchkit] implementRegistry: handlers for "${key}" must be an object`);
+    }
+    const endpointKeys = Object.keys(contract.endpoints);
+    const handlerEntryKeys = Object.keys(entryHandlers);
+    const missingEndpoints = endpointKeys.filter((endpointKey) => !Object.hasOwn(entryHandlers, endpointKey));
+    const extraEndpoints = handlerEntryKeys.filter((endpointKey) => !Object.hasOwn(contract.endpoints, endpointKey));
+    if (missingEndpoints.length > 0 || extraEndpoints.length > 0) {
+      throw new Error(`[stitchkit] implementRegistry: handlers for "${key}" mismatch (missing: ${missingEndpoints.join(", ") || "none"}; extra: ${extraEndpoints.join(", ") || "none"})`);
+    }
+    services.push(bindContract(contract, entryHandlers));
+  }
+  return services;
+}
+function implementRegistry(contracts, handlers) {
+  return bindRegistry(contracts, handlers);
+}
+function createImplementRegistry() {
+  return (contracts, handlers) => bindRegistry(contracts, handlers);
+}
 
 // src/realtime/rejection.ts
-import { z } from "zod";
+import { z as z2 } from "zod";
 function realtimeContractViolation(options) {
-  const issues = options.cause instanceof z.ZodError ? zodIssues(options.cause) : undefined;
+  const issues = options.cause instanceof z2.ZodError ? zodIssues(options.cause) : undefined;
   const reason = options.reason.replaceAll("-", " ");
   const error = new AppError("REALTIME_CONTRACT_VIOLATION", `Realtime event "${options.event}" (${options.direction}, ${options.phase}): ${reason}`, 500, {
     event: options.event,
@@ -1710,6 +2019,34 @@ async function createSocketIOServer(config) {
     credentials: config.cors.credentials ?? true,
     methods: ["GET", "POST"]
   };
+  let accepting = true;
+  let attached = false;
+  let closePromise;
+  const consumerAllowRequest = config.allowRequest;
+  const checkRequest = async (request) => {
+    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 { Server } = await importPeer(() => import("socket.io"), "socket.io");
   const io = new Server({
     ...config.serverOptions,
@@ -1717,15 +2054,31 @@ async function createSocketIOServer(config) {
     cors,
     transports,
     pingTimeout,
-    pingInterval
+    pingInterval,
+    allowRequest
   });
+  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 { Server: Engine } = await importPeer(() => import("@socket.io/bun-engine"), "@socket.io/bun-engine");
     const engineOpts = {
       path,
       cors,
       pingTimeout,
-      pingInterval
+      pingInterval,
+      allowRequest: checkRequest
     };
     if (config.serverOptions?.maxHttpBufferSize !== undefined) {
       engineOpts.maxHttpBufferSize = config.serverOptions.maxHttpBufferSize;
@@ -1746,11 +2099,14 @@ async function createSocketIOServer(config) {
         return engine.handleRequest(req, ctx.server);
       }
     };
-    return { io, websocket, route, attach: noop };
+    return { io, websocket, route, attach: noop, ...lifecycle };
   }
   return {
     io,
-    attach: (server) => io.attach(server),
+    attach: (server) => {
+      io.attach(server);
+      attached = true;
+    },
     websocket: { open: noop, message: noop, close: noop, maxPayloadLength: 0 },
     route: {
       method: "ALL",
@@ -1758,7 +2114,8 @@ async function createSocketIOServer(config) {
       handler: () => {
         throw new Error("[stitchkit] On Node, Socket.IO attaches via serveNode({ socket }) — this route is not mounted.");
       }
-    }
+    },
+    ...lifecycle
   };
 }
 function socketIoLane(websocket) {
@@ -1768,4 +2125,4 @@ function socketIoLane(websocket) {
   });
 }
 
-export { parseMultipart, createHandler, defineMultipartStream, implement, createImplement, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };
+export { parseMultipart, createHandler, ShutdownStateSchema, ShutdownOptionsSchema, ShutdownStatusSchema, ShutdownResultSchema, createServerLifecycle, defineMultipartStream, implement, createImplement, implementRegistry, createImplementRegistry, bindRealtimeServer, webSocketLane, composeWebSocketHandlers, createSocketIOServer, socketIoLane };

package/dist/index-h05ygjqx.js

@@ -0,0 +1,149 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/observability/trace.ts
+var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  let hex = "";
+  for (const byte of arr)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function createTraceContext() {
+  return { traceId: randomHex(16), spanId: randomHex(8) };
+}
+function parseTraceparent(header) {
+  if (!header)
+    return null;
+  const match = TRACEPARENT_RE.exec(header.trim());
+  if (!match?.[1] || !match[2] || !match[3] || !match[4] || match[5] === undefined)
+    return null;
+  const version = match[1].toLowerCase();
+  if (version === "ff")
+    return null;
+  const suffix = match[5];
+  if (version === "00" ? suffix !== "" : suffix !== "" && !/^(?:-[0-9a-f]{2,})+$/i.test(suffix)) {
+    return null;
+  }
+  const traceId = match[2].toLowerCase();
+  const parentSpanId = match[3].toLowerCase();
+  const traceFlags = match[4].toLowerCase();
+  if (/^0+$/.test(traceId) || /^0+$/.test(parentSpanId))
+    return null;
+  return { traceId, spanId: randomHex(8), parentSpanId, traceFlags };
+}
+function formatTraceparent(ctx) {
+  return `00-${ctx.traceId}-${ctx.spanId}-${ctx.traceFlags ?? "01"}`;
+}
+function resolveTraceContext(req) {
+  return parseTraceparent(req.headers.get("traceparent")) ?? createTraceContext();
+}
+function childSpan(parent) {
+  return {
+    traceId: parent.traceId,
+    spanId: randomHex(8),
+    parentSpanId: parent.spanId,
+    ...parent.tracestate !== undefined && { tracestate: parent.tracestate },
+    ...parent.baggage !== undefined && { baggage: parent.baggage },
+    ...parent.traceFlags !== undefined && { traceFlags: parent.traceFlags }
+  };
+}
+var encoder = new TextEncoder;
+function boundedPropagationValue(value, maxBytes, maxMembers) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  if (!trimmed || encoder.encode(trimmed).byteLength > maxBytes)
+    return;
+  for (const character of trimmed) {
+    const code = character.charCodeAt(0);
+    if (code <= 31 || code === 127)
+      return;
+  }
+  const members = trimmed.split(",");
+  if (members.length > maxMembers || members.some((member) => !member.trim())) {
+    return;
+  }
+  return trimmed;
+}
+function resolvePropagationContext(metadata, fallback) {
+  const traceparent = metadata?.traceparent;
+  const parsed = typeof traceparent === "string" ? parseTraceparent(traceparent) : null;
+  const trace = traceparent === undefined ? fallback ?? createTraceContext() : parsed ?? createTraceContext();
+  const tracestate = parsed ? boundedPropagationValue(metadata?.tracestate, 512, 32) : undefined;
+  const baggage = boundedPropagationValue(metadata?.baggage, 8192, 180);
+  return {
+    ...trace,
+    ...tracestate !== undefined && { tracestate },
+    ...baggage !== undefined && { baggage }
+  };
+}
+
+// src/internal/route-pattern.ts
+var PARAM_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function parseTrailingWildcard(path) {
+  const segments = path.split("/").filter(Boolean);
+  const paramNames = new Set;
+  let wildcard = null;
+  for (const [segmentIndex, segment] of segments.entries()) {
+    if (segment.startsWith(":")) {
+      const name2 = segment.slice(1);
+      if (!PARAM_IDENTIFIER.test(name2)) {
+        throw new Error(`Invalid route parameter name "${name2}" in path "${path}"`);
+      }
+      if (paramNames.has(name2)) {
+        throw new Error(`Duplicate route parameter name "${name2}" in path "${path}"`);
+      }
+      paramNames.add(name2);
+      continue;
+    }
+    if (!segment.startsWith("*")) {
+      if (segment.includes("*")) {
+        throw new Error(`Wildcard must occupy its own segment in path "${path}"`);
+      }
+      continue;
+    }
+    const name = segment.slice(1);
+    if (!PARAM_IDENTIFIER.test(name)) {
+      throw new Error(`Trailing wildcard in path "${path}" must be named, for example "/*filePath"`);
+    }
+    if (segmentIndex !== segments.length - 1) {
+      throw new Error(`Wildcard "*${name}" must be the final segment in path "${path}"`);
+    }
+    if (wildcard) {
+      throw new Error(`Path "${path}" contains more than one wildcard`);
+    }
+    if (paramNames.has(name)) {
+      throw new Error(`Duplicate route parameter name "${name}" in path "${path}"`);
+    }
+    wildcard = { name, segmentIndex };
+  }
+  return wildcard;
+}
+
+// src/internal/typed.ts
+function typedEntries(value) {
+  return Object.entries(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function callRuntimeHandler(handler, context) {
+  if (typeof handler !== "function") {
+    throw new TypeError("Runtime handler must be a function");
+  }
+  return Reflect.apply(handler, undefined, [context]);
+}
+function mapObject(source, mapper) {
+  const result = {};
+  for (const [key, value] of typedEntries(source)) {
+    const mapped = mapper(key, value);
+    if (mapped !== undefined)
+      result[key] = mapped;
+  }
+  return result;
+}
+
+export { __require, parseTrailingWildcard, typedEntries, isRecord, callRuntimeHandler, mapObject, createTraceContext, parseTraceparent, formatTraceparent, resolveTraceContext, childSpan, resolvePropagationContext };