stitchkit 0.1.0 → 0.2.0

package/dist/index-v2z2v3mq.js

@@ -0,0 +1,587 @@
+import {
+  normalizeError
+} from "./index-a35v22fh.js";
+import {
+  AppError,
+  badRequest
+} from "./index-kckky6zw.js";
+import {
+  extractIp,
+  getClientInfo,
+  parseQueryParams,
+  resolveTraceId
+} from "./index-ke4mx4ea.js";
+
+// src/server/multipart.ts
+var DEFAULT_MAX_UPLOAD_BYTES = 25 * 1024 * 1024;
+async function parseMultipart(req, fileField, fieldsSchema, maxBytes = DEFAULT_MAX_UPLOAD_BYTES) {
+  const declared = Number(req.headers.get("content-length") ?? 0);
+  if (declared > maxBytes) {
+    badRequest(`Upload exceeds the ${Math.round(maxBytes / 1024 / 1024)} MB limit`);
+  }
+  const formData = await req.formData();
+  const file = formData.get(fileField);
+  if (!file || !(file instanceof File)) {
+    badRequest(`Missing file field: ${fileField}`);
+  }
+  if (file.size > maxBytes) {
+    badRequest(`Upload exceeds the ${Math.round(maxBytes / 1024 / 1024)} MB limit`);
+  }
+  const fields = {};
+  for (const [key, value] of formData.entries()) {
+    if (key === fileField)
+      continue;
+    if (typeof value === "string") {
+      try {
+        fields[key] = JSON.parse(value);
+      } catch {
+        fields[key] = value;
+      }
+    }
+  }
+  const parsed = fieldsSchema ? fieldsSchema.parse(fields) : fields;
+  return { file, fields: parsed };
+}
+
+// src/server/middleware/cors.ts
+function corsHeaders(config, requestOrigin) {
+  let allowOrigin;
+  if (config.origin === undefined || config.origin === "*") {
+    allowOrigin = config.credentials ? requestOrigin ?? undefined : "*";
+  } else if (Array.isArray(config.origin)) {
+    allowOrigin = requestOrigin && config.origin.includes(requestOrigin) ? requestOrigin : undefined;
+  } else {
+    allowOrigin = config.origin;
+  }
+  const headers = {
+    "Access-Control-Allow-Methods": config.methods ?? "GET, POST, PUT, PATCH, DELETE, OPTIONS",
+    "Access-Control-Allow-Headers": config.headers ?? "Content-Type, Authorization, X-Trace-Id"
+  };
+  if (allowOrigin !== undefined) {
+    headers["Access-Control-Allow-Origin"] = allowOrigin;
+  }
+  if (config.credentials) {
+    headers["Access-Control-Allow-Credentials"] = "true";
+  }
+  const variesByOrigin = Array.isArray(config.origin) || (config.origin === undefined || config.origin === "*") && Boolean(config.credentials);
+  if (variesByOrigin) {
+    headers.Vary = "Origin";
+  }
+  return headers;
+}
+function corsPreflightResponse(config, req) {
+  return new Response(null, {
+    status: 204,
+    headers: corsHeaders(config, req.headers.get("origin"))
+  });
+}
+
+// src/server/router.ts
+import { resolve, sep } from "node:path";
+function joinPath(...parts) {
+  const joined = parts.filter(Boolean).map((part) => part.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return `/${joined}`;
+}
+function matchSegments(patternSegments, requestSegments) {
+  if (patternSegments.length !== requestSegments.length)
+    return null;
+  const params = {};
+  for (const [i, pattern] of patternSegments.entries()) {
+    const actual = requestSegments[i];
+    if (actual === undefined)
+      return null;
+    if (pattern.startsWith(":")) {
+      params[pattern.slice(1)] = decodeURIComponent(actual);
+    } else if (pattern !== actual) {
+      return null;
+    }
+  }
+  return params;
+}
+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 = joinPath("/", service.prefix, method.path === "/" ? "" : method.path);
+      const fullPath = prefix ? joinPath(prefix, servicePath) : servicePath;
+      const segments = fullPath.split("/").filter(Boolean);
+      const entries = map.get(method.method) ?? [];
+      entries.push({ method, service, 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 aIsParam = a.segments[i]?.startsWith(":");
+        const bIsParam = b.segments[i]?.startsWith(":");
+        if (aIsParam !== bIsParam)
+          return aIsParam ? 1 : -1;
+      }
+      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 = pathname.split("/").filter(Boolean);
+  for (const entry of entries) {
+    const pathParams = matchSegments(entry.segments, requestSegments);
+    if (pathParams) {
+      return {
+        method: entry.method,
+        service: entry.service,
+        pathParams,
+        groupHooks: entry.groupHooks
+      };
+    }
+  }
+  return null;
+}
+function allowedMethods(routeMap, pathname) {
+  const requestSegments = pathname.split("/").filter(Boolean);
+  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) {
+      const normalized = entry.segments.map((s) => s.startsWith(":") ? ":param" : 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 matchRawRoute(rawRoutes, httpMethod, pathname) {
+  for (const route of rawRoutes) {
+    if (route.method !== "ALL" && route.method !== httpMethod)
+      continue;
+    if (route.path.endsWith("/*")) {
+      const prefix = route.path.slice(0, -2);
+      if (pathname === prefix || pathname.startsWith(`${prefix}/`)) {
+        return { route, params: {} };
+      }
+      continue;
+    }
+    if (route.path.includes("/:")) {
+      const routeSegs = route.path.split("/").filter(Boolean);
+      const pathSegs = pathname.split("/").filter(Boolean);
+      const params = matchSegments(routeSegs, pathSegs);
+      if (params)
+        return { route, params };
+      continue;
+    }
+    if (route.path === pathname)
+      return { route, params: {} };
+  }
+  return null;
+}
+function staticRoute(prefix, dir) {
+  const cleanPrefix = prefix.replace(/\/+$/, "");
+  const cleanDir = dir.replace(/\/+$/, "");
+  return {
+    method: "GET",
+    path: `${cleanPrefix}/*`,
+    handler: async (req) => {
+      const pathname = new URL(req.url).pathname;
+      const rel = pathname.slice(cleanPrefix.length).replace(/^\/+/, "");
+      const root = resolve(cleanDir);
+      const target = resolve(root, rel);
+      if (target !== root && !target.startsWith(root + sep)) {
+        return new Response("Forbidden", { status: 403 });
+      }
+      const file = Bun.file(target);
+      if (!await file.exists()) {
+        return new Response("Not found", { status: 404 });
+      }
+      return new Response(file);
+    }
+  };
+}
+
+// src/server/context.ts
+var RESERVED_KEYS = new Set([
+  "params",
+  "input",
+  "source",
+  "req",
+  "url",
+  "headers",
+  "traceId",
+  "spanId",
+  "ipAddress",
+  "userAgent"
+]);
+async function readJsonBody(req) {
+  const text = await req.text();
+  if (text.trim() === "")
+    return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    badRequest("Invalid JSON body");
+  }
+}
+async function buildContext(req, url, method, pathParams, traceId) {
+  const parsedParams = method.paramsSchema ? method.paramsSchema.parse(pathParams) : undefined;
+  let parsedInput;
+  let file;
+  if (method.multipart) {
+    const multipart = await parseMultipart(req, method.multipart, method.inputSchema);
+    parsedInput = multipart.fields;
+    file = multipart.file;
+  } else if (method.inputSchema) {
+    if (req.method === "GET") {
+      parsedInput = method.inputSchema.parse(parseQueryParams(url));
+    } else if (req.method === "DELETE") {
+      const ct = req.headers.get("content-type");
+      if (ct?.includes("application/json")) {
+        parsedInput = method.inputSchema.parse(await readJsonBody(req));
+      } else {
+        parsedInput = method.inputSchema.parse(parseQueryParams(url));
+      }
+    } else {
+      parsedInput = method.inputSchema.parse(await readJsonBody(req));
+    }
+  }
+  const safePathParams = {};
+  for (const [k, v] of Object.entries(pathParams)) {
+    if (!RESERVED_KEYS.has(k))
+      safePathParams[k] = v;
+  }
+  return {
+    params: parsedParams,
+    input: parsedInput,
+    ...file && { file },
+    source: "http",
+    req,
+    url,
+    headers: req.headers,
+    ...safePathParams,
+    traceId,
+    ...getClientInfo(req)
+  };
+}
+function buildErrorContext(req, url, traceId) {
+  return {
+    params: undefined,
+    input: undefined,
+    source: "http",
+    req,
+    url,
+    headers: req.headers,
+    traceId,
+    ...getClientInfo(req)
+  };
+}
+
+// src/server/logger.ts
+var c = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+var METHOD_COLOR = {
+  GET: c.green,
+  POST: c.yellow,
+  PUT: c.blue,
+  PATCH: c.cyan,
+  DELETE: c.red,
+  OPTIONS: c.gray
+};
+var isProd = false;
+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 elapsedMs(startTime) {
+  return Number(process.hrtime.bigint() - startTime) / 1e6;
+}
+function levelForStatus(status) {
+  if (status >= 500)
+    return "error";
+  if (status >= 400)
+    return "warn";
+  return "info";
+}
+function buildLogFields(method, path, status, durationMs, traceId) {
+  return { traceId, method, path, status, durationMs };
+}
+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) {
+  const log = { traceId, startTime: process.hrtime.bigint() };
+  if (!isProd) {
+    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} ${pathname} ${ipLabel(extractIp(req))}`);
+  }
+  return log;
+}
+function logOutgoing(req, pathname, status, log) {
+  const ms = elapsedMs(log.startTime);
+  if (isProd) {
+    console.log(JSON.stringify({
+      ts: new Date().toISOString(),
+      level: levelForStatus(status),
+      msg: `${req.method} ${pathname} ${status}`,
+      ...buildLogFields(req.method, pathname, status, Math.round(ms), log.traceId),
+      ip: extractIp(req) || undefined
+    }));
+    return;
+  }
+  const mc = METHOD_COLOR[req.method] ?? c.dim;
+  console.log(`${c.gray}[${timestamp()}]${c.reset} ${mc}${req.method}${c.reset} ${c.dim}${log.traceId}${c.reset} ${c.cyan}←${c.reset} ${pathname} ${statusColor(status)}${status}${c.reset} ${durationColor(ms)}${formatMs(ms)}${c.reset} ${ipLabel(extractIp(req))}`);
+}
+
+// src/server/create.ts
+function createHandler(config) {
+  const { cors, hooks, logging = false } = config;
+  const customLogger = typeof logging === "object" ? logging : null;
+  const useDefaultLog = logging === true;
+  const resolveId = config.traceId ?? resolveTraceId;
+  const routeMap = buildRouteMap(normalizeGroups(config));
+  validateRoutes(routeMap);
+  async function dispatch(req, url, traceId, server) {
+    const shouldLogRequest = logging && shouldLog(url.pathname, req.method);
+    let reqLog;
+    if (shouldLogRequest && useDefaultLog) {
+      reqLog = logIncoming(req, url.pathname, traceId);
+    }
+    if (shouldLogRequest && customLogger) {
+      customLogger.debug(`${req.method} ${url.pathname}`, {
+        traceId,
+        method: req.method,
+        path: url.pathname,
+        ip: extractIp(req) || undefined
+      });
+      reqLog = { traceId, startTime: process.hrtime.bigint() };
+    }
+    const logDone = (status) => {
+      if (!reqLog)
+        return;
+      if (useDefaultLog)
+        logOutgoing(req, url.pathname, status, reqLog);
+      if (customLogger) {
+        const durationMs = Math.round(elapsedMs(reqLog.startTime));
+        const level = levelForStatus(status);
+        customLogger[level](`${req.method} ${url.pathname} ${status} ${durationMs}ms`, buildLogFields(req.method, url.pathname, status, durationMs, reqLog.traceId));
+      }
+    };
+    const respondError = async (err, errCtx, endpoint) => {
+      if (hooks?.onError) {
+        try {
+          const response = await hooks.onError(errCtx ?? buildErrorContext(req, url, traceId), err, endpoint);
+          if (response instanceof Response) {
+            const withCors = applyCors(response, cors, req);
+            logDone(withCors.status);
+            return withCors;
+          }
+        } catch {}
+      }
+      const appErr = normalizeError(err);
+      logDone(appErr.status);
+      return json(appErr.toJSON(), appErr.status, cors, req);
+    };
+    if (cors && req.method === "OPTIONS") {
+      const res = corsPreflightResponse(cors, req);
+      logDone(204);
+      return res;
+    }
+    if (hooks?.onRequest) {
+      const earlyResponse = await hooks.onRequest(req);
+      if (earlyResponse instanceof Response) {
+        logDone(earlyResponse.status);
+        return earlyResponse;
+      }
+    }
+    if (config.rawRoutes) {
+      const rawMatch = matchRawRoute(config.rawRoutes, req.method, url.pathname);
+      if (rawMatch) {
+        try {
+          const res = await rawMatch.route.handler(req, {
+            params: rawMatch.params,
+            server
+          });
+          const withCors = applyCors(res, cors, req);
+          logDone(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;
+    let ctx;
+    try {
+      ctx = await buildContext(req, url, method, pathParams, traceId);
+      if (hooks?.beforeHandle) {
+        await hooks.beforeHandle(ctx, method);
+      }
+      if (groupHooks?.beforeHandle) {
+        await groupHooks.beforeHandle(ctx, method);
+      }
+      let result = await method.handler(ctx);
+      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 (method.outputSchema) {
+        result = method.outputSchema.parse(result);
+      }
+      if (result === undefined || result === null) {
+        logDone(204);
+        return new Response(null, { status: 204, headers: corsHeaders2(cors, req) });
+      }
+      logDone(200);
+      return json(result, 200, cors, req);
+    } catch (err) {
+      return respondError(err, ctx, method);
+    }
+  }
+  return async (req, server) => {
+    const url = new URL(req.url, "http://localhost");
+    const traceId = resolveId(req);
+    const response = await dispatch(req, url, traceId, server);
+    if (!response.headers.has("x-request-id")) {
+      response.headers.set("x-request-id", traceId);
+    }
+    return response;
+  };
+}
+function createServer(config) {
+  const { routes, websocket, development, bun: bunExtra, port = 3000, hostname } = config;
+  const fetch = createHandler(config);
+  return websocket ? Bun.serve({
+    ...bunExtra,
+    ...routes && { routes },
+    ...development && { development },
+    port,
+    hostname,
+    websocket,
+    fetch
+  }) : Bun.serve({
+    ...bunExtra,
+    ...development && { development },
+    port,
+    hostname,
+    fetch
+  });
+}
+function normalizeGroups(config) {
+  const result = [];
+  if (config.services) {
+    for (const service of config.services) {
+      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;
+  const headers = new Headers(res.headers);
+  for (const [key, value] of Object.entries(extra))
+    headers.set(key, value);
+  return new Response(res.body, {
+    status: res.status,
+    statusText: res.statusText,
+    headers
+  });
+}
+function json(data, status, cors, req) {
+  return Response.json(data, { status, headers: corsHeaders2(cors, req) });
+}
+
+export { parseMultipart, corsHeaders, corsPreflightResponse, staticRoute, createHandler, createServer };

package/dist/index.js

@@ -7,6 +7,7 @@ import {
 import {
   parseSSE
 } from "./index-n7bmdwmz.js";
+import"./index-809wc1tt.js";
 import {
   ALL_TRANSPORTS,
   AppError,
@@ -19,8 +20,7 @@ import {
   paginatedSchema,
   rateLimited,
   unauthorized
-} from "./index-7wfkbvss.js";
-import"./index-809wc1tt.js";
+} from "./index-kckky6zw.js";
 // src/browser/socket-io.ts
 import { io } from "socket.io-client";
 function createSocketIOClient(config) {

package/dist/node.d.ts

@@ -0,0 +1,4 @@
+export { createHandler } from './server/create';
+export { type NodeServerConfig, type NodeServerHandle, serveNode } from './server/node';
+export type { HandlerConfig } from './server/types';
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACxF,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/node.js

@@ -0,0 +1,26 @@
+import {
+  createHandler
+} from "./index-v2z2v3mq.js";
+import"./index-a35v22fh.js";
+import"./index-kckky6zw.js";
+import"./index-ke4mx4ea.js";
+// src/server/node.ts
+import { serve } from "srvx";
+async function serveNode(config) {
+  const { port = 3000, hostname, ...handlerConfig } = config;
+  const handler = createHandler(handlerConfig);
+  const server = serve({ port, hostname, fetch: handler });
+  await server.ready();
+  const listenUrl = server.url ?? `http://${hostname ?? "localhost"}:${port}`;
+  const resolvedPort = Number(new URL(listenUrl).port) || port;
+  const resolvedHost = hostname ?? "localhost";
+  return {
+    url: `http://${resolvedHost}:${resolvedPort}`,
+    port: resolvedPort,
+    close: (closeActive) => server.close(closeActive)
+  };
+}
+export {
+  serveNode,
+  createHandler
+};

package/dist/server/create.d.ts

@@ -1,4 +1,4 @@
-import type { ServerConfig } from './types';
-export declare function createHandler(config: ServerConfig): (req: Request) => Promise<Response>;
-export declare function createServer(config: ServerConfig): Bun.Server<unknown>;
+import type { BunServerConfig, HandlerConfig } from './types';
+export declare function createHandler(config: HandlerConfig): (req: Request) => Promise<Response>;
+export declare function createServer(config: BunServerConfig): Bun.Server<unknown>;
 //# sourceMappingURL=create.d.ts.map

package/dist/server/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/server/create.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAwB,YAAY,EAAgB,MAAM,SAAS,CAAC;AAEhF,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA+KvF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,uBAsBhD"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/server/create.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAEV,eAAe,EACf,aAAa,EAGd,MAAM,SAAS,CAAC;AAEjB,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAiLxF;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,uBAsBnD"}

