@kozojs/core 0.2.4 → 0.2.6

package/lib/index.js

@@ -1,8 +1,7 @@
 // src/app.ts
-import { Hono } from "hono";
+import { Hono } from "hono/quick";
 import { serve } from "@hono/node-server";
-import Ajv3 from "ajv";
-import addFormats3 from "ajv-formats";
+import { createServer } from "http";
 
 // src/client-generator.ts
 function generateMethodName(method, path) {
@@ -202,431 +201,2735 @@ function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
-// src/optimizations/serializer.ts
-import fastJson from "fast-json-stringify";
-import { zodToJsonSchema } from "zod-to-json-schema";
-function isZodSchema(schema) {
-  return typeof schema === "object" && schema !== null && "safeParse" in schema;
+// src/uws-transport.ts
+import { createServer as netCreateServer } from "net";
+
+// src/errors.ts
+var CONTENT_TYPE_PROBLEM = "application/problem+json";
+var ERROR_RESPONSES = {
+  VALIDATION_FAILED: {
+    type: "https://kozo.dev/errors/validation-failed",
+    title: "Validation Failed",
+    status: 400
+  },
+  INVALID_BODY: {
+    type: "https://kozo.dev/errors/invalid-body",
+    title: "Invalid Request Body",
+    status: 400
+  },
+  INVALID_QUERY: {
+    type: "https://kozo.dev/errors/invalid-query",
+    title: "Invalid Query Parameters",
+    status: 400
+  },
+  INVALID_PARAMS: {
+    type: "https://kozo.dev/errors/invalid-params",
+    title: "Invalid Path Parameters",
+    status: 400
+  },
+  INTERNAL_ERROR: {
+    type: "https://kozo.dev/errors/internal-error",
+    title: "Internal Server Error",
+    status: 500
+  },
+  NOT_FOUND: {
+    type: "https://kozo.dev/errors/not-found",
+    title: "Resource Not Found",
+    status: 404
+  },
+  UNAUTHORIZED: {
+    type: "https://kozo.dev/errors/unauthorized",
+    title: "Unauthorized",
+    status: 401
+  },
+  FORBIDDEN: {
+    type: "https://kozo.dev/errors/forbidden",
+    title: "Forbidden",
+    status: 403
+  }
+};
+var HDR_PROBLEM = { "Content-Type": CONTENT_TYPE_PROBLEM };
+var INIT_400 = Object.freeze({ status: 400, headers: HDR_PROBLEM });
+var INIT_401 = Object.freeze({ status: 401, headers: HDR_PROBLEM });
+var INIT_403 = Object.freeze({ status: 403, headers: HDR_PROBLEM });
+var INIT_404 = Object.freeze({ status: 404, headers: HDR_PROBLEM });
+var INIT_500 = Object.freeze({ status: 500, headers: HDR_PROBLEM });
+function formatAjvErrors(errors) {
+  if (!errors || errors.length === 0) return [];
+  return errors.map((err) => ({
+    field: err.instancePath?.replace(/^\//, "").replace(/\//g, ".") || err.params?.missingProperty || "unknown",
+    message: err.message || "Invalid value",
+    code: err.keyword || "invalid",
+    value: err.data
+  }));
 }
-var ResponseSerializer = class {
-  serializers = /* @__PURE__ */ new Map();
-  fallback = JSON.stringify;
-  compile(routeId, schema) {
-    try {
-      let jsonSchema;
-      const isZod = isZodSchema(schema);
-      if (isZod) {
-        jsonSchema = zodToJsonSchema(schema, { $refStrategy: "none", target: "jsonSchema7" });
-        if (process.env.KOZO_DEBUG_SCHEMA === "true") {
-          console.log(`
-[DIAGNOSTIC] Schema for ${routeId}:`);
-          console.log(JSON.stringify(jsonSchema, null, 2));
-          const schemaStr = JSON.stringify(jsonSchema);
-          const hasAnyOf = schemaStr.includes("anyOf");
-          const hasOneOf = schemaStr.includes("oneOf");
-          const hasAllOf = schemaStr.includes("allOf");
-          if (hasAnyOf || hasOneOf || hasAllOf) {
-            console.warn(`\u26A0\uFE0F  Complex schema detected for ${routeId}:`, { hasAnyOf, hasOneOf, hasAllOf });
-            console.warn("   This may reduce fast-json-stringify performance");
-          }
-        }
-      } else {
-        jsonSchema = schema;
-      }
-      const stringify = fastJson(jsonSchema);
-      this.serializers.set(routeId, stringify);
-    } catch (err) {
-      console.error(`Failed to compile serializer for ${routeId}`, err);
-      this.serializers.set(routeId, this.fallback);
-    }
+function formatZodErrors(errors) {
+  if (!errors?.issues) return [];
+  return errors.issues.map((issue) => ({
+    field: issue.path?.join(".") || "unknown",
+    message: issue.message || "Invalid value",
+    code: issue.code || "invalid",
+    value: issue.input
+  }));
+}
+function validationErrorResponse(field, ajvErrors, instance) {
+  const body = {
+    type: ERROR_RESPONSES.VALIDATION_FAILED.type,
+    title: ERROR_RESPONSES.VALIDATION_FAILED.title,
+    status: 400,
+    errors: formatAjvErrors(ajvErrors)
+  };
+  if (instance) body.instance = instance;
+  return new Response(JSON.stringify(body), INIT_400);
+}
+function internalErrorResponse(err, instance) {
+  const body = {
+    type: ERROR_RESPONSES.INTERNAL_ERROR.type,
+    title: ERROR_RESPONSES.INTERNAL_ERROR.title,
+    status: 500,
+    detail: err?.message
+  };
+  if (instance) body.instance = instance;
+  return new Response(JSON.stringify(body), INIT_500);
+}
+var BODY_404_STATIC = JSON.stringify({
+  type: ERROR_RESPONSES.NOT_FOUND.type,
+  title: ERROR_RESPONSES.NOT_FOUND.title,
+  status: 404
+});
+function notFoundResponse(instance) {
+  if (!instance) return new Response(BODY_404_STATIC, INIT_404);
+  const body = {
+    type: ERROR_RESPONSES.NOT_FOUND.type,
+    title: ERROR_RESPONSES.NOT_FOUND.title,
+    status: 404,
+    instance
+  };
+  return new Response(JSON.stringify(body), INIT_404);
+}
+var BODY_401_STATIC = JSON.stringify({
+  type: ERROR_RESPONSES.UNAUTHORIZED.type,
+  title: ERROR_RESPONSES.UNAUTHORIZED.title,
+  status: 401
+});
+function unauthorizedResponse(instance) {
+  if (!instance) return new Response(BODY_401_STATIC, INIT_401);
+  const body = {
+    type: ERROR_RESPONSES.UNAUTHORIZED.type,
+    title: ERROR_RESPONSES.UNAUTHORIZED.title,
+    status: 401,
+    instance
+  };
+  return new Response(JSON.stringify(body), INIT_401);
+}
+var BODY_403_STATIC = JSON.stringify({
+  type: ERROR_RESPONSES.FORBIDDEN.type,
+  title: ERROR_RESPONSES.FORBIDDEN.title,
+  status: 403
+});
+function forbiddenResponse(instance) {
+  if (!instance) return new Response(BODY_403_STATIC, INIT_403);
+  const body = {
+    type: ERROR_RESPONSES.FORBIDDEN.type,
+    title: ERROR_RESPONSES.FORBIDDEN.title,
+    status: 403,
+    instance
+  };
+  return new Response(JSON.stringify(body), INIT_403);
+}
+var BODY_500_STATIC = JSON.stringify({
+  type: ERROR_RESPONSES.INTERNAL_ERROR.type,
+  title: ERROR_RESPONSES.INTERNAL_ERROR.title,
+  status: 500
+});
+var KozoError = class extends Error {
+  statusCode;
+  code;
+  constructor(message, statusCode, code) {
+    super(message);
+    this.name = "KozoError";
+    this.statusCode = statusCode;
+    this.code = code;
   }
-  // Deprecated: for backward compatibility
-  compileFromZod(routeId, zodSchema) {
-    this.compile(routeId, zodSchema);
+  toResponse(instance) {
+    const body = {
+      type: `https://kozo.dev/errors/${this.code}`,
+      title: this.message,
+      status: this.statusCode
+    };
+    if (instance) body.instance = instance;
+    const init = _initForStatus(this.statusCode);
+    return new Response(JSON.stringify(body), init);
   }
-  // Deprecated: for backward compatibility
-  compileFromJsonSchema(routeId, schema) {
-    this.compile(routeId, schema);
+};
+function _initForStatus(status) {
+  if (status === 400) return INIT_400;
+  if (status === 401) return INIT_401;
+  if (status === 403) return INIT_403;
+  if (status === 404) return INIT_404;
+  if (status === 500) return INIT_500;
+  return Object.freeze({ status, headers: HDR_PROBLEM });
+}
+var ValidationFailedError = class extends KozoError {
+  errors;
+  constructor(message, errors = []) {
+    super(message, 400, "validation-failed");
+    this.name = "ValidationFailedError";
+    this.errors = errors;
   }
-  serialize(routeId, data) {
-    const serializer = this.serializers.get(routeId);
-    return serializer ? serializer(data) : this.fallback(data);
+  toResponse(instance) {
+    const body = {
+      type: "https://kozo.dev/errors/validation-failed",
+      title: this.message,
+      status: 400,
+      errors: this.errors
+    };
+    if (instance) body.instance = instance;
+    return new Response(JSON.stringify(body), INIT_400);
   }
-  has(routeId) {
-    return this.serializers.has(routeId);
+};
+var NotFoundError = class extends KozoError {
+  constructor(message = "Resource Not Found") {
+    super(message, 404, "not-found");
+    this.name = "NotFoundError";
   }
-  getSerializer(routeId) {
-    return this.serializers.get(routeId);
+};
+var UnauthorizedError = class extends KozoError {
+  constructor(message = "Unauthorized") {
+    super(message, 401, "unauthorized");
+    this.name = "UnauthorizedError";
   }
 };
-var commonSchemas = {
-  health: {
-    type: "object",
-    properties: {
-      status: { type: "string" },
-      timestamp: { type: "number" }
-    }
-  },
-  error: {
-    type: "object",
-    properties: {
-      error: { type: "string" },
-      status: { type: "number" }
-    }
-  },
-  success: {
-    type: "object",
-    properties: {
-      success: { type: "boolean" },
-      data: {}
-    }
+var ForbiddenError = class extends KozoError {
+  constructor(message = "Forbidden") {
+    super(message, 403, "forbidden");
+    this.name = "ForbiddenError";
   }
 };
-var globalSerializer = new ResponseSerializer();
-globalSerializer.compile("__health", commonSchemas.health);
-globalSerializer.compile("__error", commonSchemas.error);
 
-// src/optimizations/validator.ts
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
-import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
-function isZodSchema2(schema) {
-  return typeof schema === "object" && schema !== null && "safeParse" in schema;
+// src/uws-transport.ts
+var STATUS_TEXT = {
+  200: "200 OK",
+  201: "201 Created",
+  204: "204 No Content",
+  301: "301 Moved Permanently",
+  302: "302 Found",
+  400: "400 Bad Request",
+  401: "401 Unauthorized",
+  403: "403 Forbidden",
+  404: "404 Not Found",
+  405: "405 Method Not Allowed",
+  422: "422 Unprocessable Entity",
+  429: "429 Too Many Requests",
+  500: "500 Internal Server Error",
+  503: "503 Service Unavailable"
+};
+var BODY_404 = JSON.stringify({
+  type: "https://kozo.dev/errors/not-found",
+  title: "Resource Not Found",
+  status: 404
+});
+var NO_BODY_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "DELETE", "OPTIONS", "TRACE"]);
+var CT_JSON = "application/json";
+var CT_PROBLEM = "application/problem+json";
+var BODY_500 = JSON.stringify({
+  type: "https://kozo.dev/errors/internal-error",
+  title: "Internal Server Error",
+  status: 500
+});
+function uwsFastWriteJson(uwsRes, body) {
+  uwsRes.cork(() => {
+    uwsRes.writeStatus("200 OK");
+    uwsRes.writeHeader("Content-Type", CT_JSON);
+    uwsRes.end(body);
+  });
 }
-var HybridValidator = class {
-  ajv;
-  validators = /* @__PURE__ */ new Map();
-  constructor() {
-    this.ajv = new Ajv({
-      allErrors: false,
-      // Stop at first error (faster)
-      coerceTypes: true,
-      // Auto-coerce strings to numbers etc
-      removeAdditional: true
-      // Strip unknown properties
+function uwsFastWrite400(field, errors, uwsRes) {
+  const body = JSON.stringify({
+    type: "https://kozo.dev/errors/validation-failed",
+    title: "Validation Failed",
+    status: 400,
+    errors: (errors ?? []).map((e) => ({
+      field: e.instancePath?.replace(/^\//, "").replace(/\//g, ".") || e.params?.missingProperty || "unknown",
+      message: e.message || "Invalid value",
+      code: e.keyword || "invalid"
+    }))
+  });
+  uwsRes.cork(() => {
+    uwsRes.writeStatus("400 Bad Request");
+    uwsRes.writeHeader("Content-Type", CT_PROBLEM);
+    uwsRes.end(body);
+  });
+}
+function uwsFastWrite500(uwsRes) {
+  uwsRes.cork(() => {
+    uwsRes.writeStatus("500 Internal Server Error");
+    uwsRes.writeHeader("Content-Type", CT_PROBLEM);
+    uwsRes.end(BODY_500);
+  });
+}
+function uwsFastWriteError(err, uwsRes) {
+  if (err instanceof KozoError) {
+    const body = JSON.stringify({
+      type: `https://kozo.dev/errors/${err.code}`,
+      title: err.message,
+      status: err.statusCode
+    });
+    uwsRes.cork(() => {
+      uwsRes.writeStatus(STATUS_TEXT[err.statusCode] ?? `${err.statusCode}`);
+      uwsRes.writeHeader("Content-Type", CT_PROBLEM);
+      uwsRes.end(body);
     });
-    addFormats(this.ajv);
+  } else {
+    uwsFastWrite500(uwsRes);
   }
-  compile(routeId, schema) {
-    try {
-      let jsonSchema;
-      if (isZodSchema2(schema)) {
-        jsonSchema = zodToJsonSchema2(schema, { $refStrategy: "none", target: "jsonSchema7" });
-      } else {
-        jsonSchema = schema;
-      }
-      const validate = this.ajv.compile(jsonSchema);
-      this.validators.set(routeId, (data) => {
-        const valid = validate(data);
-        if (valid) {
-          return { valid: true, data };
-        }
-        return {
-          valid: false,
-          errors: validate.errors?.map((e) => `${e.instancePath} ${e.message}`) || ["Validation failed"]
-        };
-      });
-    } catch (err) {
-      if (isZodSchema2(schema)) {
-        this.validators.set(routeId, (data) => {
-          const result = schema.safeParse(data);
-          if (result.success) {
-            return { valid: true, data: result.data };
-          }
-          return {
-            valid: false,
-            errors: result.error.issues.map((i) => `${i.path.join(".")} ${i.message}`)
-          };
+}
+async function tryLoadUws() {
+  try {
+    const { createRequire } = await import("module");
+    const req = createRequire(import.meta.url);
+    return req("uWebSockets.js");
+  } catch {
+    return null;
+  }
+}
+function uwsWrite404(uwsRes) {
+  uwsRes.cork(() => {
+    uwsRes.writeStatus("404 Not Found");
+    uwsRes.writeHeader("Content-Type", "application/problem+json");
+    uwsRes.end(BODY_404);
+  });
+}
+function getFreePort() {
+  return new Promise((resolve2, reject) => {
+    const srv = netCreateServer();
+    srv.listen(0, "0.0.0.0", () => {
+      const port = srv.address().port;
+      srv.close((err) => err ? reject(err) : resolve2(port));
+    });
+  });
+}
+var UWS_METHOD = {
+  GET: "get",
+  POST: "post",
+  PUT: "put",
+  PATCH: "patch",
+  DELETE: "del",
+  OPTIONS: "options",
+  HEAD: "head"
+};
+async function createUwsServer(opts) {
+  const { uws, routes } = opts;
+  const port = opts.port === 0 ? await getFreePort() : opts.port;
+  const emptyParams = Object.freeze({});
+  return new Promise((resolve2, reject) => {
+    const uwsApp = uws.App();
+    for (const route of routes) {
+      const fn = UWS_METHOD[route.method];
+      if (!fn) continue;
+      const h = route.handler;
+      const names = route.paramNames;
+      const hasParams = names.length > 0;
+      const noBody = NO_BODY_METHODS.has(route.method);
+      if (noBody && !hasParams) {
+        uwsApp[fn](route.path, (uwsRes, uwsReq) => {
+          const query = uwsReq.getQuery();
+          h(uwsRes, query ? `${uwsReq.getUrl()}?${query}` : uwsReq.getUrl(), "", emptyParams);
+        });
+      } else if (noBody && hasParams) {
+        uwsApp[fn](route.path, (uwsRes, uwsReq) => {
+          const rawPath = uwsReq.getUrl();
+          const query = uwsReq.getQuery();
+          const params = {};
+          for (let i = 0; i < names.length; i++) params[names[i]] = uwsReq.getParameter(i);
+          h(uwsRes, query ? `${rawPath}?${query}` : rawPath, "", params);
+        });
+      } else if (!hasParams) {
+        uwsApp[fn](route.path, (uwsRes, uwsReq) => {
+          const rawPath = uwsReq.getUrl();
+          const query = uwsReq.getQuery();
+          const url = query ? `${rawPath}?${query}` : rawPath;
+          let aborted = false;
+          let bodyStr = "";
+          uwsRes.onAborted(() => {
+            aborted = true;
+          });
+          uwsRes.onData((chunk, isLast) => {
+            if (aborted) return;
+            if (chunk.byteLength > 0) bodyStr += Buffer.from(chunk).toString("utf8");
+            if (isLast) h(uwsRes, url, bodyStr, emptyParams);
+          });
         });
       } else {
-        console.error(`Failed to compile validator for ${routeId}`, err);
-        this.validators.set(routeId, () => ({ valid: false, errors: ["Internal Server Error: Validator compilation failed"] }));
+        uwsApp[fn](route.path, (uwsRes, uwsReq) => {
+          const rawPath = uwsReq.getUrl();
+          const query = uwsReq.getQuery();
+          const url = query ? `${rawPath}?${query}` : rawPath;
+          const params = {};
+          for (let i = 0; i < names.length; i++) params[names[i]] = uwsReq.getParameter(i);
+          let aborted = false;
+          let bodyStr = "";
+          uwsRes.onAborted(() => {
+            aborted = true;
+          });
+          uwsRes.onData((chunk, isLast) => {
+            if (aborted) return;
+            if (chunk.byteLength > 0) bodyStr += Buffer.from(chunk).toString("utf8");
+            if (isLast) h(uwsRes, url, bodyStr, params);
+          });
+        });
       }
     }
+    uwsApp.any("/*", (uwsRes) => {
+      uwsWrite404(uwsRes);
+    });
+    let listenToken = null;
+    uwsApp.listen(port, (token) => {
+      if (!token) {
+        reject(new Error(`[Kozo] uWS failed to listen on port ${port}`));
+        return;
+      }
+      listenToken = token;
+      resolve2({
+        port,
+        server: {
+          close() {
+            if (listenToken) uws.us_listen_socket_close(listenToken);
+          }
+        }
+      });
+    });
+  });
+}
+
+// src/compiler.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import fastJson from "fast-json-stringify";
+
+// src/fast-response.ts
+var CL_CACHE = /* @__PURE__ */ (() => {
+  const arr = new Array(1e4);
+  for (let i = 0; i < 1e4; i++) arr[i] = String(i);
+  return arr;
+})();
+function fastCL(n) {
+  return n < 1e4 ? CL_CACHE[n] : String(n);
+}
+var CT_JSON2 = "application/json";
+var CT_PROBLEM2 = "application/problem+json";
+var CT_TEXT = "text/plain";
+var CT_HTML = "text/html; charset=utf-8";
+var BODY_4042 = JSON.stringify({
+  type: "https://kozo.dev/errors/not-found",
+  title: "Resource Not Found",
+  status: 404
+});
+var LEN_404 = fastCL(BODY_4042.length);
+var BODY_5002 = JSON.stringify({
+  type: "https://kozo.dev/errors/internal-error",
+  title: "Internal Server Error",
+  status: 500
+});
+var LEN_500 = fastCL(BODY_5002.length);
+function fastWriteJson(res, body) {
+  res.writeHead(200, [
+    "Content-Type",
+    CT_JSON2,
+    "Content-Length",
+    fastCL(body.length)
+  ]);
+  res.end(body);
+}
+function fastWriteText(res, body, status = 200) {
+  const len = Buffer.byteLength(body);
+  res.writeHead(status, [
+    "Content-Type",
+    CT_TEXT,
+    "Content-Length",
+    fastCL(len)
+  ]);
+  res.end(body);
+}
+function fastWriteHtml(res, body, status = 200) {
+  const len = Buffer.byteLength(body);
+  res.writeHead(status, [
+    "Content-Type",
+    CT_HTML,
+    "Content-Length",
+    fastCL(len)
+  ]);
+  res.end(body);
+}
+function fastWriteJsonStatus(res, body, status) {
+  res.writeHead(status, [
+    "Content-Type",
+    CT_JSON2,
+    "Content-Length",
+    fastCL(body.length)
+  ]);
+  res.end(body);
+}
+function fastWrite404(res) {
+  res.writeHead(404, [
+    "Content-Type",
+    CT_PROBLEM2,
+    "Content-Length",
+    LEN_404
+  ]);
+  res.end(BODY_4042);
+}
+function fastWrite500(res) {
+  res.writeHead(500, [
+    "Content-Type",
+    CT_PROBLEM2,
+    "Content-Length",
+    LEN_500
+  ]);
+  res.end(BODY_5002);
+}
+function fastWrite400(field, errors, res) {
+  const body = JSON.stringify({
+    type: "https://kozo.dev/errors/validation-failed",
+    title: "Validation Failed",
+    status: 400,
+    errors: (errors ?? []).map((e) => ({
+      field: e.instancePath?.replace(/^\//, "").replace(/\//g, ".") || e.params?.missingProperty || "unknown",
+      message: e.message || "Invalid value",
+      code: e.keyword || "invalid"
+    }))
+  });
+  res.writeHead(400, [
+    "Content-Type",
+    CT_PROBLEM2,
+    "Content-Length",
+    fastCL(body.length)
+  ]);
+  res.end(body);
+}
+function fastWriteError(err, res) {
+  if (err instanceof KozoError) {
+    const body = JSON.stringify({
+      type: `https://kozo.dev/errors/${err.code}`,
+      title: err.message,
+      status: err.statusCode
+    });
+    res.writeHead(err.statusCode, [
+      "Content-Type",
+      CT_PROBLEM2,
+      "Content-Length",
+      fastCL(body.length)
+    ]);
+    res.end(body);
+  } else {
+    fastWrite500(res);
   }
-  // Deprecated: kept for backward compatibility if needed, but redirects to compile
-  compileFromZod(routeId, zodSchema) {
-    this.compile(routeId, zodSchema);
-  }
-  validate(routeId, data) {
-    const validator = this.validators.get(routeId);
-    if (!validator) {
-      return { valid: true, data };
-    }
-    return validator(data);
-  }
-  // For production: throws on invalid (faster than returning errors)
-  validateOrThrow(routeId, data) {
-    const result = this.validate(routeId, data);
-    if (!result.valid) {
-      const error = new Error("Validation failed");
-      error.errors = result.errors;
-      throw error;
-    }
-    return result.data;
-  }
-  has(routeId) {
-    return this.validators.has(routeId);
-  }
-};
-var globalValidator = new HybridValidator();
+}
 
 // src/compiler.ts
-import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
-import Ajv2 from "ajv";
-import addFormats2 from "ajv-formats";
-import fastJson2 from "fast-json-stringify";
-var ajv = new Ajv2({
+var ajv = new Ajv({
   removeAdditional: "all",
   useDefaults: true,
   coerceTypes: true
 });
-addFormats2(ajv);
-function isZodSchema3(schema) {
+addFormats(ajv);
+function isZodSchema(schema) {
   return typeof schema === "object" && schema !== null && "safeParse" in schema;
 }
+var ZOD_OPTS = { $refStrategy: "none", target: "jsonSchema7" };
+var HDR_JSON = { "Content-Type": "application/json" };
+var RESPONSE_INIT_200 = Object.freeze({ status: 200, headers: HDR_JSON });
+function jsonResponse200(body) {
+  return new Response(body, RESPONSE_INIT_200);
+}
+var EMPTY_BODY = Object.freeze({});
+var EMPTY_BODY_HANDLER = () => EMPTY_BODY;
+function toJsonBody(result) {
+  if (typeof result === "string") return result;
+  return JSON.stringify(result);
+}
 var SchemaCompiler = class {
   static compile(schema) {
     const compiled = {};
     if (schema.body) {
-      const jsonSchema = isZodSchema3(schema.body) ? zodToJsonSchema3(schema.body, { target: "jsonSchema7" }) : schema.body;
+      const jsonSchema = isZodSchema(schema.body) ? zodToJsonSchema(schema.body, ZOD_OPTS) : schema.body;
       compiled.validateBody = ajv.compile(jsonSchema);
     }
     if (schema.query) {
-      const jsonSchema = isZodSchema3(schema.query) ? zodToJsonSchema3(schema.query, { target: "jsonSchema7" }) : schema.query;
+      const jsonSchema = isZodSchema(schema.query) ? zodToJsonSchema(schema.query, ZOD_OPTS) : schema.query;
       compiled.validateQuery = ajv.compile(jsonSchema);
     }
     if (schema.params) {
-      const jsonSchema = isZodSchema3(schema.params) ? zodToJsonSchema3(schema.params, { target: "jsonSchema7" }) : schema.params;
+      const jsonSchema = isZodSchema(schema.params) ? zodToJsonSchema(schema.params, ZOD_OPTS) : schema.params;
       compiled.validateParams = ajv.compile(jsonSchema);
     }
     if (schema.response) {
-      if (typeof schema.response === "object" && !isZodSchema3(schema.response)) {
+      if (typeof schema.response === "object" && !isZodSchema(schema.response)) {
         const keys = Object.keys(schema.response);
         const isStatusMap = keys.length > 0 && keys.every((k) => !isNaN(Number(k)));
         if (isStatusMap) {
           const responseSchemas = schema.response;
           if (responseSchemas[200]) {
-            const jsonSchema = isZodSchema3(responseSchemas[200]) ? zodToJsonSchema3(responseSchemas[200], { target: "jsonSchema7" }) : responseSchemas[200];
-            compiled.serialize = fastJson2(jsonSchema);
+            const jsonSchema = isZodSchema(responseSchemas[200]) ? zodToJsonSchema(responseSchemas[200], ZOD_OPTS) : responseSchemas[200];
+            compiled.serialize = fastJson(jsonSchema);
           }
         } else {
-          compiled.serialize = fastJson2(schema.response);
+          compiled.serialize = fastJson(schema.response);
         }
       } else {
         const responseSchema = schema.response;
-        const jsonSchema = zodToJsonSchema3(responseSchema, { target: "jsonSchema7" });
-        compiled.serialize = fastJson2(jsonSchema);
+        const jsonSchema = zodToJsonSchema(responseSchema, ZOD_OPTS);
+        compiled.serialize = fastJson(jsonSchema);
       }
     }
     return compiled;
   }
 };
-var RESPONSE_INIT_200 = { status: 200, headers: { "Content-Type": "application/json" } };
-var RESPONSE_INIT_400 = { status: 400, headers: { "Content-Type": "application/json" } };
-var RESPONSE_INIT_500 = { status: 500, headers: { "Content-Type": "application/json" } };
-var ERROR_INVALID = '{"error":"Validation failed"}';
-var ERROR_INTERNAL = '{"error":"Internal server error"}';
-function compileRouteHandler(userHandler, schema, services, compiled) {
-  const bodyValidator = compiled.validateBody;
-  const queryValidator = compiled.validateQuery;
-  const paramsValidator = compiled.validateParams;
-  const serializer = compiled.serialize;
-  const needsBody = !!bodyValidator;
-  const needsQuery = !!queryValidator;
-  const needsParams = !!paramsValidator;
-  const needsSerialize = !!serializer;
-  if (!needsBody && !needsQuery && !needsParams) {
-    if (needsSerialize) {
-      return (c) => {
-        c.services = services;
-        const result = userHandler(c);
-        if (result instanceof Promise) {
-          return result.then((res) => {
-            if (res instanceof Response) return res;
-            return new Response(serializer(res), RESPONSE_INIT_200);
-          });
+function compileRouteHandler(handler, schema, services, compiled) {
+  const { validateBody, validateQuery, validateParams, serialize } = compiled;
+  const hasServices = services != null && Object.keys(services).length > 0;
+  const hasQuery = !!validateQuery;
+  const hasParams = !!validateParams;
+  const hasBody = !!validateBody;
+  const hasSer = !!serialize;
+  const handlerIgnoresArgs = handler.length === 0;
+  if (!hasBody && !hasQuery && !hasParams && !hasServices) {
+    if (hasSer) {
+      const ser = serialize;
+      return function scenario1_bare_ser(c) {
+        try {
+          const result = handlerIgnoresArgs ? handler() : handler({ c });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
+          }
+          return jsonResponse200(ser(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
         }
-        if (result instanceof Response) return result;
-        return new Response(serializer(result), RESPONSE_INIT_200);
       };
-    } else {
-      return (c) => {
-        c.services = services;
-        const result = userHandler(c);
-        if (result instanceof Promise) {
-          return result.then((res) => {
-            if (res instanceof Response) return res;
-            return new Response(JSON.stringify(res), RESPONSE_INIT_200);
-          });
-        }
+    }
+    return function scenario1_bare(c) {
+      try {
+        const result = handlerIgnoresArgs ? handler() : handler({ c });
         if (result instanceof Response) return result;
-        return new Response(JSON.stringify(result), RESPONSE_INIT_200);
+        if (result != null && typeof result.then === "function") {
+          return result.then(
+            (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+            (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+          );
+        }
+        return jsonResponse200(toJsonBody(result));
+      } catch (err) {
+        if (err instanceof KozoError) return err.toResponse(c.req.path);
+        return internalErrorResponse(err, c.req.path);
+      }
+    };
+  }
+  if (!hasBody && !hasQuery && !hasParams && hasServices) {
+    if (hasSer) {
+      const ser = serialize;
+      return function scenario1_services_ser(c) {
+        try {
+          const result = handlerIgnoresArgs ? handler() : handler({ c, services });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
+          }
+          return jsonResponse200(ser(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
+        }
       };
     }
+    return function scenario1_services(c) {
+      try {
+        const result = handlerIgnoresArgs ? handler() : handler({ c, services });
+        if (result instanceof Response) return result;
+        if (result != null && typeof result.then === "function") {
+          return result.then(
+            (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+            (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+          );
+        }
+        return jsonResponse200(toJsonBody(result));
+      } catch (err) {
+        if (err instanceof KozoError) return err.toResponse(c.req.path);
+        return internalErrorResponse(err, c.req.path);
+      }
+    };
   }
-  if (!needsBody) {
-    if (needsSerialize) {
-      return (c) => {
-        const ctx = c;
-        ctx.services = services;
-        if (needsParams) {
-          const params = c.req.param();
-          if (!paramsValidator(params)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+  if (hasQuery && !hasParams && !hasBody) {
+    const vq = validateQuery;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function scenario2a_query_ser(c) {
+          try {
+            const query = c.req.query();
+            if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+            const result = handlerIgnoresArgs ? handler() : handler({ c, query });
+            if (result instanceof Response) return result;
+            if (result != null && typeof result.then === "function") {
+              return result.then(
+                (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+                (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+              );
+            }
+            return jsonResponse200(ser(result));
+          } catch (err) {
+            if (err instanceof KozoError) return err.toResponse(c.req.path);
+            return internalErrorResponse(err, c.req.path);
           }
-          ctx.params = params;
-        }
-        if (needsQuery) {
+        };
+      }
+      return function scenario2a_query_svc_ser(c) {
+        try {
           const query = c.req.query();
-          if (!queryValidator(query)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+          const result = handlerIgnoresArgs ? handler() : handler({ c, query, services });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
           }
-          ctx.query = query;
+          return jsonResponse200(ser(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
         }
-        const result = userHandler(c);
-        if (result instanceof Promise) {
-          return result.then((res) => {
-            if (res instanceof Response) return res;
-            return new Response(serializer(res), RESPONSE_INIT_200);
-          });
+      };
+    }
+    if (!hasServices) {
+      return function scenario2a_query(c) {
+        try {
+          const query = c.req.query();
+          if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+          const result = handlerIgnoresArgs ? handler() : handler({ c, query });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
+          }
+          return jsonResponse200(toJsonBody(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
         }
-        if (result instanceof Response) return result;
-        return new Response(serializer(result), RESPONSE_INIT_200);
       };
-    } else {
-      return (c) => {
-        const ctx = c;
-        ctx.services = services;
-        if (needsParams) {
+    }
+    return function scenario2a_query_svc(c) {
+      try {
+        const query = c.req.query();
+        if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+        const result = handlerIgnoresArgs ? handler() : handler({ c, query, services });
+        if (result instanceof Response) return result;
+        if (result != null && typeof result.then === "function") {
+          return result.then(
+            (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+            (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+          );
+        }
+        return jsonResponse200(toJsonBody(result));
+      } catch (err) {
+        if (err instanceof KozoError) return err.toResponse(c.req.path);
+        return internalErrorResponse(err, c.req.path);
+      }
+    };
+  }
+  if (hasParams && !hasQuery && !hasBody) {
+    const vp = validateParams;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function scenario2b_params_ser(c) {
+          try {
+            const params = c.req.param();
+            if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+            const result = handlerIgnoresArgs ? handler() : handler({ c, params });
+            if (result instanceof Response) return result;
+            if (result != null && typeof result.then === "function") {
+              return result.then(
+                (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+                (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+              );
+            }
+            return jsonResponse200(ser(result));
+          } catch (err) {
+            if (err instanceof KozoError) return err.toResponse(c.req.path);
+            return internalErrorResponse(err, c.req.path);
+          }
+        };
+      }
+      return function scenario2b_params_svc_ser(c) {
+        try {
           const params = c.req.param();
-          if (!paramsValidator(params)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+          const result = handlerIgnoresArgs ? handler() : handler({ c, params, services });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
           }
-          ctx.params = params;
+          return jsonResponse200(ser(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
         }
-        if (needsQuery) {
-          const query = c.req.query();
-          if (!queryValidator(query)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+      };
+    }
+    if (!hasServices) {
+      return function scenario2b_params(c) {
+        try {
+          const params = c.req.param();
+          if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+          const result = handlerIgnoresArgs ? handler() : handler({ c, params });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
           }
-          ctx.query = query;
-        }
-        const result = userHandler(c);
-        if (result instanceof Promise) {
-          return result.then((res) => {
-            if (res instanceof Response) return res;
-            return new Response(JSON.stringify(res), RESPONSE_INIT_200);
-          });
+          return jsonResponse200(toJsonBody(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
         }
-        if (result instanceof Response) return result;
-        return new Response(JSON.stringify(result), RESPONSE_INIT_200);
       };
     }
-  }
-  if (needsSerialize) {
-    return async (c) => {
+    return function scenario2b_params_svc(c) {
       try {
-        const ctx = c;
-        ctx.services = services;
-        if (needsParams) {
+        const params = c.req.param();
+        if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+        const result = handlerIgnoresArgs ? handler() : handler({ c, params, services });
+        if (result instanceof Response) return result;
+        if (result != null && typeof result.then === "function") {
+          return result.then(
+            (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+            (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+          );
+        }
+        return jsonResponse200(toJsonBody(result));
+      } catch (err) {
+        if (err instanceof KozoError) return err.toResponse(c.req.path);
+        return internalErrorResponse(err, c.req.path);
+      }
+    };
+  }
+  if (hasQuery && hasParams && !hasBody) {
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function scenario2c_qp_ser(c) {
+          try {
+            const query = c.req.query();
+            const params = c.req.param();
+            if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+            if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+            const result = handlerIgnoresArgs ? handler() : handler({ c, query, params });
+            if (result instanceof Response) return result;
+            if (result != null && typeof result.then === "function") {
+              return result.then(
+                (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+                (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+              );
+            }
+            return jsonResponse200(ser(result));
+          } catch (err) {
+            if (err instanceof KozoError) return err.toResponse(c.req.path);
+            return internalErrorResponse(err, c.req.path);
+          }
+        };
+      }
+      return function scenario2c_qp_svc_ser(c) {
+        try {
+          const query = c.req.query();
           const params = c.req.param();
-          if (!paramsValidator(params)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+          if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+          const result = handlerIgnoresArgs ? handler() : handler({ c, query, params, services });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(ser(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
           }
-          ctx.params = params;
+          return jsonResponse200(ser(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
         }
-        if (needsQuery) {
+      };
+    }
+    if (!hasServices) {
+      return function scenario2c_qp(c) {
+        try {
           const query = c.req.query();
-          if (!queryValidator(query)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          const params = c.req.param();
+          if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+          if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+          const result = handlerIgnoresArgs ? handler() : handler({ c, query, params });
+          if (result instanceof Response) return result;
+          if (result != null && typeof result.then === "function") {
+            return result.then(
+              (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+              (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+            );
           }
-          ctx.query = query;
+          return jsonResponse200(toJsonBody(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(c.req.path);
+          return internalErrorResponse(err, c.req.path);
         }
-        if (needsBody) {
-          const rawBody = await c.req.json().catch(() => ({}));
-          if (!bodyValidator(rawBody)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+      };
+    }
+    return function scenario2c_qp_svc(c) {
+      try {
+        const query = c.req.query();
+        const params = c.req.param();
+        if (!vq(query)) return validationErrorResponse("query", vq.errors, c.req.path);
+        if (!vp(params)) return validationErrorResponse("params", vp.errors, c.req.path);
+        const result = handlerIgnoresArgs ? handler() : handler({ c, query, params, services });
+        if (result instanceof Response) return result;
+        if (result != null && typeof result.then === "function") {
+          return result.then(
+            (r) => r instanceof Response ? r : jsonResponse200(toJsonBody(r)),
+            (err) => err instanceof KozoError ? err.toResponse(c.req.path) : internalErrorResponse(err, c.req.path)
+          );
+        }
+        return jsonResponse200(toJsonBody(result));
+      } catch (err) {
+        if (err instanceof KozoError) return err.toResponse(c.req.path);
+        return internalErrorResponse(err, c.req.path);
+      }
+    };
+  }
+  if (hasBody && hasSer) {
+    const vb = validateBody;
+    const ser = serialize;
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (!hasServices) {
+      return async function scenario3_full_ser(c) {
+        const path = c.req.path;
+        try {
+          const body = await c.req.json().catch(EMPTY_BODY_HANDLER);
+          if (!vb(body)) return validationErrorResponse("body", vb.errors, path);
+          let query;
+          let params;
+          if (vq) {
+            query = c.req.query();
+            if (!vq(query)) return validationErrorResponse("query", vq.errors, path);
+          }
+          if (vp) {
+            params = c.req.param();
+            if (!vp(params)) return validationErrorResponse("params", vp.errors, path);
           }
-          ctx.body = rawBody;
+          const result = await handler({ c, body, query, params });
+          if (result instanceof Response) return result;
+          return jsonResponse200(ser(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(path);
+          return internalErrorResponse(err, path);
+        }
+      };
+    }
+    return async function scenario3_full_ser_svc(c) {
+      const path = c.req.path;
+      try {
+        const body = await c.req.json().catch(EMPTY_BODY_HANDLER);
+        if (!vb(body)) return validationErrorResponse("body", vb.errors, path);
+        let query;
+        let params;
+        if (vq) {
+          query = c.req.query();
+          if (!vq(query)) return validationErrorResponse("query", vq.errors, path);
         }
-        const result = await userHandler(c);
+        if (vp) {
+          params = c.req.param();
+          if (!vp(params)) return validationErrorResponse("params", vp.errors, path);
+        }
+        const result = await handler({ c, body, query, params, services });
         if (result instanceof Response) return result;
-        return new Response(serializer(result), RESPONSE_INIT_200);
+        return jsonResponse200(ser(result));
       } catch (err) {
-        console.error("[Kozo] Handler error:", err);
-        return new Response(ERROR_INTERNAL, RESPONSE_INIT_500);
+        if (err instanceof KozoError) return err.toResponse(path);
+        return internalErrorResponse(err, path);
       }
     };
-  } else {
-    return async (c) => {
-      try {
-        const ctx = c;
-        ctx.services = services;
-        if (needsParams) {
-          const params = c.req.param();
-          if (!paramsValidator(params)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+  }
+  if (hasBody && !hasSer) {
+    const vb = validateBody;
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (!hasServices) {
+      return async function scenario4_full_noser(c) {
+        const path = c.req.path;
+        try {
+          const body = await c.req.json().catch(EMPTY_BODY_HANDLER);
+          if (!vb(body)) return validationErrorResponse("body", vb.errors, path);
+          let query;
+          let params;
+          if (vq) {
+            query = c.req.query();
+            if (!vq(query)) return validationErrorResponse("query", vq.errors, path);
           }
-          ctx.params = params;
-        }
-        if (needsQuery) {
-          const query = c.req.query();
-          if (!queryValidator(query)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          if (vp) {
+            params = c.req.param();
+            if (!vp(params)) return validationErrorResponse("params", vp.errors, path);
           }
-          ctx.query = query;
+          const result = await handler({ c, body, query, params });
+          if (result instanceof Response) return result;
+          return jsonResponse200(toJsonBody(result));
+        } catch (err) {
+          if (err instanceof KozoError) return err.toResponse(path);
+          return internalErrorResponse(err, path);
         }
-        if (needsBody) {
-          const rawBody = await c.req.json().catch(() => ({}));
-          if (!bodyValidator(rawBody)) {
-            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
-          }
-          ctx.body = rawBody;
+      };
+    }
+    return async function scenario4_full_noser_svc(c) {
+      const path = c.req.path;
+      try {
+        const body = await c.req.json().catch(EMPTY_BODY_HANDLER);
+        if (!vb(body)) return validationErrorResponse("body", vb.errors, path);
+        let query;
+        let params;
+        if (vq) {
+          query = c.req.query();
+          if (!vq(query)) return validationErrorResponse("query", vq.errors, path);
+        }
+        if (vp) {
+          params = c.req.param();
+          if (!vp(params)) return validationErrorResponse("params", vp.errors, path);
         }
-        const result = await userHandler(c);
+        const result = await handler({ c, body, query, params, services });
         if (result instanceof Response) return result;
-        return new Response(JSON.stringify(result), RESPONSE_INIT_200);
+        return jsonResponse200(toJsonBody(result));
       } catch (err) {
-        console.error("[Kozo] Handler error:", err);
-        return new Response(ERROR_INTERNAL, RESPONSE_INIT_500);
+        if (err instanceof KozoError) return err.toResponse(path);
+        return internalErrorResponse(err, path);
       }
     };
   }
+  return async function scenario5_fallback(c) {
+    const path = c.req.path;
+    try {
+      const result = await handler({ c, services: hasServices ? services : void 0 });
+      if (result instanceof Response) return result;
+      return jsonResponse200(toJsonBody(result));
+    } catch (err) {
+      if (err instanceof KozoError) return err.toResponse(path);
+      return internalErrorResponse(err, path);
+    }
+  };
 }
-
-// src/app.ts
-var ajv2 = new Ajv3({
-  removeAdditional: "all",
-  useDefaults: true,
-  coerceTypes: true
-});
-addFormats3(ajv2);
-var isBun = typeof Bun !== "undefined";
-if (isBun) {
-  try {
-    if (typeof Bun !== "undefined" && Bun.json) {
-      globalThis.JSON = {
-        parse: Bun.json.parse,
-        stringify: Bun.json.stringify
+function parseNativeQuery(url) {
+  const qIdx = url.indexOf("?");
+  if (qIdx === -1) return {};
+  const sp = new URLSearchParams(url.slice(qIdx + 1));
+  const result = {};
+  sp.forEach((v, k) => {
+    result[k] = v;
+  });
+  return result;
+}
+function readNativeBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      try {
+        const str = Buffer.concat(chunks).toString("utf8");
+        resolve2(str ? JSON.parse(str) : {});
+      } catch {
+        resolve2({});
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function compileNativeHandler(handler, schema, services, compiled) {
+  const { validateBody, validateQuery, validateParams, serialize } = compiled;
+  const hasServices = services != null && Object.keys(services).length > 0;
+  const hasQuery = !!validateQuery;
+  const hasParams = !!validateParams;
+  const hasBody = !!validateBody;
+  const hasSer = !!serialize;
+  const handlerIgnoresArgs = handler.length === 0;
+  if (!hasBody && !hasQuery && !hasParams && !hasServices) {
+    if (hasSer) {
+      const ser = serialize;
+      if (handlerIgnoresArgs) {
+        return function native_s1_bare_ser_noargs(req, res, _p) {
+          try {
+            const result = handler();
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => fastWriteJson(res, ser(r)),
+                (err) => fastWriteError(err, res)
+              );
+              return;
+            }
+            fastWriteJson(res, ser(result));
+          } catch (err) {
+            fastWriteError(err, res);
+          }
+        };
+      }
+      return function native_s1_bare_ser(req, res, _p) {
+        try {
+          const result = handler({ req });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, ser(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, ser(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    if (handlerIgnoresArgs) {
+      return function native_s1_bare_noargs(req, res, _p) {
+        try {
+          const result = handler();
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, toJsonBody(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, toJsonBody(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
       };
     }
-  } catch (e) {
+    return function native_s1_bare(req, res, _p) {
+      try {
+        const result = handler({ req });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => fastWriteJson(res, toJsonBody(r)),
+            (err) => fastWriteError(err, res)
+          );
+          return;
+        }
+        fastWriteJson(res, toJsonBody(result));
+      } catch (err) {
+        fastWriteError(err, res);
+      }
+    };
   }
-}
-var Kozo = class {
-  app;
-  services;
-  routes = [];
-  constructor(config = {}) {
-    this.app = new Hono();
-    this.services = config.services || {};
+  if (!hasBody && !hasQuery && !hasParams && hasServices) {
+    if (hasSer) {
+      const ser = serialize;
+      if (handlerIgnoresArgs) {
+        return function native_s1_svc_ser_noargs(req, res, _p) {
+          try {
+            const result = handler();
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => fastWriteJson(res, ser(r)),
+                (err) => fastWriteError(err, res)
+              );
+              return;
+            }
+            fastWriteJson(res, ser(result));
+          } catch (err) {
+            fastWriteError(err, res);
+          }
+        };
+      }
+      return function native_s1_svc_ser(req, res, _p) {
+        try {
+          const result = handler({ req, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, ser(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, ser(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    if (handlerIgnoresArgs) {
+      return function native_s1_svc_noargs(req, res, _p) {
+        try {
+          const result = handler();
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, toJsonBody(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, toJsonBody(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    return function native_s1_svc(req, res, _p) {
+      try {
+        const result = handler({ req, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => fastWriteJson(res, toJsonBody(r)),
+            (err) => fastWriteError(err, res)
+          );
+          return;
+        }
+        fastWriteJson(res, toJsonBody(result));
+      } catch (err) {
+        fastWriteError(err, res);
+      }
+    };
   }
-  // Plugin system
-  use(plugin) {
+  if (hasQuery && !hasParams && !hasBody) {
+    const vq = validateQuery;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function native_s2a_q_ser(req, res, _p) {
+          try {
+            const query = parseNativeQuery(req.url ?? "/");
+            if (!vq(query)) {
+              fastWrite400("query", vq.errors, res);
+              return;
+            }
+            const result = handlerIgnoresArgs ? handler() : handler({ req, query });
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => fastWriteJson(res, ser(r)),
+                (err) => fastWriteError(err, res)
+              );
+              return;
+            }
+            fastWriteJson(res, ser(result));
+          } catch (err) {
+            fastWriteError(err, res);
+          }
+        };
+      }
+      return function native_s2a_q_svc_ser(req, res, _p) {
+        try {
+          const query = parseNativeQuery(req.url ?? "/");
+          if (!vq(query)) {
+            fastWrite400("query", vq.errors, res);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req, query, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, ser(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, ser(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    if (!hasServices) {
+      return function native_s2a_q(req, res, _p) {
+        try {
+          const query = parseNativeQuery(req.url ?? "/");
+          if (!vq(query)) {
+            fastWrite400("query", vq.errors, res);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req, query });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, toJsonBody(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, toJsonBody(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    return function native_s2a_q_svc(req, res, _p) {
+      try {
+        const query = parseNativeQuery(req.url ?? "/");
+        if (!vq(query)) {
+          fastWrite400("query", vq.errors, res);
+          return;
+        }
+        const result = handlerIgnoresArgs ? handler() : handler({ req, query, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => fastWriteJson(res, toJsonBody(r)),
+            (err) => fastWriteError(err, res)
+          );
+          return;
+        }
+        fastWriteJson(res, toJsonBody(result));
+      } catch (err) {
+        fastWriteError(err, res);
+      }
+    };
+  }
+  if (hasParams && !hasQuery && !hasBody) {
+    const vp = validateParams;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function native_s2b_p_ser(req, res, params) {
+          try {
+            if (!vp(params)) {
+              fastWrite400("params", vp.errors, res);
+              return;
+            }
+            const result = handlerIgnoresArgs ? handler() : handler({ req, params });
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => fastWriteJson(res, ser(r)),
+                (err) => fastWriteError(err, res)
+              );
+              return;
+            }
+            fastWriteJson(res, ser(result));
+          } catch (err) {
+            fastWriteError(err, res);
+          }
+        };
+      }
+      return function native_s2b_p_svc_ser(req, res, params) {
+        try {
+          if (!vp(params)) {
+            fastWrite400("params", vp.errors, res);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req, params, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, ser(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, ser(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    if (!hasServices) {
+      return function native_s2b_p(req, res, params) {
+        try {
+          if (!vp(params)) {
+            fastWrite400("params", vp.errors, res);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req, params });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, toJsonBody(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, toJsonBody(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    return function native_s2b_p_svc(req, res, params) {
+      try {
+        if (!vp(params)) {
+          fastWrite400("params", vp.errors, res);
+          return;
+        }
+        const result = handlerIgnoresArgs ? handler() : handler({ req, params, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => fastWriteJson(res, toJsonBody(r)),
+            (err) => fastWriteError(err, res)
+          );
+          return;
+        }
+        fastWriteJson(res, toJsonBody(result));
+      } catch (err) {
+        fastWriteError(err, res);
+      }
+    };
+  }
+  if (hasQuery && hasParams && !hasBody) {
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function native_s2c_qp_ser(req, res, params) {
+          try {
+            const query = parseNativeQuery(req.url ?? "/");
+            if (!vq(query)) {
+              fastWrite400("query", vq.errors, res);
+              return;
+            }
+            if (!vp(params)) {
+              fastWrite400("params", vp.errors, res);
+              return;
+            }
+            const result = handlerIgnoresArgs ? handler() : handler({ req, query, params });
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => fastWriteJson(res, ser(r)),
+                (err) => fastWriteError(err, res)
+              );
+              return;
+            }
+            fastWriteJson(res, ser(result));
+          } catch (err) {
+            fastWriteError(err, res);
+          }
+        };
+      }
+      return function native_s2c_qp_svc_ser(req, res, params) {
+        try {
+          const query = parseNativeQuery(req.url ?? "/");
+          if (!vq(query)) {
+            fastWrite400("query", vq.errors, res);
+            return;
+          }
+          if (!vp(params)) {
+            fastWrite400("params", vp.errors, res);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req, query, params, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, ser(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, ser(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    if (!hasServices) {
+      return function native_s2c_qp(req, res, params) {
+        try {
+          const query = parseNativeQuery(req.url ?? "/");
+          if (!vq(query)) {
+            fastWrite400("query", vq.errors, res);
+            return;
+          }
+          if (!vp(params)) {
+            fastWrite400("params", vp.errors, res);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req, query, params });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => fastWriteJson(res, toJsonBody(r)),
+              (err) => fastWriteError(err, res)
+            );
+            return;
+          }
+          fastWriteJson(res, toJsonBody(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    return function native_s2c_qp_svc(req, res, params) {
+      try {
+        const query = parseNativeQuery(req.url ?? "/");
+        if (!vq(query)) {
+          fastWrite400("query", vq.errors, res);
+          return;
+        }
+        if (!vp(params)) {
+          fastWrite400("params", vp.errors, res);
+          return;
+        }
+        const result = handlerIgnoresArgs ? handler() : handler({ req, query, params, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => fastWriteJson(res, toJsonBody(r)),
+            (err) => fastWriteError(err, res)
+          );
+          return;
+        }
+        fastWriteJson(res, toJsonBody(result));
+      } catch (err) {
+        fastWriteError(err, res);
+      }
+    };
+  }
+  if (hasBody && hasSer) {
+    const vb = validateBody;
+    const ser = serialize;
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (!hasServices) {
+      return async function native_s3_body_ser(req, res, params) {
+        try {
+          const body = await readNativeBody(req);
+          if (!vb(body)) {
+            fastWrite400("body", vb.errors, res);
+            return;
+          }
+          let query;
+          if (vq) {
+            query = parseNativeQuery(req.url ?? "/");
+            if (!vq(query)) {
+              fastWrite400("query", vq.errors, res);
+              return;
+            }
+          }
+          if (vp && !vp(params)) {
+            fastWrite400("params", vp.errors, res);
+            return;
+          }
+          const result = await handler({ req, body, query, params });
+          fastWriteJson(res, ser(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    return async function native_s3_body_ser_svc(req, res, params) {
+      try {
+        const body = await readNativeBody(req);
+        if (!vb(body)) {
+          fastWrite400("body", vb.errors, res);
+          return;
+        }
+        let query;
+        if (vq) {
+          query = parseNativeQuery(req.url ?? "/");
+          if (!vq(query)) {
+            fastWrite400("query", vq.errors, res);
+            return;
+          }
+        }
+        if (vp && !vp(params)) {
+          fastWrite400("params", vp.errors, res);
+          return;
+        }
+        const result = await handler({ req, body, query, params, services });
+        fastWriteJson(res, ser(result));
+      } catch (err) {
+        fastWriteError(err, res);
+      }
+    };
+  }
+  if (hasBody && !hasSer) {
+    const vb = validateBody;
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (!hasServices) {
+      return async function native_s4_body_noser(req, res, params) {
+        try {
+          const body = await readNativeBody(req);
+          if (!vb(body)) {
+            fastWrite400("body", vb.errors, res);
+            return;
+          }
+          let query;
+          if (vq) {
+            query = parseNativeQuery(req.url ?? "/");
+            if (!vq(query)) {
+              fastWrite400("query", vq.errors, res);
+              return;
+            }
+          }
+          if (vp && !vp(params)) {
+            fastWrite400("params", vp.errors, res);
+            return;
+          }
+          const result = await handler({ req, body, query, params });
+          fastWriteJson(res, toJsonBody(result));
+        } catch (err) {
+          fastWriteError(err, res);
+        }
+      };
+    }
+    return async function native_s4_body_noser_svc(req, res, params) {
+      try {
+        const body = await readNativeBody(req);
+        if (!vb(body)) {
+          fastWrite400("body", vb.errors, res);
+          return;
+        }
+        let query;
+        if (vq) {
+          query = parseNativeQuery(req.url ?? "/");
+          if (!vq(query)) {
+            fastWrite400("query", vq.errors, res);
+            return;
+          }
+        }
+        if (vp && !vp(params)) {
+          fastWrite400("params", vp.errors, res);
+          return;
+        }
+        const result = await handler({ req, body, query, params, services });
+        fastWriteJson(res, toJsonBody(result));
+      } catch (err) {
+        fastWriteError(err, res);
+      }
+    };
+  }
+  return function native_fallback(req, res, _p) {
+    fastWriteError(new Error("Route scenario not implemented"), res);
+  };
+}
+function compileUwsNativeHandler(handler, schema, services, compiled) {
+  const { validateBody, validateQuery, validateParams, serialize } = compiled;
+  const hasServices = services != null && Object.keys(services).length > 0;
+  const hasQuery = !!validateQuery;
+  const hasParams = !!validateParams;
+  const hasBody = !!validateBody;
+  const hasSer = !!serialize;
+  const handlerIgnoresArgs = handler.length === 0;
+  if (!hasBody && !hasQuery && !hasParams && !hasServices) {
+    if (hasSer) {
+      const ser = serialize;
+      if (handlerIgnoresArgs) {
+        return function uws_s1_bare_ser_noargs(uwsRes, _url, _raw, _p) {
+          try {
+            const result = handler();
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => uwsFastWriteJson(uwsRes, ser(r)),
+                (err) => uwsFastWriteError(err, uwsRes)
+              );
+              return;
+            }
+            uwsFastWriteJson(uwsRes, ser(result));
+          } catch (err) {
+            uwsFastWriteError(err, uwsRes);
+          }
+        };
+      }
+      return function uws_s1_bare_ser(uwsRes, url, _raw, _p) {
+        try {
+          const result = handler({ req: { url } });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, ser(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, ser(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    if (handlerIgnoresArgs) {
+      return function uws_s1_bare_noargs(uwsRes, _url, _raw, _p) {
+        try {
+          const result = handler();
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, toJsonBody(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    return function uws_s1_bare(uwsRes, url, _raw, _p) {
+      try {
+        const result = handler({ req: { url } });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+            (err) => uwsFastWriteError(err, uwsRes)
+          );
+          return;
+        }
+        uwsFastWriteJson(uwsRes, toJsonBody(result));
+      } catch (err) {
+        uwsFastWriteError(err, uwsRes);
+      }
+    };
+  }
+  if (!hasBody && !hasQuery && !hasParams && hasServices) {
+    if (hasSer) {
+      const ser = serialize;
+      if (handlerIgnoresArgs) {
+        return function uws_s1b_svc_ser_noargs(uwsRes, _url, _raw, _p) {
+          try {
+            const result = handler();
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => uwsFastWriteJson(uwsRes, ser(r)),
+                (err) => uwsFastWriteError(err, uwsRes)
+              );
+              return;
+            }
+            uwsFastWriteJson(uwsRes, ser(result));
+          } catch (err) {
+            uwsFastWriteError(err, uwsRes);
+          }
+        };
+      }
+      return function uws_s1b_svc_ser(uwsRes, url, _raw, _p) {
+        try {
+          const result = handler({ req: { url }, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, ser(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, ser(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    if (handlerIgnoresArgs) {
+      return function uws_s1b_svc_noargs(uwsRes, _url, _raw, _p) {
+        try {
+          const result = handler();
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, toJsonBody(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    return function uws_s1b_svc(uwsRes, url, _raw, _p) {
+      try {
+        const result = handler({ req: { url }, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+            (err) => uwsFastWriteError(err, uwsRes)
+          );
+          return;
+        }
+        uwsFastWriteJson(uwsRes, toJsonBody(result));
+      } catch (err) {
+        uwsFastWriteError(err, uwsRes);
+      }
+    };
+  }
+  if (hasQuery && !hasParams && !hasBody) {
+    const vq = validateQuery;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function uws_s2a_q_ser(uwsRes, url, _raw, _p) {
+          try {
+            const query = parseNativeQuery(url);
+            if (!vq(query)) {
+              uwsFastWrite400("query", vq.errors, uwsRes);
+              return;
+            }
+            const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query });
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => uwsFastWriteJson(uwsRes, ser(r)),
+                (err) => uwsFastWriteError(err, uwsRes)
+              );
+              return;
+            }
+            uwsFastWriteJson(uwsRes, ser(result));
+          } catch (err) {
+            uwsFastWriteError(err, uwsRes);
+          }
+        };
+      }
+      return function uws_s2a_q_svc_ser(uwsRes, url, _raw, _p) {
+        try {
+          const query = parseNativeQuery(url);
+          if (!vq(query)) {
+            uwsFastWrite400("query", vq.errors, uwsRes);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, ser(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, ser(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    if (!hasServices) {
+      return function uws_s2a_q(uwsRes, url, _raw, _p) {
+        try {
+          const query = parseNativeQuery(url);
+          if (!vq(query)) {
+            uwsFastWrite400("query", vq.errors, uwsRes);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, toJsonBody(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    return function uws_s2a_q_svc(uwsRes, url, _raw, _p) {
+      try {
+        const query = parseNativeQuery(url);
+        if (!vq(query)) {
+          uwsFastWrite400("query", vq.errors, uwsRes);
+          return;
+        }
+        const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+            (err) => uwsFastWriteError(err, uwsRes)
+          );
+          return;
+        }
+        uwsFastWriteJson(uwsRes, toJsonBody(result));
+      } catch (err) {
+        uwsFastWriteError(err, uwsRes);
+      }
+    };
+  }
+  if (hasParams && !hasQuery && !hasBody) {
+    const vp = validateParams;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function uws_s2b_p_ser(uwsRes, url, _raw, params) {
+          try {
+            if (!vp(params)) {
+              uwsFastWrite400("params", vp.errors, uwsRes);
+              return;
+            }
+            const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, params });
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => uwsFastWriteJson(uwsRes, ser(r)),
+                (err) => uwsFastWriteError(err, uwsRes)
+              );
+              return;
+            }
+            uwsFastWriteJson(uwsRes, ser(result));
+          } catch (err) {
+            uwsFastWriteError(err, uwsRes);
+          }
+        };
+      }
+      return function uws_s2b_p_svc_ser(uwsRes, url, _raw, params) {
+        try {
+          if (!vp(params)) {
+            uwsFastWrite400("params", vp.errors, uwsRes);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, params, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, ser(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, ser(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    if (!hasServices) {
+      return function uws_s2b_p(uwsRes, url, _raw, params) {
+        try {
+          if (!vp(params)) {
+            uwsFastWrite400("params", vp.errors, uwsRes);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, params });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, toJsonBody(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    return function uws_s2b_p_svc(uwsRes, url, _raw, params) {
+      try {
+        if (!vp(params)) {
+          uwsFastWrite400("params", vp.errors, uwsRes);
+          return;
+        }
+        const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, params, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+            (err) => uwsFastWriteError(err, uwsRes)
+          );
+          return;
+        }
+        uwsFastWriteJson(uwsRes, toJsonBody(result));
+      } catch (err) {
+        uwsFastWriteError(err, uwsRes);
+      }
+    };
+  }
+  if (hasQuery && hasParams && !hasBody) {
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (hasSer) {
+      const ser = serialize;
+      if (!hasServices) {
+        return function uws_s2c_qp_ser(uwsRes, url, _raw, params) {
+          try {
+            const query = parseNativeQuery(url);
+            if (!vq(query)) {
+              uwsFastWrite400("query", vq.errors, uwsRes);
+              return;
+            }
+            if (!vp(params)) {
+              uwsFastWrite400("params", vp.errors, uwsRes);
+              return;
+            }
+            const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query, params });
+            if (result != null && typeof result.then === "function") {
+              result.then(
+                (r) => uwsFastWriteJson(uwsRes, ser(r)),
+                (err) => uwsFastWriteError(err, uwsRes)
+              );
+              return;
+            }
+            uwsFastWriteJson(uwsRes, ser(result));
+          } catch (err) {
+            uwsFastWriteError(err, uwsRes);
+          }
+        };
+      }
+      return function uws_s2c_qp_svc_ser(uwsRes, url, _raw, params) {
+        try {
+          const query = parseNativeQuery(url);
+          if (!vq(query)) {
+            uwsFastWrite400("query", vq.errors, uwsRes);
+            return;
+          }
+          if (!vp(params)) {
+            uwsFastWrite400("params", vp.errors, uwsRes);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query, params, services });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, ser(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, ser(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    if (!hasServices) {
+      return function uws_s2c_qp(uwsRes, url, _raw, params) {
+        try {
+          const query = parseNativeQuery(url);
+          if (!vq(query)) {
+            uwsFastWrite400("query", vq.errors, uwsRes);
+            return;
+          }
+          if (!vp(params)) {
+            uwsFastWrite400("params", vp.errors, uwsRes);
+            return;
+          }
+          const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query, params });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, toJsonBody(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    return function uws_s2c_qp_svc(uwsRes, url, _raw, params) {
+      try {
+        const query = parseNativeQuery(url);
+        if (!vq(query)) {
+          uwsFastWrite400("query", vq.errors, uwsRes);
+          return;
+        }
+        if (!vp(params)) {
+          uwsFastWrite400("params", vp.errors, uwsRes);
+          return;
+        }
+        const result = handlerIgnoresArgs ? handler() : handler({ req: { url }, query, params, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+            (err) => uwsFastWriteError(err, uwsRes)
+          );
+          return;
+        }
+        uwsFastWriteJson(uwsRes, toJsonBody(result));
+      } catch (err) {
+        uwsFastWriteError(err, uwsRes);
+      }
+    };
+  }
+  if (hasBody && hasSer) {
+    const vb = validateBody;
+    const ser = serialize;
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (!hasServices) {
+      return function uws_s3_body_ser(uwsRes, url, rawBody, params) {
+        try {
+          let body;
+          try {
+            body = rawBody ? JSON.parse(rawBody) : {};
+          } catch {
+            body = {};
+          }
+          if (!vb(body)) {
+            uwsFastWrite400("body", vb.errors, uwsRes);
+            return;
+          }
+          let query;
+          if (vq) {
+            query = parseNativeQuery(url);
+            if (!vq(query)) {
+              uwsFastWrite400("query", vq.errors, uwsRes);
+              return;
+            }
+          }
+          if (vp && !vp(params)) {
+            uwsFastWrite400("params", vp.errors, uwsRes);
+            return;
+          }
+          const result = handler({ req: { url }, body, query, params });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, ser(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, ser(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    return function uws_s3_body_ser_svc(uwsRes, url, rawBody, params) {
+      try {
+        let body;
+        try {
+          body = rawBody ? JSON.parse(rawBody) : {};
+        } catch {
+          body = {};
+        }
+        if (!vb(body)) {
+          uwsFastWrite400("body", vb.errors, uwsRes);
+          return;
+        }
+        let query;
+        if (vq) {
+          query = parseNativeQuery(url);
+          if (!vq(query)) {
+            uwsFastWrite400("query", vq.errors, uwsRes);
+            return;
+          }
+        }
+        if (vp && !vp(params)) {
+          uwsFastWrite400("params", vp.errors, uwsRes);
+          return;
+        }
+        const result = handler({ req: { url }, body, query, params, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => uwsFastWriteJson(uwsRes, ser(r)),
+            (err) => uwsFastWriteError(err, uwsRes)
+          );
+          return;
+        }
+        uwsFastWriteJson(uwsRes, ser(result));
+      } catch (err) {
+        uwsFastWriteError(err, uwsRes);
+      }
+    };
+  }
+  if (hasBody && !hasSer) {
+    const vb = validateBody;
+    const vq = validateQuery;
+    const vp = validateParams;
+    if (!hasServices) {
+      return function uws_s4_body_noser(uwsRes, url, rawBody, params) {
+        try {
+          let body;
+          try {
+            body = rawBody ? JSON.parse(rawBody) : {};
+          } catch {
+            body = {};
+          }
+          if (!vb(body)) {
+            uwsFastWrite400("body", vb.errors, uwsRes);
+            return;
+          }
+          let query;
+          if (vq) {
+            query = parseNativeQuery(url);
+            if (!vq(query)) {
+              uwsFastWrite400("query", vq.errors, uwsRes);
+              return;
+            }
+          }
+          if (vp && !vp(params)) {
+            uwsFastWrite400("params", vp.errors, uwsRes);
+            return;
+          }
+          const result = handler({ req: { url }, body, query, params });
+          if (result != null && typeof result.then === "function") {
+            result.then(
+              (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+              (err) => uwsFastWriteError(err, uwsRes)
+            );
+            return;
+          }
+          uwsFastWriteJson(uwsRes, toJsonBody(result));
+        } catch (err) {
+          uwsFastWriteError(err, uwsRes);
+        }
+      };
+    }
+    return function uws_s4_body_noser_svc(uwsRes, url, rawBody, params) {
+      try {
+        let body;
+        try {
+          body = rawBody ? JSON.parse(rawBody) : {};
+        } catch {
+          body = {};
+        }
+        if (!vb(body)) {
+          uwsFastWrite400("body", vb.errors, uwsRes);
+          return;
+        }
+        let query;
+        if (vq) {
+          query = parseNativeQuery(url);
+          if (!vq(query)) {
+            uwsFastWrite400("query", vq.errors, uwsRes);
+            return;
+          }
+        }
+        if (vp && !vp(params)) {
+          uwsFastWrite400("params", vp.errors, uwsRes);
+          return;
+        }
+        const result = handler({ req: { url }, body, query, params, services });
+        if (result != null && typeof result.then === "function") {
+          result.then(
+            (r) => uwsFastWriteJson(uwsRes, toJsonBody(r)),
+            (err) => uwsFastWriteError(err, uwsRes)
+          );
+          return;
+        }
+        uwsFastWriteJson(uwsRes, toJsonBody(result));
+      } catch (err) {
+        uwsFastWriteError(err, uwsRes);
+      }
+    };
+  }
+  return function uws_fallback(uwsRes, _url, _raw, _p) {
+    uwsFastWriteError(new Error("Route scenario not implemented"), uwsRes);
+  };
+}
+
+// src/shutdown.ts
+function createInflightTracker() {
+  return {
+    count: 0,
+    requests: /* @__PURE__ */ new Set()
+  };
+}
+function trackRequest(tracker) {
+  tracker.count++;
+  let resolvePromise;
+  const promise = new Promise((resolve2) => {
+    resolvePromise = resolve2;
+  });
+  tracker.requests.add(promise);
+  return () => {
+    tracker.count--;
+    tracker.requests.delete(promise);
+    resolvePromise();
+  };
+}
+var ShutdownManager = class {
+  state = "running";
+  abortController = null;
+  server = null;
+  tracker;
+  database = null;
+  databaseProvider = null;
+  constructor() {
+    this.tracker = createInflightTracker();
+  }
+  /**
+   * Get current shutdown state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if server is shutting down
+   */
+  isShuttingDown() {
+    return this.state !== "running";
+  }
+  /**
+   * Get current in-flight request count
+   */
+  getInflightCount() {
+    return this.tracker.count;
+  }
+  /**
+   * Set the server instance for shutdown
+   */
+  setServer(server) {
+    this.server = server;
+  }
+  /**
+   * Set database for cleanup
+   */
+  setDatabase(db, provider) {
+    this.database = db;
+    this.databaseProvider = provider;
+  }
+  /**
+   * Get the AbortController signal for request cancellation
+   */
+  getAbortSignal() {
+    return this.abortController?.signal;
+  }
+  /**
+   * Create a request tracker middleware
+   * Returns an untrack function to call when request completes
+   */
+  trackRequest() {
+    return trackRequest(this.tracker);
+  }
+  /**
+   * Initiate graceful shutdown
+   */
+  async shutdown(options = {}) {
+    const {
+      timeoutMs = 3e4,
+      onShutdownStart,
+      onShutdownComplete,
+      onShutdownTimeout
+    } = options;
+    if (this.state === "shutdown") {
+      console.warn("[Kozo] Shutdown already completed");
+      return;
+    }
+    if (this.state === "shutting-down") {
+      console.warn("[Kozo] Shutdown already in progress");
+      return;
+    }
+    this.state = "shutting-down";
+    this.abortController = new AbortController();
+    this.abortController.abort();
+    const inflightCount = this.tracker.count;
+    onShutdownStart?.(inflightCount);
+    if (inflightCount > 0) {
+      console.log(`[Kozo] Graceful shutdown: waiting for ${inflightCount} in-flight requests`);
+    }
+    if (this.server) {
+      this.server.close(() => {
+        console.log("[Kozo] HTTP server closed");
+      });
+    }
+    const drainPromise = this.drainRequests();
+    const timeoutPromise = new Promise((resolve2) => {
+      setTimeout(() => {
+        onShutdownTimeout?.(this.tracker.count);
+        resolve2();
+      }, timeoutMs);
+    });
+    await Promise.race([drainPromise, timeoutPromise]);
+    await this.closeDatabase();
+    this.state = "shutdown";
+    onShutdownComplete?.();
+    console.log("[Kozo] Graceful shutdown complete");
+  }
+  /**
+   * Wait for all in-flight requests to complete
+   */
+  async drainRequests() {
+    if (this.tracker.requests.size === 0) {
+      return;
+    }
+    await Promise.all([...this.tracker.requests]);
+  }
+  /**
+   * Close database connections based on provider
+   */
+  async closeDatabase() {
+    if (!this.database || !this.databaseProvider) {
+      return;
+    }
+    try {
+      switch (this.databaseProvider) {
+        case "postgresql": {
+          const client = this.database.$client;
+          if (client && typeof client.end === "function") {
+            await client.end();
+            console.log("[Kozo] PostgreSQL connection closed");
+          }
+          break;
+        }
+        case "mysql": {
+          const client = this.database.$client;
+          if (client && typeof client.end === "function") {
+            await client.end();
+            console.log("[Kozo] MySQL connection closed");
+          }
+          break;
+        }
+        case "sqlite": {
+          const client = this.database.$client;
+          if (client && typeof client.close === "function") {
+            client.close();
+            console.log("[Kozo] SQLite connection closed");
+          }
+          break;
+        }
+      }
+    } catch (err) {
+      console.error("[Kozo] Error closing database connection:", err);
+    }
+  }
+};
+function createShutdownManager() {
+  return new ShutdownManager();
+}
+
+// src/router.ts
+import { glob } from "glob";
+import { join } from "path";
+import { pathToFileURL } from "url";
+
+// src/utils/file-to-path.ts
+import { parse } from "path";
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+function fileToPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const parsed = parse(normalized);
+  const filename = parsed.name.toLowerCase();
+  let method = "get";
+  let includeName = true;
+  if (HTTP_METHODS.includes(filename)) {
+    method = filename;
+    includeName = false;
+  } else if (filename === "index") {
+    includeName = false;
+  }
+  let segments = parsed.dir ? parsed.dir.split("/").filter(Boolean) : [];
+  if (includeName) {
+    segments.push(parsed.name);
+  }
+  const urlSegments = segments.map((segment) => {
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      return "*";
+    }
+    if (segment.startsWith("[") && segment.endsWith("?]")) {
+      return ":" + segment.slice(1, -2) + "?";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]")) {
+      return ":" + segment.slice(1, -1);
+    }
+    return segment;
+  });
+  let path = "/" + urlSegments.join("/");
+  path = path.replace(/\/+/g, "/");
+  if (path.length > 1 && path.endsWith("/")) {
+    path = path.slice(0, -1);
+  }
+  return { path, method };
+}
+function isRouteFile(filename) {
+  const segments = filename.replace(/\\/g, "/").split("/");
+  if (segments.some((s) => s.startsWith("_"))) return false;
+  if (filename.includes(".test.") || filename.includes(".spec.")) return false;
+  return filename.endsWith(".ts") || filename.endsWith(".js");
+}
+
+// src/router.ts
+async function scanRoutes(options) {
+  const { routesDir, verbose = true } = options;
+  const routes = [];
+  if (verbose) {
+    console.log(`
+\u{1F50D} Scanning routes in: ${routesDir}
+`);
+  }
+  const pattern = "**/*.{ts,js}";
+  const files = await glob(pattern, {
+    cwd: routesDir,
+    nodir: true,
+    ignore: ["**/_*.ts", "**/_*.js", "**/*.test.ts", "**/*.spec.ts"]
+  });
+  for (const file of files) {
+    if (!isRouteFile(file)) continue;
+    const parsed = fileToPath(file);
+    if (!parsed) continue;
+    const fullPath = join(routesDir, file);
+    try {
+      const fileUrl = pathToFileURL(fullPath).href;
+      const module = await import(fileUrl);
+      if (typeof module.default !== "function") {
+        console.warn(`\u26A0\uFE0F  Skipping ${file}: no default export function`);
+        continue;
+      }
+      routes.push({
+        path: parsed.path,
+        method: parsed.method,
+        filePath: fullPath,
+        module
+      });
+      if (verbose) {
+        const methodLabel = parsed.method.toUpperCase().padEnd(6);
+        console.log(`   ${methodLabel} ${parsed.path}`);
+      }
+    } catch (err) {
+      console.error(`\u274C Failed to load route: ${file}`);
+      console.error(err);
+    }
+  }
+  if (verbose) {
+    console.log(`
+\u2705 Loaded ${routes.length} routes
+`);
+  }
+  routes.sort((a, b) => {
+    const aScore = routeScore(a.path);
+    const bScore = routeScore(b.path);
+    return bScore - aScore;
+  });
+  return routes;
+}
+function routeScore(path) {
+  const segments = path.split("/").filter(Boolean);
+  let score = segments.length * 10;
+  for (const segment of segments) {
+    if (segment === "*") {
+      score -= 100;
+    } else if (segment.startsWith(":")) {
+      score -= 5;
+    } else {
+      score += 1;
+    }
+  }
+  return score;
+}
+
+// src/wasm-router.ts
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { dirname, join as join2 } from "path";
+var METHOD_INDEX = {
+  GET: 0,
+  POST: 1,
+  PUT: 2,
+  PATCH: 3,
+  DELETE: 4,
+  OPTIONS: 5,
+  HEAD: 6
+};
+function methodToIndex(m) {
+  switch (m.length) {
+    case 3:
+      return m.charCodeAt(0) === 71 ? 0 : 2;
+    case 4:
+      return m.charCodeAt(0) === 80 ? 1 : 6;
+    case 5:
+      return 3;
+    case 6:
+      return 4;
+    case 7:
+      return 5;
+    default:
+      return METHOD_INDEX[m] ?? -1;
+  }
+}
+var WasmRadixRouter = class {
+  exports = null;
+  urlView = null;
+  paramView = null;
+  patternView = null;
+  // v2: plain arrays indexed by route_id — O(1) with no hash overhead
+  handlers = [];
+  paramNames = [];
+  /** monotonic route counter */
+  nextRouteId = 0;
+  /** whether the WASM module loaded successfully */
+  ready = false;
+  // v3: pre-allocated match result — reused across calls to avoid allocation.
+  // Safe because dispatch() reads result synchronously and never stores it.
+  _emptyParams = Object.freeze({});
+  // ── Lifecycle ─────────────────────────────────────────────────────────
+  /**
+   * Attempt to load and instantiate the WASM module.
+   * Returns `true` on success, `false` if the .wasm file is missing or
+   * instantiation fails (caller should fall back to JS routing).
+   */
+  async init() {
+    try {
+      const thisDir = dirname(fileURLToPath(import.meta.url));
+      const wasmPath = join2(thisDir, "wasm", "radix.wasm");
+      const wasmBytes = await readFile(wasmPath);
+      const { instance } = await WebAssembly.instantiate(wasmBytes);
+      this.exports = instance.exports;
+      const mem = this.exports.memory;
+      const urlPtr = this.exports.get_url_buf_ptr();
+      const paramPtr = this.exports.get_param_buf_ptr();
+      const patPtr = this.exports.get_pattern_buf_ptr();
+      this.urlView = new Uint8Array(mem.buffer, urlPtr, 4096);
+      this.paramView = new DataView(mem.buffer, paramPtr, 32);
+      this.patternView = new Uint8Array(mem.buffer, patPtr, 2048);
+      this.exports.init();
+      this.ready = true;
+      return true;
+    } catch {
+      this.ready = false;
+      return false;
+    }
+  }
+  /** Is the WASM module loaded and operational? */
+  get isReady() {
+    return this.ready;
+  }
+  // ── Route registration (called at startup, not hot-path) ──────────────
+  /**
+   * Register a route in the WASM radix trie.
+   *
+   * @param method  HTTP method (GET, POST, …)
+   * @param path    Express-style pattern, e.g. `/api/users/:id` or `/blog/*`
+   * @param handler Compiled native handler (same type used by nativeListen)
+   * @returns       The assigned route ID
+   */
+  addRoute(method, path, handler) {
+    if (!this.ready) throw new Error("WasmRadixRouter not initialized");
+    const routeId = this.nextRouteId++;
+    const methodIdx = METHOD_INDEX[method.toUpperCase()];
+    if (methodIdx === void 0) throw new Error(`Unsupported method: ${method}`);
+    const names = [];
+    const segments = path.split("/");
+    for (const seg of segments) {
+      if (seg.startsWith(":")) names.push(seg.slice(1));
+      else if (seg === "*") names.push("*");
+    }
+    this.paramNames[routeId] = names;
+    this.handlers[routeId] = handler;
+    const patLen = this.writeAscii(this.patternView, path);
+    this.exports.insert_route(methodIdx, patLen, routeId);
+    return routeId;
+  }
+  // ── Hot-path matching ─────────────────────────────────────────────────
+  /**
+   * Match a request path against the radix trie.
+   *
+   * ZERO-COPY: the path string is written byte-by-byte into WASM memory
+   * without allocating a Buffer or Uint8Array.  Param values are read
+   * back as slices of the **original JS string** (the offsets produced by
+   * WASM coincide with JS character indices for ASCII paths).
+   *
+   * v3: Returns a pre-allocated result object that is reused across calls.
+   * For static routes (paramCount === 0), the params object is a frozen
+   * singleton — ZERO allocations per request on the hot path.
+   *
+   * @returns `null` on miss; otherwise the handler + extracted params.
+   */
+  match(method, path) {
+    const methodIdx = methodToIndex(method);
+    if (methodIdx === -1) return null;
+    const urlView = this.urlView;
+    const len = path.length;
+    for (let i = 0; i < len; i++) {
+      urlView[i] = path.charCodeAt(i);
+    }
+    const routeId = this.exports.match_url(methodIdx, len);
+    if (routeId === -1) return null;
+    const handler = this.handlers[routeId];
+    if (!handler) return null;
+    const paramCount = this.exports.get_param_count();
+    if (paramCount === 0) {
+      return { handler, params: this._emptyParams };
+    }
+    const names = this.paramNames[routeId];
+    const params = {};
+    const pv = this.paramView;
+    for (let i = 0; i < paramCount && i < names.length; i++) {
+      const byteOff = i * 4;
+      const offset = pv.getUint16(byteOff, true);
+      const plen = pv.getUint16(byteOff + 2, true);
+      params[names[i]] = path.slice(offset, offset + plen);
+    }
+    return { handler, params };
+  }
+  // ── Exposed internals for inline dispatch in app.ts ────────────────────
+  /**
+   * Expose raw WASM buffers + handler arrays for zero-overhead inline
+   * dispatch in app.ts.  Avoids the match() → WasmMatchResult wrapper
+   * allocation on dynamic routes (~30-50 ns saved per request).
+   *
+   * SAFETY: single-threaded — no concurrent access.
+   */
+  getInternals() {
+    return {
+      urlView: this.urlView,
+      exports: this.exports,
+      handlers: this.handlers,
+      paramNames: this.paramNames,
+      paramView: this.paramView,
+      emptyParams: this._emptyParams
+    };
+  }
+  // ── Internals ─────────────────────────────────────────────────────────
+  /**
+   * Fast ASCII write — avoids TextEncoder allocation overhead (~50 ns).
+   * URL paths are always ASCII, so charCodeAt() is byte-identical.
+   */
+  writeAscii(view, str) {
+    const len = str.length;
+    for (let i = 0; i < len; i++) {
+      view[i] = str.charCodeAt(i);
+    }
+    return len;
+  }
+};
+
+// src/app.ts
+var Kozo = class {
+  app;
+  services;
+  routes = [];
+  nativeRoutes = [];
+  shutdownManager = new ShutdownManager();
+  wasmRouter = new WasmRadixRouter();
+  /** Maps each NativeRouteHandler to its zero-shim uWS counterpart */
+  uwsHandlerMap = /* @__PURE__ */ new Map();
+  _routesDir;
+  constructor(config = {}) {
+    this.app = new Hono();
+    this.services = config.services ?? {};
+    this._routesDir = config.routesDir;
+    this.app.onError((err, c) => {
+      if (err instanceof KozoError) {
+        return err.toResponse(c.req.path);
+      }
+      console.error("[Kozo] Unhandled error:", err);
+      return internalErrorResponse(err, c.req.path);
+    });
+  }
+  // Plugin system
+  use(plugin) {
     plugin.install(this);
     return this;
   }
+  /**
+   * Load routes from the file system using the configured routesDir.
+   * Each route file is dynamically imported, its schema compiled, and handler registered.
+   * This is a no-op if routesDir is not configured.
+   */
+  async loadRoutes(routesDir) {
+    const dir = routesDir ?? this._routesDir;
+    if (!dir) return this;
+    const routes = await scanRoutes({ routesDir: dir, verbose: false });
+    for (const route of routes) {
+      const { path, method, module } = route;
+      const schema = module.schema ?? {};
+      const compiled = SchemaCompiler.compile(schema);
+      const userHandler = module.default;
+      const optimizedHandler = compileRouteHandler(
+        (ctx) => userHandler(ctx),
+        schema,
+        this.services,
+        compiled
+      );
+      this.routes.push({ method, path, schema });
+      this.app[method](path, optimizedHandler);
+    }
+    return this;
+  }
   generateClient(baseUrlOrOptions) {
     const options = typeof baseUrlOrOptions === "string" ? { baseUrl: baseUrlOrOptions, includeValidation: false } : baseUrlOrOptions || {};
     const routeInfos = this.routes.map((r) => ({
@@ -637,19 +2940,19 @@ var Kozo = class {
     return generateTypedClient(routeInfos, options);
   }
   get(path, schema, handler) {
-    this.register("get", path, schema, handler);
+    return this.register("get", path, schema, handler);
   }
   post(path, schema, handler) {
-    this.register("post", path, schema, handler);
+    return this.register("post", path, schema, handler);
   }
   put(path, schema, handler) {
-    this.register("put", path, schema, handler);
+    return this.register("put", path, schema, handler);
   }
   patch(path, schema, handler) {
-    this.register("patch", path, schema, handler);
+    return this.register("patch", path, schema, handler);
   }
   delete(path, schema, handler) {
-    this.register("delete", path, schema, handler);
+    return this.register("delete", path, schema, handler);
   }
   register(method, path, schema, handler) {
     this.routes.push({ method, path, schema });
@@ -661,15 +2964,191 @@ var Kozo = class {
       compiled
     );
     this.app[method](path, optimizedHandler);
+    const nativeHandler = compileNativeHandler(handler, schema, this.services, compiled);
+    const uwsHandler = compileUwsNativeHandler(handler, schema, this.services, compiled);
+    this.uwsHandlerMap.set(nativeHandler, uwsHandler);
+    const paramNames = [];
+    const regexStr = path.replace(/:([^/]+)/g, (_, name) => {
+      paramNames.push(name);
+      return "([^/]+)";
+    });
+    if (paramNames.length === 0) {
+      this.nativeRoutes.push({ method: method.toUpperCase(), path, staticPath: path, handler: nativeHandler });
+    } else {
+      this.nativeRoutes.push({
+        method: method.toUpperCase(),
+        path,
+        regex: new RegExp(`^${regexStr}$`),
+        paramNames,
+        handler: nativeHandler
+      });
+    }
+    return this;
+  }
+  /**
+   * Start a raw Node.js HTTP server (no @hono/node-server adapter).
+   * Writes directly to ServerResponse — eliminates Web API Request/Response
+   * allocation and adapter overhead for maximum throughput.
+   *
+   * When the Zig WASM radix trie is available (`src/wasm/radix.wasm`),
+   * ALL route matching (static + dynamic) runs through the zero-copy
+   * trie — one call into WASM per request.
+   *
+   * When the .wasm file is absent (Edge deploy, CI without Zig, etc.)
+   * routing falls back transparently to the JS Map + RegExp approach.
+   *
+   * Returns { port, server } so the caller can close the server when done.
+   */
+  async nativeListen(port = 3e3) {
+    const wasmOk = await this.wasmRouter.init();
+    if (wasmOk) {
+      for (const entry of this.nativeRoutes) {
+        const path = entry.staticPath ?? entry.regex?.source.replace(/^\^/, "").replace(/\$$/, "").replace(/\(\[\\^\/\]\+\)/g, () => `:${entry.paramNames?.shift() ?? "p"}`) ?? "/";
+        this.wasmRouter.addRoute(entry.method, entry.staticPath ?? path, entry.handler);
+      }
+      console.log("\u26A1 WASM radix router active (zero-copy Zig trie)");
+    } else {
+      console.log("\u2139\uFE0F  WASM radix router unavailable \u2014 using JS fallback");
+    }
+    const staticMap = /* @__PURE__ */ new Map();
+    const dynamicRoutes = [];
+    for (const entry of this.nativeRoutes) {
+      if (entry.staticPath !== void 0) {
+        staticMap.set(`${entry.method}:${entry.staticPath}`, entry.handler);
+      } else {
+        dynamicRoutes.push({
+          method: entry.method,
+          regex: entry.regex,
+          paramNames: entry.paramNames,
+          handler: entry.handler
+        });
+      }
+    }
+    const wasm = wasmOk ? this.wasmRouter : null;
+    const emptyParams = Object.freeze({});
+    const matchRoute = (method, path) => {
+      if (wasm) {
+        const r = wasm.match(method, path);
+        if (r) return { handler: r.handler, params: r.params };
+        return null;
+      }
+      const staticHandler = staticMap.get(`${method}:${path}`);
+      if (staticHandler) return { handler: staticHandler, params: emptyParams };
+      for (const route of dynamicRoutes) {
+        if (route.method !== method) continue;
+        const m = route.regex.exec(path);
+        if (!m) continue;
+        const params = {};
+        for (let i = 0; i < route.paramNames.length; i++) {
+          params[route.paramNames[i]] = m[i + 1];
+        }
+        return { handler: route.handler, params };
+      }
+      return null;
+    };
+    const uwsBindings = await tryLoadUws();
+    if (uwsBindings) {
+      console.log("\u{1F680} uWebSockets.js transport active (native per-route C++ matching)");
+      const uwsMap = this.uwsHandlerMap;
+      const uwsRoutes = [];
+      for (const entry of this.nativeRoutes) {
+        const uwsH = uwsMap.get(entry.handler);
+        if (!uwsH) continue;
+        uwsRoutes.push({
+          method: entry.method,
+          path: entry.path,
+          paramNames: entry.paramNames ?? [],
+          handler: uwsH
+        });
+      }
+      return createUwsServer({
+        uws: uwsBindings,
+        routes: uwsRoutes,
+        port
+      });
+    }
+    const dispatch = (req, res) => {
+      const method = req.method;
+      const rawUrl = req.url;
+      const qIdx = rawUrl.indexOf("?");
+      const path = qIdx === -1 ? rawUrl : rawUrl.slice(0, qIdx);
+      if (wasm) {
+        const result = wasm.match(method, path);
+        if (result) {
+          result.handler(req, res, result.params);
+          return;
+        }
+        fastWrite404(res);
+        return;
+      }
+      const staticHandler = staticMap.get(`${method}:${path}`);
+      if (staticHandler) {
+        staticHandler(req, res, emptyParams);
+        return;
+      }
+      for (const route of dynamicRoutes) {
+        if (route.method !== method) continue;
+        const match = route.regex.exec(path);
+        if (!match) continue;
+        const params = {};
+        for (let i = 0; i < route.paramNames.length; i++) {
+          params[route.paramNames[i]] = match[i + 1];
+        }
+        route.handler(req, res, params);
+        return;
+      }
+      fastWrite404(res);
+    };
+    return new Promise((resolve2) => {
+      const server = createServer(dispatch);
+      server.listen(port, () => {
+        const addr = server.address();
+        resolve2({ port: addr.port, server });
+      });
+    });
   }
   async listen(port) {
-    const finalPort = port || 3e3;
-    serve({
-      fetch: this.app.fetch,
+    const finalPort = port ?? 3e3;
+    const manager = this.shutdownManager;
+    const shutdownFetch = async (req, ...args) => {
+      if (manager.isShuttingDown()) {
+        return new Response(
+          JSON.stringify({
+            type: "about:blank",
+            title: "Service Unavailable",
+            status: 503,
+            detail: "Server is shutting down, please retry later"
+          }),
+          {
+            status: 503,
+            headers: { "Content-Type": "application/problem+json" }
+          }
+        );
+      }
+      const untrack = manager.trackRequest();
+      try {
+        return await this.app.fetch(req, ...args);
+      } finally {
+        untrack();
+      }
+    };
+    const server = serve({
+      fetch: shutdownFetch,
       port: finalPort
     });
+    manager.setServer(server);
     console.log(`\u{1F680} Kozo server listening on http://localhost:${finalPort}`);
   }
+  /**
+   * Graceful shutdown — drains in-flight requests before closing.
+   * Use getShutdownManager().setDatabase(db, provider) to register DB cleanup.
+   */
+  async shutdown(options) {
+    return this.shutdownManager.shutdown(options);
+  }
+  getShutdownManager() {
+    return this.shutdownManager;
+  }
   getApp() {
     return this.app;
   }
@@ -681,14 +3160,628 @@ function createKozo(config) {
   return new Kozo(config);
 }
 
+// src/native-context.ts
+function buildNativeContext(req, res, params, body, services, serialize) {
+  let _query;
+  let _extraHeaders;
+  const ctx = {
+    req,
+    res,
+    params,
+    body,
+    services,
+    get query() {
+      if (_query === void 0) {
+        const url = req.url ?? "/";
+        const qIdx = url.indexOf("?");
+        if (qIdx === -1) {
+          _query = {};
+        } else {
+          const sp = new URLSearchParams(url.slice(qIdx + 1));
+          _query = {};
+          sp.forEach((v, k) => {
+            _query[k] = v;
+          });
+        }
+      }
+      return _query;
+    },
+    json(data, status) {
+      const jsonBody = serialize ? serialize(data) : JSON.stringify(data);
+      if (_extraHeaders) {
+        const hdrs = ["Content-Type", "application/json", "Content-Length", fastCL(jsonBody.length)];
+        for (const [k, v] of _extraHeaders) hdrs.push(k, v);
+        res.writeHead(status ?? 200, hdrs);
+        res.end(jsonBody);
+      } else if (status !== void 0 && status !== 200) {
+        fastWriteJsonStatus(res, jsonBody, status);
+      } else {
+        fastWriteJson(res, jsonBody);
+      }
+    },
+    text(data, status) {
+      fastWriteText(res, data, status ?? 200);
+    },
+    html(data, status) {
+      fastWriteHtml(res, data, status ?? 200);
+    },
+    header(name, value) {
+      if (!_extraHeaders) _extraHeaders = [];
+      _extraHeaders.push([name, value]);
+      return ctx;
+    },
+    redirect(url, status) {
+      const code = status ?? 302;
+      res.writeHead(code, ["Location", url, "Content-Length", "0"]);
+      res.end();
+    }
+  };
+  return ctx;
+}
+
 // src/index.ts
 import { z } from "zod";
+
+// src/openapi.ts
+function zodToJsonSchema2(zodSchema) {
+  const schema = zodSchema;
+  const def = schema._def;
+  if (!def) {
+    return { type: "object" };
+  }
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodString": {
+      const result = { type: "string" };
+      for (const check of def.checks || []) {
+        if (check.kind === "min") result.minLength = check.value;
+        if (check.kind === "max") result.maxLength = check.value;
+        if (check.kind === "email") result.format = "email";
+        if (check.kind === "url") result.format = "uri";
+        if (check.kind === "uuid") result.format = "uuid";
+        if (check.kind === "regex") result.pattern = check.regex.source;
+      }
+      return result;
+    }
+    case "ZodNumber": {
+      const result = { type: "number" };
+      for (const check of def.checks || []) {
+        if (check.kind === "min") result.minimum = check.value;
+        if (check.kind === "max") result.maximum = check.value;
+        if (check.kind === "int") result.type = "integer";
+      }
+      return result;
+    }
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodArray":
+      return {
+        type: "array",
+        items: zodToJsonSchema2(def.type)
+      };
+    case "ZodObject": {
+      const properties = {};
+      const required = [];
+      const shape = def.shape?.() || def.shape;
+      if (shape) {
+        for (const [key, value] of Object.entries(shape)) {
+          properties[key] = zodToJsonSchema2(value);
+          const fieldDef = value._def;
+          if (fieldDef?.typeName !== "ZodOptional" && fieldDef?.typeName !== "ZodDefault") {
+            required.push(key);
+          }
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    case "ZodEnum":
+      return {
+        type: "string",
+        enum: def.values
+      };
+    case "ZodNativeEnum":
+      return {
+        type: "string",
+        enum: Object.values(def.values)
+      };
+    case "ZodLiteral":
+      return {
+        type: typeof def.value,
+        enum: [def.value]
+      };
+    case "ZodUnion":
+      return {
+        oneOf: def.options.map((opt) => zodToJsonSchema2(opt))
+      };
+    case "ZodOptional":
+      return {
+        ...zodToJsonSchema2(def.innerType),
+        nullable: true
+      };
+    case "ZodNullable":
+      return {
+        ...zodToJsonSchema2(def.innerType),
+        nullable: true
+      };
+    case "ZodDefault":
+      return {
+        ...zodToJsonSchema2(def.innerType),
+        default: def.defaultValue()
+      };
+    case "ZodRecord":
+      return {
+        type: "object",
+        additionalProperties: zodToJsonSchema2(def.valueType)
+      };
+    case "ZodDate":
+      return { type: "string", format: "date-time" };
+    case "ZodAny":
+    case "ZodUnknown":
+      return {};
+    default:
+      return { type: "object" };
+  }
+}
+var OpenAPIGenerator = class {
+  config;
+  schemas = /* @__PURE__ */ new Map();
+  schemaCounter = 0;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Generate OpenAPI spec from routes
+   */
+  generate(routes) {
+    const paths = {};
+    for (const route of routes) {
+      const openApiPath = this.honoPathToOpenApi(route.path);
+      if (!paths[openApiPath]) {
+        paths[openApiPath] = {};
+      }
+      paths[openApiPath][route.method] = this.routeToOperation(route);
+    }
+    return {
+      openapi: "3.1.0",
+      info: this.config.info,
+      servers: this.config.servers,
+      tags: this.config.tags,
+      paths,
+      components: {
+        schemas: Object.fromEntries(this.schemas),
+        securitySchemes: {
+          bearerAuth: {
+            type: "http",
+            scheme: "bearer",
+            bearerFormat: "JWT"
+          }
+        }
+      },
+      security: this.config.security
+    };
+  }
+  /**
+   * Convert Hono path params to OpenAPI format
+   * :id -> {id}
+   */
+  honoPathToOpenApi(path) {
+    return path.replace(/:([^/]+)/g, "{$1}");
+  }
+  /**
+   * Convert route to OpenAPI operation
+   */
+  routeToOperation(route) {
+    const { path, method, module } = route;
+    const { schema, meta } = module;
+    const operation = {
+      operationId: this.generateOperationId(path, method),
+      summary: meta?.summary || `${method.toUpperCase()} ${path}`,
+      description: meta?.description,
+      tags: meta?.tags || [this.extractTag(path)],
+      parameters: [],
+      responses: {
+        "200": {
+          description: "Successful response",
+          content: {
+            "application/json": {
+              schema: { type: "object" }
+            }
+          }
+        },
+        "400": {
+          description: "Validation error"
+        },
+        "500": {
+          description: "Internal server error"
+        }
+      }
+    };
+    const pathParams = path.match(/:([^/]+)/g);
+    if (pathParams) {
+      for (const param of pathParams) {
+        const paramName = param.slice(1);
+        operation.parameters.push({
+          name: paramName,
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        });
+      }
+    }
+    if (schema?.query) {
+      const querySchema = zodToJsonSchema2(schema.query);
+      if (querySchema.properties) {
+        for (const [name, propSchema] of Object.entries(querySchema.properties)) {
+          operation.parameters.push({
+            name,
+            in: "query",
+            required: querySchema.required?.includes(name) || false,
+            schema: propSchema
+          });
+        }
+      }
+    }
+    if (schema?.params) {
+      const paramsSchema = zodToJsonSchema2(schema.params);
+      if (paramsSchema.properties) {
+        for (const [name, propSchema] of Object.entries(paramsSchema.properties)) {
+          const existingIdx = operation.parameters.findIndex(
+            (p) => p.name === name && p.in === "path"
+          );
+          if (existingIdx >= 0) {
+            operation.parameters[existingIdx].schema = propSchema;
+          }
+        }
+      }
+    }
+    if (["post", "put", "patch"].includes(method) && schema?.body) {
+      operation.requestBody = {
+        required: true,
+        content: {
+          "application/json": {
+            schema: zodToJsonSchema2(schema.body)
+          }
+        }
+      };
+    }
+    if (schema?.response) {
+      for (const [status, responseSchema] of Object.entries(schema.response)) {
+        operation.responses[status] = {
+          description: this.getStatusDescription(parseInt(status)),
+          content: {
+            "application/json": {
+              schema: zodToJsonSchema2(responseSchema)
+            }
+          }
+        };
+      }
+    }
+    if (meta?.auth) {
+      operation.security = [{ bearerAuth: [] }];
+    }
+    return operation;
+  }
+  /**
+   * Generate operation ID from path and method
+   */
+  generateOperationId(path, method) {
+    const parts = path.split("/").filter(Boolean).map((part) => {
+      if (part.startsWith(":")) {
+        return "By" + this.capitalize(part.slice(1));
+      }
+      return this.capitalize(part);
+    });
+    return method + parts.join("");
+  }
+  /**
+   * Extract tag from path (first segment)
+   */
+  extractTag(path) {
+    const firstSegment = path.split("/").filter(Boolean)[0];
+    return firstSegment ? this.capitalize(firstSegment) : "Default";
+  }
+  /**
+   * Get HTTP status description
+   */
+  getStatusDescription(status) {
+    const descriptions = {
+      200: "OK",
+      201: "Created",
+      204: "No Content",
+      400: "Bad Request",
+      401: "Unauthorized",
+      403: "Forbidden",
+      404: "Not Found",
+      500: "Internal Server Error"
+    };
+    return descriptions[status] || "Response";
+  }
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+};
+function generateSwaggerHtml(specUrl, title = "API Documentation") {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${title}</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui.css" />
+  <style>
+    body { margin: 0; padding: 0; }
+    .swagger-ui .topbar { display: none; }
+  </style>
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui-bundle.js" crossorigin></script>
+  <script>
+    window.onload = () => {
+      window.ui = SwaggerUIBundle({
+        url: '${specUrl}',
+        dom_id: '#swagger-ui',
+        deepLinking: true,
+        presets: [
+          SwaggerUIBundle.presets.apis,
+          SwaggerUIBundle.SwaggerUIStandalonePreset
+        ],
+        layout: "BaseLayout",
+        persistAuthorization: true
+      });
+    };
+  </script>
+</body>
+</html>`;
+}
+function createOpenAPIGenerator(config) {
+  return new OpenAPIGenerator(config);
+}
+
+// src/middleware/logger.ts
+function logger(options = {}) {
+  const { prefix = "\u{1F310}", colorize = true } = options;
+  return async (c, next) => {
+    const start = Date.now();
+    const method = c.req.method;
+    const path = new URL(c.req.url).pathname;
+    await next();
+    const duration = Date.now() - start;
+    const status = c.res.status;
+    const statusColor = status >= 500 ? "\u{1F534}" : status >= 400 ? "\u{1F7E1}" : "\u{1F7E2}";
+    const log = `${prefix} ${method.padEnd(6)} ${path} ${statusColor} ${status} ${duration}ms`;
+    console.log(log);
+  };
+}
+
+// src/middleware/cors.ts
+import { cors as honoCors } from "hono/cors";
+function cors(options = {}) {
+  return honoCors({
+    origin: options.origin || "*",
+    allowMethods: options.allowMethods || ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    allowHeaders: options.allowHeaders || ["Content-Type", "Authorization"],
+    exposeHeaders: options.exposeHeaders || [],
+    maxAge: options.maxAge || 86400,
+    credentials: options.credentials || false
+  });
+}
+
+// src/middleware/rate-limit.ts
+var store = /* @__PURE__ */ new Map();
+function rateLimit(options) {
+  const {
+    max = 100,
+    window = 60,
+    keyGenerator = (c) => c.req.header("x-forwarded-for") ?? c.req.header("x-real-ip") ?? "anonymous",
+    message = "Too many requests"
+  } = options;
+  return async (c, next) => {
+    const key = keyGenerator(c);
+    const now = Date.now();
+    const windowMs = window * 1e3;
+    let record = store.get(key);
+    if (!record || now > record.resetAt) {
+      record = { count: 0, resetAt: now + windowMs };
+    }
+    record.count++;
+    store.set(key, record);
+    c.header("X-RateLimit-Limit", String(max));
+    c.header("X-RateLimit-Remaining", String(Math.max(0, max - record.count)));
+    c.header("X-RateLimit-Reset", String(Math.ceil(record.resetAt / 1e3)));
+    if (record.count > max) {
+      return c.json({ error: message }, 429);
+    }
+    await next();
+  };
+}
+function clearRateLimitStore() {
+  store.clear();
+}
+
+// src/middleware/error-handler.ts
+var HttpError = class extends Error {
+  constructor(statusCode, message, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "HttpError";
+  }
+};
+var BadRequestError = class extends HttpError {
+  constructor(message = "Bad Request", details) {
+    super(400, message, details);
+  }
+};
+var UnauthorizedError2 = class extends HttpError {
+  constructor(message = "Unauthorized") {
+    super(401, message);
+  }
+};
+var ForbiddenError2 = class extends HttpError {
+  constructor(message = "Forbidden") {
+    super(403, message);
+  }
+};
+var NotFoundError2 = class extends HttpError {
+  constructor(message = "Not Found") {
+    super(404, message);
+  }
+};
+var ConflictError = class extends HttpError {
+  constructor(message = "Conflict", details) {
+    super(409, message, details);
+  }
+};
+var InternalServerError = class extends HttpError {
+  constructor(message = "Internal Server Error") {
+    super(500, message);
+  }
+};
+function errorHandler() {
+  return async (c, next) => {
+    try {
+      await next();
+    } catch (err) {
+      if (err instanceof HttpError) {
+        return c.json({
+          error: err.message,
+          status: err.statusCode,
+          ...err.details ? { details: err.details } : {}
+        }, err.statusCode);
+      }
+      console.error("Unhandled error:", err);
+      return c.json({
+        error: "Internal Server Error",
+        status: 500
+      }, 500);
+    }
+  };
+}
+
+// src/middleware/fileSystemRouting.ts
+import { readFile as readFile2 } from "fs/promises";
+import { resolve } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+async function readManifest(manifestPath, onMissing) {
+  try {
+    const raw = await readFile2(manifestPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    onMissing(err instanceof Error ? err : new Error(String(err)));
+    return null;
+  }
+}
+async function importHandler(handlerPath) {
+  try {
+    const url = handlerPath.startsWith("file://") ? handlerPath : pathToFileURL2(handlerPath).href;
+    const mod = await import(url);
+    if (typeof mod.default !== "function") {
+      console.warn(
+        `[kozo:fsr] Skipping ${handlerPath}: no default export function`
+      );
+      return null;
+    }
+    return mod.default;
+  } catch (err) {
+    console.warn(
+      `[kozo:fsr] Failed to import handler ${handlerPath}:`,
+      err.message
+    );
+    return null;
+  }
+}
+async function applyFileSystemRouting(app, options = {}) {
+  const {
+    manifestPath = resolve(process.cwd(), "routes-manifest.json"),
+    verbose = false,
+    onMissingManifest = () => {
+    },
+    logger: logger2 = console.log
+  } = options;
+  const manifest = await readManifest(manifestPath, onMissingManifest);
+  if (!manifest) return;
+  const log = logger2;
+  if (verbose) {
+    log(
+      `
+\u{1F4CB} [kozo:fsr] Loading ${manifest.routes.length} route(s) from manifest
+`
+    );
+  }
+  for (const route of manifest.routes) {
+    const handler = await importHandler(route.handler);
+    if (!handler) continue;
+    app[route.method](route.path, handler);
+    if (verbose) {
+      log(
+        `   ${route.method.toUpperCase().padEnd(6)} ${route.path}  \u2192  ${route.handler}`
+      );
+    }
+  }
+  if (verbose) {
+    log("");
+  }
+}
+function createFileSystemRouting(options = {}) {
+  return (app) => applyFileSystemRouting(app, options);
+}
 export {
+  ERROR_RESPONSES,
+  ForbiddenError,
+  BadRequestError as HttpBadRequestError,
+  ConflictError as HttpConflictError,
+  HttpError,
+  ForbiddenError2 as HttpForbiddenError,
+  InternalServerError as HttpInternalServerError,
+  NotFoundError2 as HttpNotFoundError,
+  UnauthorizedError2 as HttpUnauthorizedError,
   Kozo,
+  KozoError,
+  NotFoundError,
+  OpenAPIGenerator,
   SchemaCompiler,
+  ShutdownManager,
+  UnauthorizedError,
+  ValidationFailedError,
+  applyFileSystemRouting,
+  buildNativeContext,
+  clearRateLimitStore,
   compileRouteHandler,
+  cors,
+  createFileSystemRouting,
+  createInflightTracker,
   createKozo,
+  createOpenAPIGenerator,
+  createShutdownManager,
+  errorHandler,
+  fastCL,
+  fastWrite400,
+  fastWrite404,
+  fastWrite500,
+  fastWriteError,
+  fastWriteHtml,
+  fastWriteJson,
+  fastWriteJsonStatus,
+  fastWriteText,
+  forbiddenResponse,
+  formatAjvErrors,
+  formatZodErrors,
+  generateSwaggerHtml,
   generateTypedClient,
+  internalErrorResponse,
+  logger,
+  notFoundResponse,
+  rateLimit,
+  trackRequest,
+  unauthorizedResponse,
+  validationErrorResponse,
   z
 };
 //# sourceMappingURL=index.js.map