package/dist/server/index.d.ts

@@ -13,5 +13,5 @@ export { staticRoute } from './router';
 export type { SocketIOServerConfig, SocketIOServerHandle } from './socket-io';
 export { createSocketIOServer } from './socket-io';
 export { type ParseSSEOptions, parseSSE, streamSSE } from './stream';
-export type { BunServer, Handlers, LifecycleHooks, MethodDef, RawRoute, RawRouteContext, RouteGroup, ServerConfig, ServerPassthrough, ServiceDef, StitchLogger, } from './types';
+export type { BunServer, BunServerConfig, HandlerConfig, Handlers, LifecycleHooks, MethodDef, RawRoute, RawRouteContext, RouteGroup, ServerPassthrough, ServiceDef, StitchLogger, } from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,oBAAoB,EACzB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACZ,KAAK,UAAU,EACf,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,YAAY,EACZ,YAAY,EACZ,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,UAAU,EACf,WAAW,EACX,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EACL,SAAS,EACT,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrE,YAAY,EACV,SAAS,EACT,QAAQ,EACR,cAAc,EACd,SAAS,EACT,QAAQ,EACR,eAAe,EACf,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,UAAU,EACV,YAAY,GACb,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,WAAW,EACX,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,oBAAoB,EACzB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACZ,KAAK,UAAU,EACf,SAAS,GACV,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,YAAY,EACZ,YAAY,EACZ,eAAe,GAChB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,KAAK,UAAU,EACf,WAAW,EACX,qBAAqB,GACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EACL,SAAS,EACT,eAAe,EACf,aAAa,EACb,cAAc,GACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,YAAY,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,KAAK,eAAe,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrE,YAAY,EACV,SAAS,EACT,eAAe,EACf,aAAa,EACb,QAAQ,EACR,cAAc,EACd,SAAS,EACT,QAAQ,EACR,eAAe,EACf,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,YAAY,GACb,MAAM,SAAS,CAAC"}