@boon4681/giri 0.0.1 → 0.0.2-alpha-2

package/dist/index.js

@@ -44,1506 +44,1588 @@ var init_es5 = __esm({
   }
 });
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  buildGiriApp: () => buildGiriApp,
-  composeMiddleware: () => composeMiddleware,
-  createContext: () => createContext,
-  createTypedResponse: () => createTypedResponse,
-  defineBodySchema: () => defineBodySchema,
-  defineConfig: () => defineConfig,
-  defineInputSchema: () => defineInputSchema,
-  defineMiddleware: () => defineMiddleware,
-  isGiriBodySchema: () => isGiriBodySchema,
-  isGiriInputSchema: () => isGiriInputSchema,
-  isTypedResponse: () => isTypedResponse,
-  loadLifecycle: () => loadLifecycle,
-  prepareRequestInput: () => prepareRequestInput,
-  resolveGiriPaths: () => resolveGiriPaths,
-  runInit: () => runInit,
-  scanRoutes: () => scanRoutes,
-  stack: () => stack,
-  syncProject: () => syncProject,
-  toResponse: () => toResponse,
-  typedResponseToResponse: () => typedResponseToResponse
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types.ts
-var typedResponseBrand = /* @__PURE__ */ Symbol.for("giri.typed-response");
-var inputSchemaBrand = /* @__PURE__ */ Symbol.for("giri.input-schema");
-var bodySchemaBrand = /* @__PURE__ */ Symbol.for("giri.body-schema");
-
-// src/context.ts
-var BODYLESS_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
-function createTypedResponse(data, status, format, headers) {
-  return {
-    [typedResponseBrand]: { data, status, format },
-    data,
-    status,
-    format,
-    headers
-  };
-}
-function isTypedResponse(value) {
-  return Boolean(value && typeof value === "object" && typedResponseBrand in value);
-}
-function createContext(options) {
-  const url = new URL(options.request.url);
-  const store = /* @__PURE__ */ new Map();
-  const validated = options.validated ?? {};
-  return {
-    params: options.params ?? {},
-    app: options.app ?? {},
-    req: {
-      raw: options.request,
-      url,
-      method: options.request.method,
-      header: (name) => options.request.headers.get(name),
-      json: () => options.request.json(),
-      text: () => options.request.text(),
-      arrayBuffer: () => options.request.arrayBuffer(),
-      formData: () => options.request.formData(),
-      valid: (key) => {
-        if (!(key in validated)) {
-          throw new Error(`No validated ${String(key)} data is available for this route.`);
-        }
-        return validated[key];
+// src/generator/schema/program.ts
+function createSchemaProgram(paths, routeFiles) {
+  let options = { ...DEFAULT_OPTIONS };
+  const configPath = import_typescript.default.findConfigFile(paths.cwd, import_typescript.default.sys.fileExists, "tsconfig.json");
+  if (configPath) {
+    const parsed = import_typescript.default.getParsedCommandLineOfConfigFile(configPath, {}, {
+      ...import_typescript.default.sys,
+      onUnRecoverableConfigFileDiagnostic: () => {
       }
-    },
-    set: (key, value) => {
-      store.set(key, value);
-    },
-    get: (key) => store.get(key),
-    json: (data, status = 200, headers) => createTypedResponse(data, status, "json", headers),
-    text: (text, status = 200, headers) => createTypedResponse(text, status, "text", headers)
-  };
-}
-function typedResponseToResponse(response) {
-  const headers = new Headers(response.headers);
-  if (response.format === "json" && !headers.has("content-type")) {
-    headers.set("content-type", "application/json; charset=utf-8");
-  }
-  if (response.format === "text" && !headers.has("content-type")) {
-    headers.set("content-type", "text/plain; charset=utf-8");
-  }
-  const body = BODYLESS_STATUS.has(response.status) ? null : response.format === "json" ? JSON.stringify(response.data) : String(response.data);
-  return new Response(body, {
-    status: response.status,
-    headers
-  });
-}
-function toResponse(response) {
-  return isTypedResponse(response) ? typedResponseToResponse(response) : response;
-}
-async function composeMiddleware(middleware, handle, context) {
-  let index = -1;
-  let result;
-  const dispatch = async (i) => {
-    if (i <= index) {
-      throw new Error("next() called multiple times in giri middleware.");
-    }
-    index = i;
-    if (i === middleware.length) {
-      result = await handle(context);
-      return result;
-    }
-    const returned = await middleware[i](context, () => dispatch(i + 1));
-    if (returned !== void 0) {
-      result = returned;
-      return returned;
+    });
+    if (parsed) {
+      options = { ...parsed.options, noEmit: true };
     }
-    return result;
-  };
-  await dispatch(0);
-  if (result === void 0) {
-    throw new Error("Route completed without returning a response.");
   }
-  return result;
+  return import_typescript.default.createProgram(routeFiles, options);
 }
-function defineMiddleware(optionsOrMiddleware, maybeMiddleware) {
-  if (typeof optionsOrMiddleware === "function") {
-    return optionsOrMiddleware;
-  }
-  if (!maybeMiddleware) {
-    throw new Error("defineMiddleware(options, middleware) requires a middleware function.");
+var import_typescript, DEFAULT_OPTIONS;
+var init_program = __esm({
+  "src/generator/schema/program.ts"() {
+    "use strict";
+    import_typescript = __toESM(require("typescript"));
+    DEFAULT_OPTIONS = {
+      target: import_typescript.default.ScriptTarget.ES2022,
+      module: import_typescript.default.ModuleKind.NodeNext,
+      moduleResolution: import_typescript.default.ModuleResolutionKind.NodeNext,
+      strict: true,
+      skipLibCheck: true,
+      noEmit: true
+    };
   }
-  maybeMiddleware.openapi = optionsOrMiddleware.openapi;
-  return maybeMiddleware;
-}
-function stack(...middleware) {
-  return middleware;
-}
+});
 
-// src/validation.ts
-function defineInputSchema(schema) {
-  return { [inputSchemaBrand]: true, ...schema };
-}
-function isGiriInputSchema(value) {
-  return Boolean(
-    value && typeof value === "object" && value[inputSchemaBrand] === true
-  );
+// src/generator/schema/json-schema.ts
+function createWalkContext(checker, location) {
+  return {
+    checker,
+    location,
+    defs: {},
+    inProgress: /* @__PURE__ */ new Map(),
+    usedDefs: /* @__PURE__ */ new Set(),
+    warnings: []
+  };
 }
-function defineBodySchema(contents) {
-  return { [bodySchemaBrand]: true, contents };
+function typeId(type) {
+  return type.id;
 }
-function isGiriBodySchema(value) {
-  return Boolean(
-    value && typeof value === "object" && value[bodySchemaBrand] === true
-  );
+function intrinsicName(type) {
+  return type.intrinsicName;
 }
-var MIME_TO_CONTENT_TYPE = {
-  "application/json": "json",
-  "multipart/form-data": "form",
-  "application/x-www-form-urlencoded": "urlencoded",
-  "text/plain": "text"
-};
-function contentTypeFromHeader(header) {
-  if (!header) {
-    return void 0;
-  }
-  const mime = header.split(";", 1)[0].trim().toLowerCase();
-  return MIME_TO_CONTENT_TYPE[mime];
+function isDateType(type) {
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  return symbol?.getName() === "Date";
 }
-function formDataObject(form) {
-  const result = {};
-  form.forEach((value, key) => {
-    const current = result[key];
-    if (current === void 0) {
-      result[key] = value;
-    } else if (Array.isArray(current)) {
-      current.push(value);
+function literalValuesOf(types) {
+  const values = [];
+  for (const member of types) {
+    if (member.isStringLiteral() || member.isNumberLiteral()) {
+      values.push(member.value);
+    } else if (member.flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+      values.push(intrinsicName(member) === "true");
     } else {
-      result[key] = [current, value];
+      return void 0;
     }
-  });
-  return result;
+  }
+  return values;
 }
-async function readRawBody(request, contentType) {
-  const cloned = request.clone();
-  if (contentType === "json") {
-    return cloned.json();
+function walkUnion(type, ctx) {
+  const flag = import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void | import_typescript2.default.TypeFlags.Never;
+  const members = type.types.filter((member) => !(member.flags & flag));
+  if (members.length === 1) {
+    return walkType(members[0], ctx);
   }
-  if (contentType === "text") {
-    return cloned.text();
+  const enumValues = literalValuesOf(members);
+  if (enumValues) {
+    return { enum: enumValues };
   }
-  return formDataObject(await cloned.formData());
+  return { anyOf: members.map((member) => walkType(member, ctx)) };
 }
-function queryObject(url) {
-  const result = {};
-  for (const [key, value] of url.searchParams) {
-    const current = result[key];
-    if (current === void 0) {
-      result[key] = value;
-    } else if (Array.isArray(current)) {
-      current.push(value);
-    } else {
-      result[key] = [current, value];
+function buildObjectSchema(type, ctx) {
+  const { checker } = ctx;
+  const indexInfo = checker.getIndexInfoOfType(type, import_typescript2.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript2.default.IndexKind.Number);
+  const properties = {};
+  const required = [];
+  for (const symbol of checker.getPropertiesOfType(type)) {
+    const name = symbol.getName();
+    const propType = checker.getTypeOfSymbolAtLocation(symbol, ctx.location);
+    const optional = Boolean(symbol.getFlags() & import_typescript2.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript2.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript2.default.TypeFlags.Undefined));
+    properties[name] = walkType(propType, ctx);
+    if (!optional) {
+      required.push(name);
     }
   }
-  return result;
-}
-async function runValidation(schema, value, label) {
-  if (!isGiriInputSchema(schema)) {
-    throw new Error(
-      `giri: ${label} schema must be wrapped with a validator, e.g. \`export const ${label} = zod(...)\` from @boon4681/giri/validators/zod.`
-    );
+  const schema = { type: "object" };
+  if (Object.keys(properties).length > 0) {
+    schema.properties = properties;
   }
-  return schema.validate(value);
-}
-async function prepareRequestInput(request, input) {
-  const validated = {};
-  if (input?.query) {
-    const query = queryObject(new URL(request.url));
-    const result = await runValidation(input.query, query, "query");
-    if (!result.ok) {
-      return {
-        ok: false,
-        response: createTypedResponse(
-          { message: "Invalid query parameters.", issues: result.issues },
-          400,
-          "json"
-        )
-      };
-    }
-    validated.query = result.value;
+  if (required.length > 0) {
+    schema.required = required;
   }
-  if (input?.body) {
-    const contents = input.body.contents;
-    const declared = Object.keys(contents);
-    const requested = contentTypeFromHeader(request.headers.get("content-type"));
-    const chosen = requested && contents[requested] ? requested : contents.json ? "json" : void 0;
-    if (!chosen) {
-      return {
-        ok: false,
-        response: createTypedResponse(
-          { message: "Unsupported media type.", issues: { accepted: declared } },
-          415,
-          "json"
-        )
-      };
-    }
-    let rawBody;
-    try {
-      rawBody = await readRawBody(request, chosen);
-    } catch (error) {
-      return {
-        ok: false,
-        response: createTypedResponse(
-          { message: "Invalid request body.", issues: error },
-          400,
-          "json"
-        )
-      };
-    }
-    const result = await runValidation(contents[chosen], rawBody, "body");
-    if (!result.ok) {
-      return {
-        ok: false,
-        response: createTypedResponse(
-          { message: "Invalid request body.", issues: result.issues },
-          400,
-          "json"
-        )
-      };
-    }
-    validated.body = declared.length > 1 ? { type: chosen, data: result.value } : result.value;
+  if (indexInfo) {
+    schema.additionalProperties = walkType(indexInfo.type, ctx);
+  } else if (Object.keys(properties).length > 0) {
+    schema.additionalProperties = false;
   }
-  return { ok: true, validated };
+  return schema;
 }
-
-// src/app.ts
-var import_node_module = __toESM(require("module"));
-var import_node_path3 = require("path");
-
-// src/loader/loader.ts
-var import_prompts = require("@clack/prompts");
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_node_process = require("process");
-
-// src/config/schema.ts
-var import_typebox = require("@sinclair/typebox");
-var configSchema = import_typebox.Type.Object({
-  adapter: import_typebox.Type.Any(),
-  alias: import_typebox.Type.Optional(import_typebox.Type.Record(
-    import_typebox.Type.String(),
-    import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Array(import_typebox.Type.String())])
-  )),
-  outDir: import_typebox.Type.Optional(import_typebox.Type.String()),
-  server: import_typebox.Type.Optional(import_typebox.Type.Object({
-    port: import_typebox.Type.Optional(import_typebox.Type.Number()),
-    hostname: import_typebox.Type.Optional(import_typebox.Type.String())
-  }, { additionalProperties: false })),
-  errorSchema: import_typebox.Type.Optional(import_typebox.Type.Any())
-}, { additionalProperties: false });
-
-// src/loader/loader.ts
-var import_value = require("@sinclair/typebox/value");
-var assertES5 = async (unregister) => {
-  try {
-    init_es5();
-  } catch (e) {
-    if ("errors" in e && Array.isArray(e.errors) && e.errors.length > 0) {
-      const es5Error = e.errors.filter((it) => it.text?.includes(`("es5") is not supported yet`)).length > 0;
-      if (es5Error) {
-        import_prompts.log.error(
-          `Please change compilerOptions.target from 'es5' to 'es6' or above in your tsconfig.json`
-        );
-        (0, import_node_process.exit)(1);
-      }
-    }
-    import_prompts.log.error(e);
-    (0, import_node_process.exit)(1);
-  }
-};
-var safeRegister = async () => {
-  const { register } = await import("esbuild-register/dist/node");
-  let res;
-  try {
-    res = register({
-      format: "cjs",
-      loader: "ts"
-    });
-  } catch {
-    res = {
-      unregister: () => {
-      }
-    };
+function defName(type) {
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  const name = symbol?.getName();
+  if (name && name !== "__type" && name !== "__object") {
+    return name;
   }
-  await assertES5(res.unregister);
-  return res;
-};
-
-// src/routes.ts
-var import_node_fs2 = require("fs");
-var import_promises = require("fs/promises");
-var import_node_path2 = require("path");
-var import_tinyglobby = require("tinyglobby");
-var METHOD_ORDER = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
-var METHOD_FROM_FILE = new Map(
-  METHOD_ORDER.map((method) => [`+${method.toLowerCase()}`, method])
-);
-function normalizeSlashes(path) {
-  return path.split(import_node_path2.sep).join("/");
-}
-function isRouteSourceFile(fileName) {
-  return /\.(?:[cm]?[jt]s|[jt]sx)$/.test(fileName) && !fileName.endsWith(".d.ts");
+  return `Anonymous${typeId(type)}`;
 }
-function methodFromFile(fileName) {
-  if (!isRouteSourceFile(fileName)) {
-    return void 0;
+function walkObject(type, ctx) {
+  const { checker } = ctx;
+  if (isDateType(type)) {
+    return { type: "string", format: "date-time" };
   }
-  const stem = fileName.replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "").toLowerCase();
-  return METHOD_FROM_FILE.get(stem);
-}
-function sharedFileIn(dir) {
-  for (const ext of ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"]) {
-    const file = (0, import_node_path2.join)(dir, `+shared.${ext}`);
-    if ((0, import_node_fs2.existsSync)(file)) {
-      return file;
-    }
+  if (checker.isArrayType(type)) {
+    const [element] = checker.getTypeArguments(type);
+    return { type: "array", items: element ? walkType(element, ctx) : {} };
   }
-  return void 0;
-}
-function physicalRouteSegments(routesDir, routeDir) {
-  const rel = (0, import_node_path2.relative)(routesDir, routeDir);
-  if (!rel) {
-    return [];
+  if (checker.isTupleType(type)) {
+    const elements = checker.getTypeArguments(type);
+    return { type: "array", items: elements.map((element) => walkType(element, ctx)) };
   }
-  return normalizeSlashes(rel).split("/").filter(Boolean);
+  const id = typeId(type);
+  const existing = ctx.inProgress.get(id);
+  if (existing) {
+    ctx.usedDefs.add(existing);
+    return { $ref: `#/$defs/${existing}` };
+  }
+  const name = defName(type);
+  ctx.inProgress.set(id, name);
+  const schema = buildObjectSchema(type, ctx);
+  ctx.inProgress.delete(id);
+  if (ctx.usedDefs.has(name)) {
+    ctx.defs[name] = schema;
+    return { $ref: `#/$defs/${name}` };
+  }
+  return schema;
 }
-function urlSegment(segment) {
-  if (/^\(.+\)$/.test(segment)) {
+function walkType(type, ctx) {
+  const flags = type.flags;
+  if (flags & (import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown)) {
     return {};
   }
-  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
-  if (catchAll) {
-    const name = catchAll[1];
-    return {
-      value: `:${name}{.*}`,
-      param: { name, catchAll: true }
-    };
+  if (flags & import_typescript2.default.TypeFlags.Null) {
+    return { type: "null" };
   }
-  const param = /^\[(.+)\]$/.exec(segment);
-  if (param) {
-    const name = param[1];
-    return {
-      value: `:${name}`,
-      param: { name, catchAll: false }
-    };
+  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
+    return {};
   }
-  return { value: segment };
+  if (flags & (import_typescript2.default.TypeFlags.BigInt | import_typescript2.default.TypeFlags.BigIntLiteral)) {
+    ctx.warnings.push("bigint is not JSON-serializable (JSON.stringify throws); documented as string.");
+    return { type: "string" };
+  }
+  if (type.isStringLiteral()) {
+    return { type: "string", const: type.value };
+  }
+  if (type.isNumberLiteral()) {
+    return { type: "number", const: type.value };
+  }
+  if (flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+    return { type: "boolean", const: intrinsicName(type) === "true" };
+  }
+  if (flags & import_typescript2.default.TypeFlags.String) {
+    return { type: "string" };
+  }
+  if (flags & import_typescript2.default.TypeFlags.Number) {
+    return { type: "number" };
+  }
+  if (flags & import_typescript2.default.TypeFlags.Boolean) {
+    return { type: "boolean" };
+  }
+  if (type.isUnion()) {
+    return walkUnion(type, ctx);
+  }
+  if (flags & import_typescript2.default.TypeFlags.Object || type.isIntersection()) {
+    return walkObject(type, ctx);
+  }
+  return {};
 }
-function pathFromSegments(segments) {
-  const pathSegments = [];
-  const params = [];
-  for (const segment of segments) {
-    const converted = urlSegment(segment);
-    if (converted.value) {
-      pathSegments.push(converted.value);
+var import_typescript2;
+var init_json_schema = __esm({
+  "src/generator/schema/json-schema.ts"() {
+    "use strict";
+    import_typescript2 = __toESM(require("typescript"));
+  }
+});
+
+// src/generator/schema/responses.ts
+function findHandleFunction(source) {
+  let found;
+  const isExported = (node) => import_typescript3.default.canHaveModifiers(node) && (import_typescript3.default.getModifiers(node)?.some((m) => m.kind === import_typescript3.default.SyntaxKind.ExportKeyword) ?? false);
+  for (const statement of source.statements) {
+    if (import_typescript3.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
+      found = statement;
     }
-    if (converted.param) {
-      params.push(converted.param);
+    if (import_typescript3.default.isVariableStatement(statement) && isExported(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (import_typescript3.default.isIdentifier(declaration.name) && declaration.name.text === "handle" && declaration.initializer && (import_typescript3.default.isArrowFunction(declaration.initializer) || import_typescript3.default.isFunctionExpression(declaration.initializer))) {
+          found = declaration.initializer;
+        }
+      }
     }
   }
-  return {
-    path: pathSegments.length > 0 ? `/${pathSegments.join("/")}` : "/",
-    params
-  };
+  return found;
 }
-async function scanRouteFolders(routesDir) {
-  if (!(0, import_node_fs2.existsSync)(routesDir)) {
+function collectReturnExpressions(fn) {
+  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
+    return [fn.body];
+  }
+  if (!fn.body) {
     return [];
   }
-  const folders = [routesDir];
-  const walk = async (dir) => {
-    for (const entry of await (0, import_promises.readdir)(dir, { withFileTypes: true })) {
-      if (entry.isDirectory() && entry.name !== "node_modules") {
-        const full = (0, import_node_path2.join)(dir, entry.name);
-        folders.push(full);
-        await walk(full);
-      }
+  const expressions = [];
+  const visit = (node) => {
+    if (import_typescript3.default.isFunctionDeclaration(node) || import_typescript3.default.isFunctionExpression(node) || import_typescript3.default.isArrowFunction(node)) {
+      return;
+    }
+    if (import_typescript3.default.isReturnStatement(node) && node.expression) {
+      expressions.push(node.expression);
     }
+    import_typescript3.default.forEachChild(node, visit);
   };
-  await walk(routesDir);
-  return folders;
+  import_typescript3.default.forEachChild(fn.body, visit);
+  return expressions;
 }
-function routeParamsForDir(routesDir, dir) {
-  return pathFromSegments(physicalRouteSegments(routesDir, dir)).params;
+function propertyType(checker, type, name, location) {
+  const symbol = checker.getPropertyOfType(type, name);
+  return symbol ? checker.getTypeOfSymbolAtLocation(symbol, location) : void 0;
 }
-function sharedFilesForDir(routesDir, dir) {
-  const segments = physicalRouteSegments(routesDir, dir);
-  const dirs = [routesDir];
-  let current = routesDir;
-  for (const segment of segments) {
-    current = (0, import_node_path2.join)(current, segment);
-    dirs.push(current);
+function isTypedResponse2(checker, type) {
+  return Boolean(
+    checker.getPropertyOfType(type, "data") && checker.getPropertyOfType(type, "status") && checker.getPropertyOfType(type, "format")
+  );
+}
+function readFromCall(checker, expression) {
+  if (!import_typescript3.default.isCallExpression(expression) || !import_typescript3.default.isPropertyAccessExpression(expression.expression)) {
+    return void 0;
   }
-  return dirs.map(sharedFileIn).filter((file) => Boolean(file));
+  const method = expression.expression.name.text;
+  if (method !== "json" && method !== "text") {
+    return void 0;
+  }
+  if (!isTypedResponse2(checker, checker.getTypeAtLocation(expression))) {
+    return void 0;
+  }
+  const [dataArg, statusArg] = expression.arguments;
+  if (!dataArg) {
+    return void 0;
+  }
+  let status = 200;
+  if (statusArg) {
+    const statusType = checker.getTypeAtLocation(statusArg);
+    status = statusType.isNumberLiteral() ? statusType.value : "default";
+  }
+  return { status, format: method === "text" ? "text" : "json", data: checker.getTypeAtLocation(dataArg) };
 }
-async function scanRoutes(routesDir) {
-  if (!(0, import_node_fs2.existsSync)(routesDir)) {
-    return [];
+function readFromType(checker, type, location) {
+  const dataType = propertyType(checker, type, "data", location);
+  const statusType = propertyType(checker, type, "status", location);
+  const formatType = propertyType(checker, type, "format", location);
+  if (!dataType || !statusType || !formatType) {
+    return void 0;
   }
-  const files = await (0, import_tinyglobby.glob)("**/+*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}", {
-    cwd: routesDir,
-    absolute: true,
-    onlyFiles: true
-  });
-  const routes = [];
-  for (const file of files) {
-    const method = methodFromFile((0, import_node_path2.basename)(file));
-    if (!method) {
+  const status = statusType.isNumberLiteral() ? statusType.value : "default";
+  const format = formatType.isStringLiteral() && formatType.value === "text" ? "text" : "json";
+  return { status, format, data: dataType };
+}
+function constituents(type) {
+  return type.isUnion() ? type.types : [type];
+}
+function extractRouteResponses(program, file) {
+  const result = { responses: [], opaque: false, warnings: [], $defs: {} };
+  const source = program.getSourceFile(file);
+  if (!source) {
+    return result;
+  }
+  const checker = program.getTypeChecker();
+  const fn = findHandleFunction(source);
+  if (!fn) {
+    return result;
+  }
+  const ctx = createWalkContext(checker, fn);
+  const byStatus = /* @__PURE__ */ new Map();
+  const record = (hit) => {
+    const schema = walkType(hit.data, ctx);
+    const bucket = byStatus.get(hit.status) ?? { format: hit.format, schemas: [] };
+    bucket.schemas.push(schema);
+    byStatus.set(hit.status, bucket);
+  };
+  for (const expression of collectReturnExpressions(fn)) {
+    const fromCall = readFromCall(checker, expression);
+    if (fromCall) {
+      record(fromCall);
       continue;
     }
-    const routeDir = (0, import_node_path2.dirname)(file);
-    const routeSegments = physicalRouteSegments(routesDir, routeDir);
-    const { path, params } = pathFromSegments(routeSegments);
-    routes.push({
-      method,
-      path,
-      file,
-      routeDir,
-      routeSegments,
-      params,
-      sharedFiles: sharedFilesForDir(routesDir, routeDir)
-    });
-  }
-  return routes.sort((left, right) => {
-    const pathOrder = left.path.localeCompare(right.path);
-    if (pathOrder !== 0) {
-      return pathOrder;
+    let matched = false;
+    for (const member of constituents(checker.getTypeAtLocation(expression))) {
+      const hit = readFromType(checker, member, expression);
+      if (hit) {
+        record(hit);
+        matched = true;
+      }
+    }
+    if (!matched) {
+      result.opaque = true;
     }
-    return METHOD_ORDER.indexOf(left.method) - METHOD_ORDER.indexOf(right.method);
-  });
-}
-
-// src/app.ts
-function loadModule(file) {
-  const resolved = require.resolve(file);
-  delete require.cache[resolved];
-  return require(resolved);
-}
-function interopDefault(value) {
-  if (value && typeof value === "object" && "default" in value) {
-    return value.default;
   }
-  return value;
+  for (const [status, { format, schemas }] of byStatus) {
+    const schema = schemas.length === 1 ? schemas[0] : { anyOf: schemas };
+    result.responses.push({ status, format, schema });
+  }
+  result.responses.sort((a, b) => Number(a.status) - Number(b.status));
+  result.warnings = ctx.warnings;
+  result.$defs = ctx.defs;
+  return result;
 }
-function normalizeMiddleware(value, file) {
-  const exported = interopDefault(value);
-  if (exported === void 0) {
-    return [];
+var import_typescript3;
+var init_responses = __esm({
+  "src/generator/schema/responses.ts"() {
+    "use strict";
+    import_typescript3 = __toESM(require("typescript"));
+    init_json_schema();
   }
-  if (typeof exported === "function") {
-    return [exported];
+});
+
+// src/generator/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  createSchemaProgram: () => createSchemaProgram,
+  createWalkContext: () => createWalkContext,
+  extractRouteResponses: () => extractRouteResponses,
+  walkType: () => walkType
+});
+var init_schema = __esm({
+  "src/generator/schema/index.ts"() {
+    "use strict";
+    init_program();
+    init_responses();
+    init_json_schema();
   }
-  if (Array.isArray(exported)) {
-    for (const middleware of exported) {
-      if (typeof middleware !== "function") {
-        throw new Error(`Middleware export in ${file} must contain only functions.`);
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildGiriApp: () => buildGiriApp,
+  composeMiddleware: () => composeMiddleware,
+  createContext: () => createContext,
+  createTypedResponse: () => createTypedResponse,
+  defineBodySchema: () => defineBodySchema,
+  defineConfig: () => defineConfig,
+  defineInputSchema: () => defineInputSchema,
+  defineMiddleware: () => defineMiddleware,
+  isGiriBodySchema: () => isGiriBodySchema,
+  isGiriInputSchema: () => isGiriInputSchema,
+  isTypedResponse: () => isTypedResponse,
+  loadLifecycle: () => loadLifecycle,
+  prepareRequestInput: () => prepareRequestInput,
+  resolveGiriPaths: () => resolveGiriPaths,
+  runInit: () => runInit,
+  scanRoutes: () => scanRoutes,
+  stack: () => stack,
+  syncProject: () => syncProject,
+  toResponse: () => toResponse,
+  typedResponseToResponse: () => typedResponseToResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var typedResponseBrand = /* @__PURE__ */ Symbol.for("giri.typed-response");
+var nativeContextBrand = /* @__PURE__ */ Symbol.for("giri.native-context");
+var inputSchemaBrand = /* @__PURE__ */ Symbol.for("giri.input-schema");
+var bodySchemaBrand = /* @__PURE__ */ Symbol.for("giri.body-schema");
+
+// src/context.ts
+var BODYLESS_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+var pendingResponseBrand = /* @__PURE__ */ Symbol("giri.pending-response");
+function getPending(context) {
+  return context[pendingResponseBrand];
+}
+function createTypedResponse(data, status, format, headers) {
+  return {
+    [typedResponseBrand]: { data, status, format },
+    data,
+    status,
+    format,
+    headers
+  };
+}
+function isTypedResponse(value) {
+  return Boolean(value && typeof value === "object" && typedResponseBrand in value);
+}
+function createContext(options) {
+  const url = new URL(options.request.url);
+  const store = /* @__PURE__ */ new Map();
+  const validated = options.validated ?? {};
+  const pending = { headers: new Headers() };
+  const defaultStatus = () => pending.status ?? 200;
+  const context = {
+    params: options.params ?? {},
+    app: options.app ?? {},
+    req: {
+      raw: options.request,
+      url,
+      method: options.request.method,
+      header: (name) => options.request.headers.get(name),
+      json: () => options.request.json(),
+      text: () => options.request.text(),
+      arrayBuffer: () => options.request.arrayBuffer(),
+      formData: () => options.request.formData(),
+      valid: (key) => {
+        if (!(key in validated)) {
+          throw new Error(`No validated ${String(key)} data is available for this route.`);
+        }
+        return validated[key];
+      }
+    },
+    set: (key, value) => {
+      store.set(key, value);
+    },
+    get: (key) => store.get(key),
+    json: (data, status, headers) => createTypedResponse(data, status ?? defaultStatus(), "json", headers),
+    text: (text, status, headers) => createTypedResponse(text, status ?? defaultStatus(), "text", headers),
+    html: (html, status, headers) => createTypedResponse(html, status ?? defaultStatus(), "html", headers),
+    body: (data, status, headers) => new Response(data, { status: status ?? defaultStatus(), headers }),
+    newResponse: (data, status, headers) => new Response(data, { status: status ?? defaultStatus(), headers }),
+    redirect: (location, status) => new Response(null, { status: status ?? 302, headers: { Location: location } }),
+    notFound: () => new Response("404 Not Found", { status: 404 }),
+    header: (name, value, options2) => {
+      if (value === void 0) {
+        pending.headers.delete(name);
+      } else if (options2?.append) {
+        pending.headers.append(name, value);
+      } else {
+        pending.headers.set(name, value);
       }
+    },
+    status: (code) => {
+      pending.status = code;
     }
-    return exported;
-  }
-  throw new Error(`Middleware export in ${file} must be a function or an array of functions.`);
-}
-function assertBodySchema(value, file) {
-  if (!isGiriBodySchema(value)) {
-    throw new Error(
-      `${file}: "body" must be wrapped with a validator, e.g. \`export const body = zod.body({ json: ... })\` from @boon4681/giri/validators/zod.`
-    );
-  }
+  };
+  context[nativeContextBrand] = options.native;
+  context[pendingResponseBrand] = pending;
+  return context;
 }
-function assertQuerySchema(value, file) {
-  if (!isGiriInputSchema(value)) {
-    throw new Error(
-      `${file}: "query" must be wrapped with a validator, e.g. \`export const query = zod.query(...)\` from @boon4681/giri/validators/zod.`
-    );
+function typedResponseToResponse(response) {
+  const headers = new Headers(response.headers);
+  if (response.format === "json" && !headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
   }
-}
-function routeInput(routeModule, file) {
-  const input = {};
-  if (routeModule.body !== void 0) {
-    assertBodySchema(routeModule.body, file);
-    input.body = routeModule.body;
+  if (response.format === "text" && !headers.has("content-type")) {
+    headers.set("content-type", "text/plain; charset=utf-8");
   }
-  if (routeModule.query !== void 0) {
-    assertQuerySchema(routeModule.query, file);
-    input.query = routeModule.query;
+  if (response.format === "html" && !headers.has("content-type")) {
+    headers.set("content-type", "text/html; charset=utf-8");
   }
-  return input.body || input.query ? input : void 0;
-}
-function aliasValues(value) {
-  return Array.isArray(value) ? value : [value];
-}
-function resolveAliasTarget(cwd, target, capture = "") {
-  const replaced = target.includes("*") ? target.replaceAll("*", capture) : target;
-  return (0, import_node_path3.isAbsolute)(replaced) ? replaced : (0, import_node_path3.resolve)(cwd, replaced);
+  const body = BODYLESS_STATUS.has(response.status) ? null : response.format === "json" ? JSON.stringify(response.data) : String(response.data);
+  return new Response(body, {
+    status: response.status,
+    headers
+  });
 }
-function matchAlias(request, key) {
-  if (key.includes("*")) {
-    const [prefix2, suffix = ""] = key.split("*");
-    if (request.startsWith(prefix2) && request.endsWith(suffix)) {
-      return request.slice(prefix2.length, request.length - suffix.length);
-    }
-    return void 0;
-  }
-  if (request === key) {
-    return "";
+function toResponse(response, context) {
+  const base = isTypedResponse(response) ? typedResponseToResponse(response) : response;
+  const pending = context ? getPending(context) : void 0;
+  if (!pending) {
+    return base;
   }
-  const prefix = `${key}/`;
-  if (request.startsWith(prefix)) {
-    return request.slice(prefix.length);
+  let hasPending = false;
+  pending.headers.forEach(() => {
+    hasPending = true;
+  });
+  if (!hasPending) {
+    return base;
   }
-  return void 0;
+  const headers = new Headers(base.headers);
+  pending.headers.forEach((value, key) => {
+    if (!headers.has(key)) {
+      headers.set(key, value);
+    }
+  });
+  return new Response(base.body, { status: base.status, statusText: base.statusText, headers });
 }
-function resolveAliasRequest(request, alias, cwd) {
-  for (const [key, value] of Object.entries(alias ?? {})) {
-    const capture = matchAlias(request, key);
-    if (capture === void 0) {
-      continue;
+async function composeMiddleware(middleware, handle, context) {
+  let index = -1;
+  let result;
+  const dispatch = async (i) => {
+    if (i <= index) {
+      throw new Error("next() called multiple times in giri middleware.");
     }
-    const [target] = aliasValues(value);
-    if (!target) {
-      continue;
+    index = i;
+    if (i === middleware.length) {
+      result = await handle(context);
+      return result;
     }
-    return resolveAliasTarget(cwd, target, capture);
+    const returned = await middleware[i](context, () => dispatch(i + 1));
+    if (returned !== void 0) {
+      result = returned;
+      return returned;
+    }
+    return result;
+  };
+  await dispatch(0);
+  if (result === void 0) {
+    throw new Error("Route completed without returning a response.");
   }
-  return void 0;
+  return result;
 }
-function registerAliasResolver(alias, cwd) {
-  if (!alias || Object.keys(alias).length === 0) {
-    return () => {
-    };
+function defineMiddleware(optionsOrMiddleware, maybeMiddleware) {
+  if (typeof optionsOrMiddleware === "function") {
+    return optionsOrMiddleware;
   }
-  const moduleWithResolver = import_node_module.default;
-  const originalResolveFilename = moduleWithResolver._resolveFilename;
-  moduleWithResolver._resolveFilename = function resolveWithGiriAlias(request, parent, isMain, options) {
-    return originalResolveFilename.call(
-      this,
-      resolveAliasRequest(request, alias, cwd) ?? request,
-      parent,
-      isMain,
-      options
-    );
-  };
-  return () => {
-    moduleWithResolver._resolveFilename = originalResolveFilename;
-  };
-}
-var GIRI_ALIAS_PREFIX = "$giri/";
-var giriOutDir;
-var giriResolverInstalled = false;
-function ensureGiriAliasResolver(outDir) {
-  giriOutDir = outDir;
-  if (giriResolverInstalled) {
-    return;
+  if (!maybeMiddleware) {
+    throw new Error("defineMiddleware(options, middleware) requires a middleware function.");
   }
-  giriResolverInstalled = true;
-  const moduleWithResolver = import_node_module.default;
-  const originalResolveFilename = moduleWithResolver._resolveFilename;
-  moduleWithResolver._resolveFilename = function resolveWithGiriInternalAlias(request, parent, isMain, options) {
-    const mapped = typeof request === "string" && request.startsWith(GIRI_ALIAS_PREFIX) && giriOutDir ? (0, import_node_path3.join)(giriOutDir, request.slice(GIRI_ALIAS_PREFIX.length)) : request;
-    return originalResolveFilename.call(this, mapped, parent, isMain, options);
-  };
-}
-function resolveGiriPaths(config, cwd = process.cwd()) {
-  return {
-    cwd: (0, import_node_path3.resolve)(cwd),
-    routesDir: (0, import_node_path3.resolve)(cwd, "src/routes"),
-    outDir: (0, import_node_path3.resolve)(cwd, config.outDir ?? ".giri")
-  };
+  maybeMiddleware.openapi = optionsOrMiddleware.openapi;
+  return maybeMiddleware;
 }
-async function buildGiriApp(config, options = {}) {
-  const paths = resolveGiriPaths(config, options.cwd);
-  const routes = await scanRoutes(paths.routesDir);
-  const app = config.adapter.createApp();
-  ensureGiriAliasResolver(paths.outDir);
-  const { unregister } = await safeRegister();
-  const unregisterAliasResolver = registerAliasResolver(config.alias, paths.cwd);
-  try {
-    for (const route of routes) {
-      const routeModule = loadModule(route.file);
-      if (typeof routeModule.handle !== "function") {
-        throw new Error(`${route.file} must export a named handle function.`);
-      }
-      const folderMiddleware = routeModule.config?.skipInherited ? [] : route.sharedFiles.flatMap(
-        (file) => normalizeMiddleware(loadModule(file).middleware, file)
-      );
-      const verbMiddleware = normalizeMiddleware(routeModule.middleware, route.file);
-      config.adapter.register(app, {
-        method: route.method,
-        path: route.path,
-        handle: routeModule.handle,
-        middleware: [...folderMiddleware, ...verbMiddleware],
-        input: routeInput(routeModule, route.file),
-        services: options.services
-      });
-    }
-  } finally {
-    unregisterAliasResolver();
-    unregister();
-  }
-  return { app, routes, paths };
+function stack(...middleware) {
+  return middleware;
 }
 
-// src/generator/sync.ts
-var import_node_fs6 = require("fs");
-var import_promises3 = require("fs/promises");
-var import_node_path11 = require("path");
-
-// src/generator/app-types.ts
-var import_node_fs4 = require("fs");
-var import_node_path5 = require("path");
-
-// src/generator/util.ts
-var import_node_fs3 = require("fs");
-var import_promises2 = require("fs/promises");
-var import_node_path4 = require("path");
-var GENERATED_HEADER = "// Generated by giri sync. Do not edit.";
-function slash(path) {
-  return path.split(import_node_path4.sep).join("/");
-}
-function importPath(fromFile, toFile) {
-  let path = slash((0, import_node_path4.relative)((0, import_node_path4.dirname)(fromFile), toFile)).replace(/\.d\.ts$/, "");
-  if (!path.startsWith(".")) {
-    path = `./${path}`;
-  }
-  return path;
-}
-function relativeConfigPath(fromDir, toPath) {
-  let path = slash((0, import_node_path4.relative)(fromDir, toPath));
-  if (!path.startsWith(".")) {
-    path = `./${path}`;
-  }
-  return path;
+// src/validation.ts
+function defineInputSchema(schema) {
+  return { [inputSchemaBrand]: true, ...schema };
 }
-function moduleSpecifier(fromDir, target) {
-  let path = slash((0, import_node_path4.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
-  if (!path.startsWith(".")) {
-    path = `./${path}`;
-  }
-  return path;
+function isGiriInputSchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[inputSchemaBrand] === true
+  );
 }
-function typeFilePath(paths, routeDir) {
-  const sourceDir = (0, import_node_path4.relative)(paths.cwd, routeDir);
-  return (0, import_node_path4.join)(paths.outDir, "types", sourceDir, "$types.d.ts");
+function defineBodySchema(contents) {
+  return { [bodySchemaBrand]: true, contents };
 }
-function assertSafeOutDir(paths) {
-  const rel = (0, import_node_path4.relative)(paths.cwd, paths.outDir);
-  if (!rel || rel.startsWith("..") || rel.includes(`..${import_node_path4.sep}`)) {
-    throw new Error(`Refusing to sync outside the project root: ${paths.outDir}`);
-  }
+function isGiriBodySchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[bodySchemaBrand] === true
+  );
 }
-var writeCache = /* @__PURE__ */ new Map();
-async function writeGenerated(path, content) {
-  if (writeCache.get(path) === content && (0, import_node_fs3.existsSync)(path)) {
-    return;
+var MIME_TO_CONTENT_TYPE = {
+  "application/json": "json",
+  "multipart/form-data": "form",
+  "application/x-www-form-urlencoded": "urlencoded",
+  "text/plain": "text"
+};
+function contentTypeFromHeader(header) {
+  if (!header) {
+    return void 0;
   }
-  await (0, import_promises2.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
-  await (0, import_promises2.writeFile)(path, content);
-  writeCache.set(path, content);
+  const mime = header.split(";", 1)[0].trim().toLowerCase();
+  return MIME_TO_CONTENT_TYPE[mime];
 }
-async function writeJson(path, value) {
-  await writeGenerated(path, `${JSON.stringify(value, null, 2)}
-`);
+function formDataObject(form) {
+  const result = {};
+  form.forEach((value, key) => {
+    const current = result[key];
+    if (current === void 0) {
+      result[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      result[key] = [current, value];
+    }
+  });
+  return result;
 }
-async function pruneDir(dir, keep) {
-  let entries;
-  try {
-    entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
-  } catch {
-    return;
+async function readRawBody(request, contentType) {
+  const cloned = request.clone();
+  if (contentType === "json") {
+    return cloned.json();
   }
-  for (const entry of entries) {
-    const full = (0, import_node_path4.join)(dir, entry.name);
-    if (entry.isDirectory()) {
-      await pruneDir(full, keep);
-      await (0, import_promises2.rmdir)(full).catch(() => {
-      });
-    } else if (!keep.has(full)) {
-      await (0, import_promises2.rm)(full, { force: true });
-      writeCache.delete(full);
-    }
+  if (contentType === "text") {
+    return cloned.text();
   }
+  return formDataObject(await cloned.formData());
 }
-
-// src/generator/app-types.ts
-var MAIN_EXTENSIONS = ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
-function findMainFile(cwd) {
-  for (const ext of MAIN_EXTENSIONS) {
-    const file = (0, import_node_path5.join)(cwd, "src", `main.${ext}`);
-    if ((0, import_node_fs4.existsSync)(file)) {
-      return file;
+function queryObject(url) {
+  const result = {};
+  for (const [key, value] of url.searchParams) {
+    const current = result[key];
+    if (current === void 0) {
+      result[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      result[key] = [current, value];
     }
   }
-  return void 0;
+  return result;
 }
-function moduleSpecifier2(fromDir, target) {
-  let path = slash((0, import_node_path5.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
-  if (!path.startsWith(".")) {
-    path = `./${path}`;
+async function runValidation(schema, value, label) {
+  if (!isGiriInputSchema(schema)) {
+    throw new Error(
+      `giri: ${label} schema must be wrapped with a validator, e.g. \`export const ${label} = zod(...)\` from @boon4681/giri/validators/zod.`
+    );
   }
-  return path;
+  return schema.validate(value);
 }
-async function writeAppTypes(paths) {
-  const file = (0, import_node_path5.join)(paths.outDir, "types", "app.d.ts");
-  const mainFile = findMainFile(paths.cwd);
-  if (!mainFile) {
-    await writeGenerated(file, [GENERATED_HEADER, "export {};", ""].join("\n"));
-    return;
+async function prepareRequestInput(request, input) {
+  const validated = {};
+  if (input?.query) {
+    const query = queryObject(new URL(request.url));
+    const result = await runValidation(input.query, query, "query");
+    if (!result.ok) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid query parameters.", issues: result.issues },
+          400,
+          "json"
+        )
+      };
+    }
+    validated.query = result.value;
   }
-  const spec = moduleSpecifier2((0, import_node_path5.join)(paths.outDir, "types"), mainFile);
-  await writeGenerated(
-    file,
-    [
-      GENERATED_HEADER,
-      "declare global {",
-      "  namespace Giri {",
-      "    interface Register {",
-      `      app: typeof import(${JSON.stringify(spec)}) extends {`,
-      "        init: (...args: any[]) => infer R;",
-      "      }",
-      "        ? Awaited<R>",
-      "        : Record<string, unknown>;",
-      "    }",
-      "  }",
-      "}",
-      "export {};",
-      ""
-    ].join("\n")
-  );
-}
-
-// src/generator/manifest.ts
-var import_node_path6 = require("path");
-async function writeManifest(paths, routes, data = {}) {
-  const manifest = {
-    version: 1,
-    routes: routes.map((route) => {
-      const responses = data.responsesByFile?.get(route.file);
-      const input = data.inputsByFile?.get(route.file);
-      const security = data.securityByFile?.get(route.file);
+  if (input?.body) {
+    const contents = input.body.contents;
+    const declared = Object.keys(contents);
+    const requested = contentTypeFromHeader(request.headers.get("content-type"));
+    const chosen = requested && contents[requested] ? requested : contents.json ? "json" : void 0;
+    if (!chosen) {
       return {
-        method: route.method,
-        path: route.path,
-        file: slash((0, import_node_path6.relative)(paths.cwd, route.file)),
-        params: route.params,
-        shared: route.sharedFiles.map((file) => slash((0, import_node_path6.relative)(paths.cwd, file))),
-        types: slash((0, import_node_path6.relative)(paths.cwd, typeFilePath(paths, route.routeDir))),
-        ...data.hiddenFiles?.has(route.file) ? { hidden: true } : {},
-        ...input ? { input } : {},
-        ...security && security.security.length > 0 ? { security: security.security } : {},
-        responses: responses?.responses ?? [],
-        ...responses && Object.keys(responses.$defs).length > 0 ? { $defs: responses.$defs } : {}
+        ok: false,
+        response: createTypedResponse(
+          { message: "Unsupported media type.", issues: { accepted: declared } },
+          415,
+          "json"
+        )
       };
-    })
-  };
-  await writeJson((0, import_node_path6.join)(paths.outDir, "manifest.json"), manifest);
+    }
+    let rawBody;
+    try {
+      rawBody = await readRawBody(request, chosen);
+    } catch (error) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid request body.", issues: error },
+          400,
+          "json"
+        )
+      };
+    }
+    const result = await runValidation(contents[chosen], rawBody, "body");
+    if (!result.ok) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid request body.", issues: result.issues },
+          400,
+          "json"
+        )
+      };
+    }
+    validated.body = declared.length > 1 ? { type: chosen, data: result.value } : result.value;
+  }
+  return { ok: true, validated };
 }
 
-// src/generator/openapi.ts
-var import_node_fs5 = require("fs");
-var import_node_path7 = require("path");
-var REASON = {
-  200: "OK",
-  201: "Created",
-  202: "Accepted",
-  204: "No Content",
-  400: "Bad Request",
-  401: "Unauthorized",
-  403: "Forbidden",
-  404: "Not Found",
-  409: "Conflict",
-  422: "Unprocessable Entity",
-  500: "Internal Server Error"
-};
-function toOpenApiPath(path) {
-  return path.replace(/:([A-Za-z0-9_]+)(?:\{[^}]*\})?/g, "{$1}");
-}
-function rewriteRefs(value) {
-  if (Array.isArray(value)) {
-    return value.map(rewriteRefs);
+// src/app.ts
+var import_node_module = __toESM(require("module"));
+var import_node_path3 = require("path");
+
+// src/loader/loader.ts
+var import_prompts = require("@clack/prompts");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_process = require("process");
+
+// src/config/schema.ts
+var import_typebox = require("@sinclair/typebox");
+var configSchema = import_typebox.Type.Object({
+  adapter: import_typebox.Type.Any(),
+  alias: import_typebox.Type.Optional(import_typebox.Type.Record(
+    import_typebox.Type.String(),
+    import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Array(import_typebox.Type.String())])
+  )),
+  outDir: import_typebox.Type.Optional(import_typebox.Type.String()),
+  server: import_typebox.Type.Optional(import_typebox.Type.Object({
+    port: import_typebox.Type.Optional(import_typebox.Type.Number()),
+    hostname: import_typebox.Type.Optional(import_typebox.Type.String())
+  }, { additionalProperties: false })),
+  errorSchema: import_typebox.Type.Optional(import_typebox.Type.Any())
+}, { additionalProperties: false });
+
+// src/loader/loader.ts
+var import_value = require("@sinclair/typebox/value");
+var assertES5 = async (unregister) => {
+  try {
+    init_es5();
+  } catch (e) {
+    if ("errors" in e && Array.isArray(e.errors) && e.errors.length > 0) {
+      const es5Error = e.errors.filter((it) => it.text?.includes(`("es5") is not supported yet`)).length > 0;
+      if (es5Error) {
+        import_prompts.log.error(
+          `Please change compilerOptions.target from 'es5' to 'es6' or above in your tsconfig.json`
+        );
+        (0, import_node_process.exit)(1);
+      }
+    }
+    import_prompts.log.error(e);
+    (0, import_node_process.exit)(1);
   }
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const [key, child] of Object.entries(value)) {
-      if (key === "$ref" && typeof child === "string" && child.startsWith("#/$defs/")) {
-        out.$ref = child.replace("#/$defs/", "#/components/schemas/");
-      } else {
-        out[key] = rewriteRefs(child);
+};
+var safeRegister = async () => {
+  const { register } = await import("esbuild-register/dist/node");
+  let res;
+  try {
+    res = register({
+      format: "cjs",
+      loader: "ts"
+    });
+  } catch {
+    res = {
+      unregister: () => {
       }
-    }
-    return out;
+    };
   }
-  return value;
+  await assertES5(res.unregister);
+  return res;
+};
+
+// src/routes.ts
+var import_node_fs2 = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+var import_tinyglobby = require("tinyglobby");
+var METHOD_ORDER = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
+var METHOD_FROM_FILE = new Map(
+  METHOD_ORDER.map((method) => [`+${method.toLowerCase()}`, method])
+);
+function normalizeSlashes(path) {
+  return path.split(import_node_path2.sep).join("/");
 }
-function mediaTypeFor(format) {
-  return format === "text" ? "text/plain" : "application/json";
+function isRouteSourceFile(fileName) {
+  return /\.(?:[cm]?[jt]s|[jt]sx)$/.test(fileName) && !fileName.endsWith(".d.ts");
 }
-var BODY_MEDIA_TYPE = {
-  json: "application/json",
-  form: "multipart/form-data",
-  urlencoded: "application/x-www-form-urlencoded",
-  text: "text/plain"
-};
-function buildResponses(responses) {
-  if (responses.length === 0) {
-    return { default: { description: "Response" } };
-  }
-  const out = {};
-  for (const response of responses) {
-    const key = response.status === "default" ? "default" : String(response.status);
-    const description = typeof response.status === "number" && REASON[response.status] || "Response";
-    out[key] = {
-      description,
-      content: { [mediaTypeFor(response.format)]: { schema: rewriteRefs(response.schema) } }
-    };
+function methodFromFile(fileName) {
+  if (!isRouteSourceFile(fileName)) {
+    return void 0;
   }
-  return out;
+  const stem = fileName.replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "").toLowerCase();
+  return METHOD_FROM_FILE.get(stem);
 }
-function pathParameters(route) {
-  const seen = /* @__PURE__ */ new Set();
-  const params = [];
-  for (const param of route.params) {
-    if (seen.has(param.name)) {
-      continue;
+function sharedFileIn(dir) {
+  for (const ext of ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"]) {
+    const file = (0, import_node_path2.join)(dir, `+shared.${ext}`);
+    if ((0, import_node_fs2.existsSync)(file)) {
+      return file;
     }
-    seen.add(param.name);
-    params.push({ name: param.name, in: "path", required: true, schema: { type: "string" } });
   }
-  return params;
+  return void 0;
 }
-function queryParameters(query) {
-  if (!query || query.type !== "object" || typeof query.properties !== "object") {
+function physicalRouteSegments(routesDir, routeDir) {
+  const rel = (0, import_node_path2.relative)(routesDir, routeDir);
+  if (!rel) {
     return [];
   }
-  const properties = query.properties;
-  const required = Array.isArray(query.required) ? query.required : [];
-  return Object.entries(properties).map(([name, schema]) => ({
-    name,
-    in: "query",
-    required: required.includes(name),
-    schema: rewriteRefs(schema)
-  }));
+  return normalizeSlashes(rel).split("/").filter(Boolean);
 }
-function readProjectInfo(cwd) {
-  const file = (0, import_node_path7.join)(cwd, "package.json");
-  if ((0, import_node_fs5.existsSync)(file)) {
-    try {
-      const pkg = JSON.parse((0, import_node_fs5.readFileSync)(file, "utf8"));
-      return { title: pkg.name ?? "giri API", version: pkg.version ?? "0.0.0" };
-    } catch {
-    }
+function urlSegment(segment) {
+  if (/^\(.+\)$/.test(segment)) {
+    return {};
   }
-  return { title: "giri API", version: "0.0.0" };
+  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
+  if (catchAll) {
+    const name = catchAll[1];
+    return {
+      value: `:${name}{.*}`,
+      param: { name, catchAll: true }
+    };
+  }
+  const param = /^\[(.+)\]$/.exec(segment);
+  if (param) {
+    const name = param[1];
+    return {
+      value: `:${name}`,
+      param: { name, catchAll: false }
+    };
+  }
+  return { value: segment };
 }
-function buildOpenApiDocument(paths, routes, data = {}) {
-  const documentPaths = {};
-  const schemas = {};
-  const securitySchemes = {};
-  for (const route of routes) {
-    if (data.hiddenFiles?.has(route.file)) {
-      continue;
-    }
-    const responses = data.responsesByFile?.get(route.file);
-    const input = data.inputsByFile?.get(route.file);
-    const security = data.securityByFile?.get(route.file);
-    for (const [name, schema] of Object.entries(responses?.$defs ?? {})) {
-      schemas[name] = rewriteRefs(schema);
-    }
-    const operation = { responses: buildResponses(responses?.responses ?? []) };
-    const parameters = [...pathParameters(route), ...queryParameters(input?.query)];
-    if (parameters.length > 0) {
-      operation.parameters = parameters;
-    }
-    if (input?.body) {
-      const content = {};
-      for (const [contentType, schema] of Object.entries(input.body)) {
-        content[BODY_MEDIA_TYPE[contentType] ?? contentType] = {
-          schema: rewriteRefs(schema)
-        };
-      }
-      if (Object.keys(content).length > 0) {
-        operation.requestBody = { required: true, content };
-      }
-    }
-    if (security && security.security.length > 0) {
-      operation.security = security.security;
+function pathFromSegments(segments) {
+  const pathSegments = [];
+  const params = [];
+  for (const segment of segments) {
+    const converted = urlSegment(segment);
+    if (converted.value) {
+      pathSegments.push(converted.value);
     }
-    if (security) {
-      Object.assign(securitySchemes, security.securitySchemes);
+    if (converted.param) {
+      params.push(converted.param);
     }
-    const openApiPath = toOpenApiPath(route.path);
-    const pathItem = documentPaths[openApiPath] ?? {};
-    pathItem[route.method.toLowerCase()] = operation;
-    documentPaths[openApiPath] = pathItem;
   }
-  const document = {
-    openapi: "3.1.0",
-    info: readProjectInfo(paths.cwd),
-    paths: documentPaths
+  return {
+    path: pathSegments.length > 0 ? `/${pathSegments.join("/")}` : "/",
+    params
   };
-  const components = {};
-  if (Object.keys(schemas).length > 0) {
-    components.schemas = schemas;
-  }
-  if (Object.keys(securitySchemes).length > 0) {
-    components.securitySchemes = securitySchemes;
-  }
-  if (Object.keys(components).length > 0) {
-    document.components = components;
-  }
-  return document;
-}
-async function writeOpenApi(paths, routes, data = {}) {
-  await writeJson((0, import_node_path7.join)(paths.outDir, "openapi.json"), buildOpenApiDocument(paths, routes, data));
-}
-
-// src/generator/param-types.ts
-var import_node_path8 = require("path");
-function paramsType(params) {
-  if (params.length === 0) {
-    return "{}";
-  }
-  const unique = /* @__PURE__ */ new Map();
-  for (const param of params) {
-    unique.set(param.name, param);
-  }
-  const fields = [...unique.values()].map((param) => `  ${JSON.stringify(param.name)}: string;`).join("\n");
-  return `{
-${fields}
-}`;
 }
-function varsType(typesDir, sharedFiles) {
-  if (sharedFiles.length === 0) {
-    return "{}";
+async function scanRouteFolders(routesDir) {
+  if (!(0, import_node_fs2.existsSync)(routesDir)) {
+    return [];
   }
-  return sharedFiles.map((file) => {
-    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
-    return `(typeof import(${spec}) extends { middleware: infer M } ? import("@boon4681/giri").InferStackVars<M> : {})`;
-  }).join("\n    & ");
-}
-function methodExports(typesDir, verbs) {
-  return verbs.map(({ method, file }) => {
-    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
-    const input = `import("@boon4681/giri").RouteInputOf<typeof import(${spec})>`;
-    const vars = `Vars & import("@boon4681/giri").MiddlewareVarsOf<typeof import(${spec})>`;
-    return `export type ${method} = import("@boon4681/giri").Handle<Params, ${input}, ${vars}>;`;
-  });
-}
-async function writeParamTypes(paths, folders) {
-  for (const { dir, params, sharedFiles, verbs } of folders) {
-    const file = typeFilePath(paths, dir);
-    const typesDir = (0, import_node_path8.dirname)(file);
-    const lines = [
-      GENERATED_HEADER,
-      `export type Params = ${paramsType(params)};`,
-      "export type RouteParams = Params;",
-      `type Vars = ${varsType(typesDir, sharedFiles)};`,
-      "export type Middleware<Injects extends Record<string, unknown> = {}> =",
-      '  import("@boon4681/giri").Middleware<Params, import("@boon4681/giri").ValidatedInput, Injects>;',
-      'export type Handle<Input extends import("@boon4681/giri").ValidatedInput = import("@boon4681/giri").ValidatedInput> =',
-      '  import("@boon4681/giri").Handle<Params, Input, Vars>;'
-    ];
-    if (verbs.length > 0) {
-      lines.push(...methodExports(typesDir, verbs));
+  const folders = [routesDir];
+  const walk = async (dir) => {
+    for (const entry of await (0, import_promises.readdir)(dir, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name !== "node_modules") {
+        const full = (0, import_node_path2.join)(dir, entry.name);
+        folders.push(full);
+        await walk(full);
+      }
     }
-    lines.push("");
-    await writeGenerated(file, lines.join("\n"));
-  }
-}
-
-// src/generator/inputs.ts
-function sanitize(schema) {
-  const { $schema, ...rest } = schema;
-  void $schema;
-  return rest;
+  };
+  await walk(routesDir);
+  return folders;
 }
-function inputToJsonSchema(schema) {
-  if (!isGiriInputSchema(schema)) {
-    return void 0;
+function routeParamsForDir(routesDir, dir) {
+  return pathFromSegments(physicalRouteSegments(routesDir, dir)).params;
+}
+function sharedFilesForDir(routesDir, dir) {
+  const segments = physicalRouteSegments(routesDir, dir);
+  const dirs = [routesDir];
+  let current = routesDir;
+  for (const segment of segments) {
+    current = (0, import_node_path2.join)(current, segment);
+    dirs.push(current);
   }
-  return sanitize(schema.toJsonSchema());
+  return dirs.map(sharedFileIn).filter((file) => Boolean(file));
 }
-function bodyToJsonSchemas(value) {
-  if (!isGiriBodySchema(value)) {
-    return void 0;
+async function scanRoutes(routesDir) {
+  if (!(0, import_node_fs2.existsSync)(routesDir)) {
+    return [];
   }
-  const out = {};
-  for (const [contentType, schema] of Object.entries(value.contents)) {
-    const json = inputToJsonSchema(schema);
-    if (json) {
-      out[contentType] = json;
+  const files = await (0, import_tinyglobby.glob)("**/+*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}", {
+    cwd: routesDir,
+    absolute: true,
+    onlyFiles: true
+  });
+  const routes = [];
+  for (const file of files) {
+    const method = methodFromFile((0, import_node_path2.basename)(file));
+    if (!method) {
+      continue;
     }
+    const routeDir = (0, import_node_path2.dirname)(file);
+    const routeSegments = physicalRouteSegments(routesDir, routeDir);
+    const { path, params } = pathFromSegments(routeSegments);
+    routes.push({
+      method,
+      path,
+      file,
+      routeDir,
+      routeSegments,
+      params,
+      sharedFiles: sharedFilesForDir(routesDir, routeDir)
+    });
   }
-  return Object.keys(out).length > 0 ? out : void 0;
+  return routes.sort((left, right) => {
+    const pathOrder = left.path.localeCompare(right.path);
+    if (pathOrder !== 0) {
+      return pathOrder;
+    }
+    return METHOD_ORDER.indexOf(left.method) - METHOD_ORDER.indexOf(right.method);
+  });
 }
 
-// src/generator/route-meta.ts
-function loadModule2(file) {
+// src/app.ts
+function loadModule(file) {
   const resolved = require.resolve(file);
   delete require.cache[resolved];
   return require(resolved);
 }
-function interopDefault2(value) {
+function interopDefault(value) {
   if (value && typeof value === "object" && "default" in value) {
     return value.default;
   }
   return value;
 }
-function middlewareFunctions(value) {
-  const exported = interopDefault2(value);
+function normalizeMiddleware(value, file) {
+  const exported = interopDefault(value);
+  if (exported === void 0) {
+    return [];
+  }
   if (typeof exported === "function") {
     return [exported];
   }
   if (Array.isArray(exported)) {
-    return exported.filter((fn) => typeof fn === "function");
+    for (const middleware of exported) {
+      if (typeof middleware !== "function") {
+        throw new Error(`Middleware export in ${file} must contain only functions.`);
+      }
+    }
+    return exported;
   }
-  return [];
+  throw new Error(`Middleware export in ${file} must be a function or an array of functions.`);
 }
-function readInput(routeModule) {
+function assertBodySchema(value, file) {
+  if (!isGiriBodySchema(value)) {
+    throw new Error(
+      `${file}: "body" must be wrapped with a validator, e.g. \`export const body = zod.body({ json: ... })\` from @boon4681/giri/validators/zod.`
+    );
+  }
+}
+function assertQuerySchema(value, file) {
+  if (!isGiriInputSchema(value)) {
+    throw new Error(
+      `${file}: "query" must be wrapped with a validator, e.g. \`export const query = zod.query(...)\` from @boon4681/giri/validators/zod.`
+    );
+  }
+}
+function routeInput(routeModule, file) {
   const input = {};
-  const body = bodyToJsonSchemas(routeModule.body);
-  const query = inputToJsonSchema(routeModule.query);
-  if (body) {
-    input.body = body;
+  if (routeModule.body !== void 0) {
+    assertBodySchema(routeModule.body, file);
+    input.body = routeModule.body;
   }
-  if (query) {
-    input.query = query;
+  if (routeModule.query !== void 0) {
+    assertQuerySchema(routeModule.query, file);
+    input.query = routeModule.query;
   }
   return input.body || input.query ? input : void 0;
 }
-function hiddenFrom(value) {
-  if (value === false) {
-    return true;
+function aliasValues(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function resolveAliasTarget(cwd, target, capture = "") {
+  const replaced = target.includes("*") ? target.replaceAll("*", capture) : target;
+  return (0, import_node_path3.isAbsolute)(replaced) ? replaced : (0, import_node_path3.resolve)(cwd, replaced);
+}
+function matchAlias(request, key) {
+  if (key.includes("*")) {
+    const [prefix2, suffix = ""] = key.split("*");
+    if (request.startsWith(prefix2) && request.endsWith(suffix)) {
+      return request.slice(prefix2.length, request.length - suffix.length);
+    }
+    return void 0;
   }
-  if (value === true) {
-    return false;
+  if (request === key) {
+    return "";
   }
-  if (value && typeof value === "object" && "hidden" in value) {
-    return Boolean(value.hidden);
+  const prefix = `${key}/`;
+  if (request.startsWith(prefix)) {
+    return request.slice(prefix.length);
   }
   return void 0;
 }
-function collectHidden(route, routeModule, loadShared) {
-  let hidden = false;
-  for (const file of route.sharedFiles) {
-    const opinion = hiddenFrom(loadShared(file).openapi);
-    if (opinion !== void 0) {
-      hidden = opinion;
+function resolveAliasRequest(request, alias, cwd) {
+  for (const [key, value] of Object.entries(alias ?? {})) {
+    const capture = matchAlias(request, key);
+    if (capture === void 0) {
+      continue;
+    }
+    const [target] = aliasValues(value);
+    if (!target) {
+      continue;
     }
+    return resolveAliasTarget(cwd, target, capture);
   }
-  const verb = hiddenFrom(routeModule.openapi);
-  return verb ?? hidden;
+  return void 0;
 }
-function collectSecurity(route, routeModule, loadShared) {
-  const skipInherited = Boolean(
-    routeModule.config?.skipInherited
-  );
-  const middleware = [];
-  if (!skipInherited) {
-    for (const file of route.sharedFiles) {
-      middleware.push(...middlewareFunctions(loadShared(file).middleware));
-    }
+function registerAliasResolver(alias, cwd) {
+  if (!alias || Object.keys(alias).length === 0) {
+    return () => {
+    };
   }
-  middleware.push(...middlewareFunctions(routeModule.middleware));
-  const security = [];
-  const securitySchemes = {};
-  for (const fn of middleware) {
-    const openapi = fn.openapi;
-    if (openapi?.security) {
-      for (const requirement of openapi.security) {
-        if (!security.some((seen) => JSON.stringify(seen) === JSON.stringify(requirement))) {
-          security.push(requirement);
-        }
-      }
-    }
-    if (openapi?.securitySchemes) {
-      Object.assign(securitySchemes, openapi.securitySchemes);
-    }
+  const moduleWithResolver = import_node_module.default;
+  const originalResolveFilename = moduleWithResolver._resolveFilename;
+  moduleWithResolver._resolveFilename = function resolveWithGiriAlias(request, parent, isMain, options) {
+    return originalResolveFilename.call(
+      this,
+      resolveAliasRequest(request, alias, cwd) ?? request,
+      parent,
+      isMain,
+      options
+    );
+  };
+  return () => {
+    moduleWithResolver._resolveFilename = originalResolveFilename;
+  };
+}
+var GIRI_ALIAS_PREFIX = "$giri/";
+var giriOutDir;
+var giriResolverInstalled = false;
+function ensureGiriAliasResolver(outDir) {
+  giriOutDir = outDir;
+  if (giriResolverInstalled) {
+    return;
   }
-  return security.length > 0 || Object.keys(securitySchemes).length > 0 ? { security, securitySchemes } : void 0;
+  giriResolverInstalled = true;
+  const moduleWithResolver = import_node_module.default;
+  const originalResolveFilename = moduleWithResolver._resolveFilename;
+  moduleWithResolver._resolveFilename = function resolveWithGiriInternalAlias(request, parent, isMain, options) {
+    const mapped = typeof request === "string" && request.startsWith(GIRI_ALIAS_PREFIX) && giriOutDir ? (0, import_node_path3.join)(giriOutDir, request.slice(GIRI_ALIAS_PREFIX.length)) : request;
+    return originalResolveFilename.call(this, mapped, parent, isMain, options);
+  };
 }
-async function extractRouteMeta(config, paths, routes) {
-  const byFile = /* @__PURE__ */ new Map();
-  const { unregister } = await safeRegister();
-  const unregisterAlias = registerAliasResolver(config.alias, paths.cwd);
-  const sharedCache = /* @__PURE__ */ new Map();
-  const loadShared = (file) => {
-    if (!sharedCache.has(file)) {
-      try {
-        sharedCache.set(file, loadModule2(file));
-      } catch {
-        sharedCache.set(file, {});
-      }
-    }
-    return sharedCache.get(file);
+function resolveGiriPaths(config, cwd = process.cwd()) {
+  return {
+    cwd: (0, import_node_path3.resolve)(cwd),
+    routesDir: (0, import_node_path3.resolve)(cwd, "src/routes"),
+    outDir: (0, import_node_path3.resolve)(cwd, config.outDir ?? ".giri")
   };
+}
+async function buildGiriApp(config, options = {}) {
+  const paths = resolveGiriPaths(config, options.cwd);
+  const routes = await scanRoutes(paths.routesDir);
+  const app = config.adapter.createApp();
+  ensureGiriAliasResolver(paths.outDir);
+  const { unregister } = await safeRegister();
+  const unregisterAliasResolver = registerAliasResolver(config.alias, paths.cwd);
   try {
     for (const route of routes) {
-      try {
-        const routeModule = loadModule2(route.file);
-        const meta = {};
-        const input = readInput(routeModule);
-        const security = collectSecurity(route, routeModule, loadShared);
-        const hidden = collectHidden(route, routeModule, loadShared);
-        if (input) {
-          meta.input = input;
-        }
-        if (security) {
-          meta.security = security;
-        }
-        if (hidden) {
-          meta.hidden = true;
-        }
-        if (meta.input || meta.security || meta.hidden) {
-          byFile.set(route.file, meta);
-        }
-      } catch {
+      const routeModule = loadModule(route.file);
+      if (typeof routeModule.handle !== "function") {
+        throw new Error(`${route.file} must export a named handle function.`);
       }
+      const folderMiddleware = routeModule.config?.skipInherited ? [] : route.sharedFiles.flatMap(
+        (file) => normalizeMiddleware(loadModule(file).middleware, file)
+      );
+      const verbMiddleware = normalizeMiddleware(routeModule.middleware, route.file);
+      config.adapter.register(app, {
+        method: route.method,
+        path: route.path,
+        handle: routeModule.handle,
+        middleware: [...folderMiddleware, ...verbMiddleware],
+        input: routeInput(routeModule, route.file),
+        services: options.services
+      });
     }
   } finally {
-    unregisterAlias();
+    unregisterAliasResolver();
     unregister();
   }
-  return byFile;
+  return { app, routes, paths };
 }
 
-// src/generator/route-types.ts
-var import_node_path9 = require("path");
-async function writeRouteTypes(paths, routes) {
-  const file = (0, import_node_path9.join)(paths.outDir, "routes.d.ts");
-  const lines = [
-    GENERATED_HEADER,
-    "export interface RouteParams {"
-  ];
-  for (const route of routes) {
-    const typeFile = typeFilePath(paths, route.routeDir);
-    lines.push(
-      `  ${JSON.stringify(`${route.method} ${route.path}`)}: import(${JSON.stringify(
-        importPath(file, typeFile)
-      )}).Params;`
-    );
+// src/generator/sync.ts
+var import_node_fs6 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path11 = require("path");
+
+// src/generator/app-types.ts
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
+
+// src/generator/util.ts
+var import_node_fs3 = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path4 = require("path");
+var GENERATED_HEADER = "// Generated by giri sync. Do not edit.";
+function slash(path) {
+  return path.split(import_node_path4.sep).join("/");
+}
+function importPath(fromFile, toFile) {
+  let path = slash((0, import_node_path4.relative)((0, import_node_path4.dirname)(fromFile), toFile)).replace(/\.d\.ts$/, "");
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
   }
-  lines.push("}", "");
-  await writeGenerated(file, lines.join("\n"));
+  return path;
 }
-
-// src/generator/schema/program.ts
-var import_typescript = __toESM(require("typescript"));
-var DEFAULT_OPTIONS = {
-  target: import_typescript.default.ScriptTarget.ES2022,
-  module: import_typescript.default.ModuleKind.NodeNext,
-  moduleResolution: import_typescript.default.ModuleResolutionKind.NodeNext,
-  strict: true,
-  skipLibCheck: true,
-  noEmit: true
-};
-function createSchemaProgram(paths, routeFiles) {
-  let options = { ...DEFAULT_OPTIONS };
-  const configPath = import_typescript.default.findConfigFile(paths.cwd, import_typescript.default.sys.fileExists, "tsconfig.json");
-  if (configPath) {
-    const parsed = import_typescript.default.getParsedCommandLineOfConfigFile(configPath, {}, {
-      ...import_typescript.default.sys,
-      onUnRecoverableConfigFileDiagnostic: () => {
-      }
-    });
-    if (parsed) {
-      options = { ...parsed.options, noEmit: true };
+function relativeConfigPath(fromDir, toPath) {
+  let path = slash((0, import_node_path4.relative)(fromDir, toPath));
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  return path;
+}
+function moduleSpecifier(fromDir, target) {
+  let path = slash((0, import_node_path4.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  return path;
+}
+function typeFilePath(paths, routeDir) {
+  const sourceDir = (0, import_node_path4.relative)(paths.cwd, routeDir);
+  return (0, import_node_path4.join)(paths.outDir, "types", sourceDir, "$types.d.ts");
+}
+function assertSafeOutDir(paths) {
+  const rel = (0, import_node_path4.relative)(paths.cwd, paths.outDir);
+  if (!rel || rel.startsWith("..") || rel.includes(`..${import_node_path4.sep}`)) {
+    throw new Error(`Refusing to sync outside the project root: ${paths.outDir}`);
+  }
+}
+var writeCache = /* @__PURE__ */ new Map();
+async function writeGenerated(path, content) {
+  if (writeCache.get(path) === content && (0, import_node_fs3.existsSync)(path)) {
+    return;
+  }
+  await (0, import_promises2.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
+  await (0, import_promises2.writeFile)(path, content);
+  writeCache.set(path, content);
+}
+async function writeJson(path, value) {
+  await writeGenerated(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function pruneDir(dir, keep) {
+  let entries;
+  try {
+    entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = (0, import_node_path4.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      await pruneDir(full, keep);
+      await (0, import_promises2.rmdir)(full).catch(() => {
+      });
+    } else if (!keep.has(full)) {
+      await (0, import_promises2.rm)(full, { force: true });
+      writeCache.delete(full);
     }
   }
-  return import_typescript.default.createProgram(routeFiles, options);
 }
 
-// src/generator/schema/responses.ts
-var import_typescript3 = __toESM(require("typescript"));
-
-// src/generator/schema/json-schema.ts
-var import_typescript2 = __toESM(require("typescript"));
-function createWalkContext(checker, location) {
-  return {
-    checker,
-    location,
-    defs: {},
-    inProgress: /* @__PURE__ */ new Map(),
-    usedDefs: /* @__PURE__ */ new Set(),
-    warnings: []
-  };
+// src/generator/app-types.ts
+var MAIN_EXTENSIONS = ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
+function findMainFile(cwd) {
+  for (const ext of MAIN_EXTENSIONS) {
+    const file = (0, import_node_path5.join)(cwd, "src", `main.${ext}`);
+    if ((0, import_node_fs4.existsSync)(file)) {
+      return file;
+    }
+  }
+  return void 0;
 }
-function typeId(type) {
-  return type.id;
+function moduleSpecifier2(fromDir, target) {
+  let path = slash((0, import_node_path5.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  return path;
 }
-function intrinsicName(type) {
-  return type.intrinsicName;
+async function writeAppTypes(paths) {
+  const file = (0, import_node_path5.join)(paths.outDir, "types", "app.d.ts");
+  const mainFile = findMainFile(paths.cwd);
+  if (!mainFile) {
+    await writeGenerated(file, [GENERATED_HEADER, "export {};", ""].join("\n"));
+    return;
+  }
+  const spec = moduleSpecifier2((0, import_node_path5.join)(paths.outDir, "types"), mainFile);
+  await writeGenerated(
+    file,
+    [
+      GENERATED_HEADER,
+      "declare global {",
+      "  namespace Giri {",
+      "    interface Register {",
+      `      app: typeof import(${JSON.stringify(spec)}) extends {`,
+      "        init: (...args: any[]) => infer R;",
+      "      }",
+      "        ? Awaited<R>",
+      "        : Record<string, unknown>;",
+      "    }",
+      "  }",
+      "}",
+      "export {};",
+      ""
+    ].join("\n")
+  );
 }
-function isDateType(type) {
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  return symbol?.getName() === "Date";
+
+// src/generator/manifest.ts
+var import_node_path6 = require("path");
+async function writeManifest(paths, routes, data = {}) {
+  const manifest = {
+    version: 1,
+    routes: routes.map((route) => {
+      const responses = data.responsesByFile?.get(route.file);
+      const input = data.inputsByFile?.get(route.file);
+      const security = data.securityByFile?.get(route.file);
+      return {
+        method: route.method,
+        path: route.path,
+        file: slash((0, import_node_path6.relative)(paths.cwd, route.file)),
+        params: route.params,
+        shared: route.sharedFiles.map((file) => slash((0, import_node_path6.relative)(paths.cwd, file))),
+        types: slash((0, import_node_path6.relative)(paths.cwd, typeFilePath(paths, route.routeDir))),
+        ...data.hiddenFiles?.has(route.file) ? { hidden: true } : {},
+        ...input ? { input } : {},
+        ...security && security.security.length > 0 ? { security: security.security } : {},
+        responses: responses?.responses ?? [],
+        ...responses && Object.keys(responses.$defs).length > 0 ? { $defs: responses.$defs } : {}
+      };
+    })
+  };
+  await writeJson((0, import_node_path6.join)(paths.outDir, "manifest.json"), manifest);
 }
-function literalValuesOf(types) {
-  const values = [];
-  for (const member of types) {
-    if (member.isStringLiteral() || member.isNumberLiteral()) {
-      values.push(member.value);
-    } else if (member.flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
-      values.push(intrinsicName(member) === "true");
-    } else {
-      return void 0;
+
+// src/generator/openapi.ts
+var import_node_fs5 = require("fs");
+var import_node_path7 = require("path");
+var REASON = {
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  409: "Conflict",
+  422: "Unprocessable Entity",
+  500: "Internal Server Error"
+};
+function toOpenApiPath(path) {
+  return path.replace(/:([A-Za-z0-9_]+)(?:\{[^}]*\})?/g, "{$1}");
+}
+function rewriteRefs(value) {
+  if (Array.isArray(value)) {
+    return value.map(rewriteRefs);
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      if (key === "$ref" && typeof child === "string" && child.startsWith("#/$defs/")) {
+        out.$ref = child.replace("#/$defs/", "#/components/schemas/");
+      } else {
+        out[key] = rewriteRefs(child);
+      }
     }
+    return out;
   }
-  return values;
+  return value;
 }
-function walkUnion(type, ctx) {
-  const flag = import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void | import_typescript2.default.TypeFlags.Never;
-  const members = type.types.filter((member) => !(member.flags & flag));
-  if (members.length === 1) {
-    return walkType(members[0], ctx);
+function mediaTypeFor(format) {
+  return format === "text" ? "text/plain" : "application/json";
+}
+var BODY_MEDIA_TYPE = {
+  json: "application/json",
+  form: "multipart/form-data",
+  urlencoded: "application/x-www-form-urlencoded",
+  text: "text/plain"
+};
+function buildResponses(responses) {
+  if (responses.length === 0) {
+    return { default: { description: "Response" } };
   }
-  const enumValues = literalValuesOf(members);
-  if (enumValues) {
-    return { enum: enumValues };
+  const out = {};
+  for (const response of responses) {
+    const key = response.status === "default" ? "default" : String(response.status);
+    const description = typeof response.status === "number" && REASON[response.status] || "Response";
+    out[key] = {
+      description,
+      content: { [mediaTypeFor(response.format)]: { schema: rewriteRefs(response.schema) } }
+    };
   }
-  return { anyOf: members.map((member) => walkType(member, ctx)) };
+  return out;
 }
-function buildObjectSchema(type, ctx) {
-  const { checker } = ctx;
-  const indexInfo = checker.getIndexInfoOfType(type, import_typescript2.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript2.default.IndexKind.Number);
-  const properties = {};
-  const required = [];
-  for (const symbol of checker.getPropertiesOfType(type)) {
-    const name = symbol.getName();
-    const propType = checker.getTypeOfSymbolAtLocation(symbol, ctx.location);
-    const optional = Boolean(symbol.getFlags() & import_typescript2.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript2.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript2.default.TypeFlags.Undefined));
-    properties[name] = walkType(propType, ctx);
-    if (!optional) {
-      required.push(name);
+function pathParameters(route) {
+  const seen = /* @__PURE__ */ new Set();
+  const params = [];
+  for (const param of route.params) {
+    if (seen.has(param.name)) {
+      continue;
     }
+    seen.add(param.name);
+    params.push({ name: param.name, in: "path", required: true, schema: { type: "string" } });
   }
-  const schema = { type: "object" };
-  if (Object.keys(properties).length > 0) {
-    schema.properties = properties;
-  }
-  if (required.length > 0) {
-    schema.required = required;
-  }
-  if (indexInfo) {
-    schema.additionalProperties = walkType(indexInfo.type, ctx);
-  } else if (Object.keys(properties).length > 0) {
-    schema.additionalProperties = false;
-  }
-  return schema;
+  return params;
 }
-function defName(type) {
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  const name = symbol?.getName();
-  if (name && name !== "__type" && name !== "__object") {
-    return name;
+function queryParameters(query) {
+  if (!query || query.type !== "object" || typeof query.properties !== "object") {
+    return [];
   }
-  return `Anonymous${typeId(type)}`;
+  const properties = query.properties;
+  const required = Array.isArray(query.required) ? query.required : [];
+  return Object.entries(properties).map(([name, schema]) => ({
+    name,
+    in: "query",
+    required: required.includes(name),
+    schema: rewriteRefs(schema)
+  }));
 }
-function walkObject(type, ctx) {
-  const { checker } = ctx;
-  if (isDateType(type)) {
-    return { type: "string", format: "date-time" };
-  }
-  if (checker.isArrayType(type)) {
-    const [element] = checker.getTypeArguments(type);
-    return { type: "array", items: element ? walkType(element, ctx) : {} };
-  }
-  if (checker.isTupleType(type)) {
-    const elements = checker.getTypeArguments(type);
-    return { type: "array", items: elements.map((element) => walkType(element, ctx)) };
-  }
-  const id = typeId(type);
-  const existing = ctx.inProgress.get(id);
-  if (existing) {
-    ctx.usedDefs.add(existing);
-    return { $ref: `#/$defs/${existing}` };
-  }
-  const name = defName(type);
-  ctx.inProgress.set(id, name);
-  const schema = buildObjectSchema(type, ctx);
-  ctx.inProgress.delete(id);
-  if (ctx.usedDefs.has(name)) {
-    ctx.defs[name] = schema;
-    return { $ref: `#/$defs/${name}` };
+function readProjectInfo(cwd) {
+  const file = (0, import_node_path7.join)(cwd, "package.json");
+  if ((0, import_node_fs5.existsSync)(file)) {
+    try {
+      const pkg = JSON.parse((0, import_node_fs5.readFileSync)(file, "utf8"));
+      return { title: pkg.name ?? "giri API", version: pkg.version ?? "0.0.0" };
+    } catch {
+    }
   }
-  return schema;
+  return { title: "giri API", version: "0.0.0" };
 }
-function walkType(type, ctx) {
-  const flags = type.flags;
-  if (flags & (import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown)) {
-    return {};
-  }
-  if (flags & import_typescript2.default.TypeFlags.Null) {
-    return { type: "null" };
+function buildOpenApiDocument(paths, routes, data = {}) {
+  const documentPaths = {};
+  const schemas = {};
+  const securitySchemes = {};
+  for (const route of routes) {
+    if (data.hiddenFiles?.has(route.file)) {
+      continue;
+    }
+    const responses = data.responsesByFile?.get(route.file);
+    const input = data.inputsByFile?.get(route.file);
+    const security = data.securityByFile?.get(route.file);
+    for (const [name, schema] of Object.entries(responses?.$defs ?? {})) {
+      schemas[name] = rewriteRefs(schema);
+    }
+    const operation = { responses: buildResponses(responses?.responses ?? []) };
+    const parameters = [...pathParameters(route), ...queryParameters(input?.query)];
+    if (parameters.length > 0) {
+      operation.parameters = parameters;
+    }
+    if (input?.body) {
+      const content = {};
+      for (const [contentType, schema] of Object.entries(input.body)) {
+        content[BODY_MEDIA_TYPE[contentType] ?? contentType] = {
+          schema: rewriteRefs(schema)
+        };
+      }
+      if (Object.keys(content).length > 0) {
+        operation.requestBody = { required: true, content };
+      }
+    }
+    if (security && security.security.length > 0) {
+      operation.security = security.security;
+    }
+    if (security) {
+      Object.assign(securitySchemes, security.securitySchemes);
+    }
+    const openApiPath = toOpenApiPath(route.path);
+    const pathItem = documentPaths[openApiPath] ?? {};
+    pathItem[route.method.toLowerCase()] = operation;
+    documentPaths[openApiPath] = pathItem;
   }
-  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
-    return {};
+  const document = {
+    openapi: "3.1.0",
+    info: readProjectInfo(paths.cwd),
+    paths: documentPaths
+  };
+  const components = {};
+  if (Object.keys(schemas).length > 0) {
+    components.schemas = schemas;
   }
-  if (flags & (import_typescript2.default.TypeFlags.BigInt | import_typescript2.default.TypeFlags.BigIntLiteral)) {
-    ctx.warnings.push("bigint is not JSON-serializable (JSON.stringify throws); documented as string.");
-    return { type: "string" };
+  if (Object.keys(securitySchemes).length > 0) {
+    components.securitySchemes = securitySchemes;
   }
-  if (type.isStringLiteral()) {
-    return { type: "string", const: type.value };
+  if (Object.keys(components).length > 0) {
+    document.components = components;
   }
-  if (type.isNumberLiteral()) {
-    return { type: "number", const: type.value };
+  return document;
+}
+async function writeOpenApi(paths, routes, data = {}) {
+  await writeJson((0, import_node_path7.join)(paths.outDir, "openapi.json"), buildOpenApiDocument(paths, routes, data));
+}
+
+// src/generator/param-types.ts
+var import_node_path8 = require("path");
+function paramsType(params) {
+  if (params.length === 0) {
+    return "{}";
   }
-  if (flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
-    return { type: "boolean", const: intrinsicName(type) === "true" };
+  const unique = /* @__PURE__ */ new Map();
+  for (const param of params) {
+    unique.set(param.name, param);
   }
-  if (flags & import_typescript2.default.TypeFlags.String) {
-    return { type: "string" };
+  const fields = [...unique.values()].map((param) => `  ${JSON.stringify(param.name)}: string;`).join("\n");
+  return `{
+${fields}
+}`;
+}
+function varsType(typesDir, sharedFiles) {
+  if (sharedFiles.length === 0) {
+    return "{}";
   }
-  if (flags & import_typescript2.default.TypeFlags.Number) {
-    return { type: "number" };
+  return sharedFiles.map((file) => {
+    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
+    return `(typeof import(${spec}) extends { middleware: infer M } ? import("@boon4681/giri").InferStackVars<M> : {})`;
+  }).join("\n    & ");
+}
+function methodExports(typesDir, verbs) {
+  return verbs.map(({ method, file }) => {
+    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
+    const input = `import("@boon4681/giri").RouteInputOf<typeof import(${spec})>`;
+    const vars = `Vars & import("@boon4681/giri").MiddlewareVarsOf<typeof import(${spec})>`;
+    return `export type ${method} = import("@boon4681/giri").Handle<Params, ${input}, ${vars}>;`;
+  });
+}
+async function writeParamTypes(paths, folders) {
+  for (const { dir, params, sharedFiles, verbs } of folders) {
+    const file = typeFilePath(paths, dir);
+    const typesDir = (0, import_node_path8.dirname)(file);
+    const lines = [
+      GENERATED_HEADER,
+      `export type Params = ${paramsType(params)};`,
+      "export type RouteParams = Params;",
+      `type Vars = ${varsType(typesDir, sharedFiles)};`,
+      "export type Middleware<Injects extends Record<string, unknown> = {}> =",
+      '  import("@boon4681/giri").Middleware<Params, import("@boon4681/giri").ValidatedInput, Injects>;',
+      'export type Handle<Input extends import("@boon4681/giri").ValidatedInput = import("@boon4681/giri").ValidatedInput> =',
+      '  import("@boon4681/giri").Handle<Params, Input, Vars>;'
+    ];
+    if (verbs.length > 0) {
+      lines.push(...methodExports(typesDir, verbs));
+    }
+    lines.push("");
+    await writeGenerated(file, lines.join("\n"));
   }
-  if (flags & import_typescript2.default.TypeFlags.Boolean) {
-    return { type: "boolean" };
+}
+
+// src/generator/inputs.ts
+function sanitize(schema) {
+  const { $schema, ...rest } = schema;
+  void $schema;
+  return rest;
+}
+function inputToJsonSchema(schema) {
+  if (!isGiriInputSchema(schema)) {
+    return void 0;
   }
-  if (type.isUnion()) {
-    return walkUnion(type, ctx);
+  return sanitize(schema.toJsonSchema());
+}
+function bodyToJsonSchemas(value) {
+  if (!isGiriBodySchema(value)) {
+    return void 0;
   }
-  if (flags & import_typescript2.default.TypeFlags.Object || type.isIntersection()) {
-    return walkObject(type, ctx);
+  const out = {};
+  for (const [contentType, schema] of Object.entries(value.contents)) {
+    const json = inputToJsonSchema(schema);
+    if (json) {
+      out[contentType] = json;
+    }
   }
-  return {};
+  return Object.keys(out).length > 0 ? out : void 0;
 }
 
-// src/generator/schema/responses.ts
-function findHandleFunction(source) {
-  let found;
-  const isExported = (node) => import_typescript3.default.canHaveModifiers(node) && (import_typescript3.default.getModifiers(node)?.some((m) => m.kind === import_typescript3.default.SyntaxKind.ExportKeyword) ?? false);
-  for (const statement of source.statements) {
-    if (import_typescript3.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
-      found = statement;
-    }
-    if (import_typescript3.default.isVariableStatement(statement) && isExported(statement)) {
-      for (const declaration of statement.declarationList.declarations) {
-        if (import_typescript3.default.isIdentifier(declaration.name) && declaration.name.text === "handle" && declaration.initializer && (import_typescript3.default.isArrowFunction(declaration.initializer) || import_typescript3.default.isFunctionExpression(declaration.initializer))) {
-          found = declaration.initializer;
-        }
-      }
-    }
+// src/generator/route-meta.ts
+function loadModule2(file) {
+  const resolved = require.resolve(file);
+  delete require.cache[resolved];
+  return require(resolved);
+}
+function interopDefault2(value) {
+  if (value && typeof value === "object" && "default" in value) {
+    return value.default;
   }
-  return found;
+  return value;
 }
-function collectReturnExpressions(fn) {
-  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
-    return [fn.body];
+function middlewareFunctions(value) {
+  const exported = interopDefault2(value);
+  if (typeof exported === "function") {
+    return [exported];
   }
-  if (!fn.body) {
-    return [];
+  if (Array.isArray(exported)) {
+    return exported.filter((fn) => typeof fn === "function");
   }
-  const expressions = [];
-  const visit = (node) => {
-    if (import_typescript3.default.isFunctionDeclaration(node) || import_typescript3.default.isFunctionExpression(node) || import_typescript3.default.isArrowFunction(node)) {
-      return;
-    }
-    if (import_typescript3.default.isReturnStatement(node) && node.expression) {
-      expressions.push(node.expression);
-    }
-    import_typescript3.default.forEachChild(node, visit);
-  };
-  import_typescript3.default.forEachChild(fn.body, visit);
-  return expressions;
-}
-function propertyType(checker, type, name, location) {
-  const symbol = checker.getPropertyOfType(type, name);
-  return symbol ? checker.getTypeOfSymbolAtLocation(symbol, location) : void 0;
-}
-function isTypedResponse2(checker, type) {
-  return Boolean(
-    checker.getPropertyOfType(type, "data") && checker.getPropertyOfType(type, "status") && checker.getPropertyOfType(type, "format")
-  );
+  return [];
 }
-function readFromCall(checker, expression) {
-  if (!import_typescript3.default.isCallExpression(expression) || !import_typescript3.default.isPropertyAccessExpression(expression.expression)) {
-    return void 0;
+function readInput(routeModule) {
+  const input = {};
+  const body = bodyToJsonSchemas(routeModule.body);
+  const query = inputToJsonSchema(routeModule.query);
+  if (body) {
+    input.body = body;
   }
-  const method = expression.expression.name.text;
-  if (method !== "json" && method !== "text") {
-    return void 0;
+  if (query) {
+    input.query = query;
   }
-  if (!isTypedResponse2(checker, checker.getTypeAtLocation(expression))) {
-    return void 0;
+  return input.body || input.query ? input : void 0;
+}
+function hiddenFrom(value) {
+  if (value === false) {
+    return true;
   }
-  const [dataArg, statusArg] = expression.arguments;
-  if (!dataArg) {
-    return void 0;
+  if (value === true) {
+    return false;
   }
-  let status = 200;
-  if (statusArg) {
-    const statusType = checker.getTypeAtLocation(statusArg);
-    status = statusType.isNumberLiteral() ? statusType.value : "default";
+  if (value && typeof value === "object" && "hidden" in value) {
+    return Boolean(value.hidden);
   }
-  return { status, format: method === "text" ? "text" : "json", data: checker.getTypeAtLocation(dataArg) };
+  return void 0;
 }
-function readFromType(checker, type, location) {
-  const dataType = propertyType(checker, type, "data", location);
-  const statusType = propertyType(checker, type, "status", location);
-  const formatType = propertyType(checker, type, "format", location);
-  if (!dataType || !statusType || !formatType) {
-    return void 0;
+function collectHidden(route, routeModule, loadShared) {
+  let hidden = false;
+  for (const file of route.sharedFiles) {
+    const opinion = hiddenFrom(loadShared(file).openapi);
+    if (opinion !== void 0) {
+      hidden = opinion;
+    }
   }
-  const status = statusType.isNumberLiteral() ? statusType.value : "default";
-  const format = formatType.isStringLiteral() && formatType.value === "text" ? "text" : "json";
-  return { status, format, data: dataType };
-}
-function constituents(type) {
-  return type.isUnion() ? type.types : [type];
+  const verb = hiddenFrom(routeModule.openapi);
+  return verb ?? hidden;
 }
-function extractRouteResponses(program, file) {
-  const result = { responses: [], opaque: false, warnings: [], $defs: {} };
-  const source = program.getSourceFile(file);
-  if (!source) {
-    return result;
-  }
-  const checker = program.getTypeChecker();
-  const fn = findHandleFunction(source);
-  if (!fn) {
-    return result;
+function collectSecurity(route, routeModule, loadShared) {
+  const skipInherited = Boolean(
+    routeModule.config?.skipInherited
+  );
+  const middleware = [];
+  if (!skipInherited) {
+    for (const file of route.sharedFiles) {
+      middleware.push(...middlewareFunctions(loadShared(file).middleware));
+    }
   }
-  const ctx = createWalkContext(checker, fn);
-  const byStatus = /* @__PURE__ */ new Map();
-  const record = (hit) => {
-    const schema = walkType(hit.data, ctx);
-    const bucket = byStatus.get(hit.status) ?? { format: hit.format, schemas: [] };
-    bucket.schemas.push(schema);
-    byStatus.set(hit.status, bucket);
-  };
-  for (const expression of collectReturnExpressions(fn)) {
-    const fromCall = readFromCall(checker, expression);
-    if (fromCall) {
-      record(fromCall);
-      continue;
+  middleware.push(...middlewareFunctions(routeModule.middleware));
+  const security = [];
+  const securitySchemes = {};
+  for (const fn of middleware) {
+    const openapi = fn.openapi;
+    if (openapi?.security) {
+      for (const requirement of openapi.security) {
+        if (!security.some((seen) => JSON.stringify(seen) === JSON.stringify(requirement))) {
+          security.push(requirement);
+        }
+      }
     }
-    let matched = false;
-    for (const member of constituents(checker.getTypeAtLocation(expression))) {
-      const hit = readFromType(checker, member, expression);
-      if (hit) {
-        record(hit);
-        matched = true;
+    if (openapi?.securitySchemes) {
+      Object.assign(securitySchemes, openapi.securitySchemes);
+    }
+  }
+  return security.length > 0 || Object.keys(securitySchemes).length > 0 ? { security, securitySchemes } : void 0;
+}
+async function extractRouteMeta(config, paths, routes) {
+  const byFile = /* @__PURE__ */ new Map();
+  const { unregister } = await safeRegister();
+  const unregisterAlias = registerAliasResolver(config.alias, paths.cwd);
+  const sharedCache = /* @__PURE__ */ new Map();
+  const loadShared = (file) => {
+    if (!sharedCache.has(file)) {
+      try {
+        sharedCache.set(file, loadModule2(file));
+      } catch {
+        sharedCache.set(file, {});
       }
     }
-    if (!matched) {
-      result.opaque = true;
+    return sharedCache.get(file);
+  };
+  try {
+    for (const route of routes) {
+      try {
+        const routeModule = loadModule2(route.file);
+        const meta = {};
+        const input = readInput(routeModule);
+        const security = collectSecurity(route, routeModule, loadShared);
+        const hidden = collectHidden(route, routeModule, loadShared);
+        if (input) {
+          meta.input = input;
+        }
+        if (security) {
+          meta.security = security;
+        }
+        if (hidden) {
+          meta.hidden = true;
+        }
+        if (meta.input || meta.security || meta.hidden) {
+          byFile.set(route.file, meta);
+        }
+      } catch {
+      }
     }
+  } finally {
+    unregisterAlias();
+    unregister();
   }
-  for (const [status, { format, schemas }] of byStatus) {
-    const schema = schemas.length === 1 ? schemas[0] : { anyOf: schemas };
-    result.responses.push({ status, format, schema });
+  return byFile;
+}
+
+// src/generator/route-types.ts
+var import_node_path9 = require("path");
+async function writeRouteTypes(paths, routes) {
+  const file = (0, import_node_path9.join)(paths.outDir, "routes.d.ts");
+  const lines = [
+    GENERATED_HEADER,
+    "export interface RouteParams {"
+  ];
+  for (const route of routes) {
+    const typeFile = typeFilePath(paths, route.routeDir);
+    lines.push(
+      `  ${JSON.stringify(`${route.method} ${route.path}`)}: import(${JSON.stringify(
+        importPath(file, typeFile)
+      )}).Params;`
+    );
   }
-  result.responses.sort((a, b) => Number(a.status) - Number(b.status));
-  result.warnings = ctx.warnings;
-  result.$defs = ctx.defs;
-  return result;
+  lines.push("}", "");
+  await writeGenerated(file, lines.join("\n"));
 }
 
 // src/generator/tsconfig.ts
@@ -1602,20 +1684,21 @@ async function typeFolders(paths, routes) {
     verbs: verbsByDir.get(slash(dir)) ?? []
   }));
 }
-function extractResponses(paths, routes) {
+async function extractResponses(paths, routes) {
   const byFile = /* @__PURE__ */ new Map();
   if (routes.length === 0) {
     return byFile;
   }
   try {
+    const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
     const files = [...new Set(routes.map((route) => route.file))];
     const appTypes = (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts");
-    const program = createSchemaProgram(
+    const program = createSchemaProgram2(
       paths,
       (0, import_node_fs6.existsSync)(appTypes) ? [...files, appTypes] : files
     );
     for (const file of files) {
-      byFile.set(file, extractRouteResponses(program, file));
+      byFile.set(file, extractRouteResponses2(program, file));
     }
   } catch (error) {
     console.warn(`giri: skipped response schema generation (${error.message}).`);
@@ -1657,7 +1740,7 @@ async function syncProject(config, options = {}) {
   await writeRouteTypes(paths, routes);
   await writeAppTypes(paths);
   await writeTsConfig(paths, config);
-  const responsesByFile = extractResponses(paths, routes);
+  const responsesByFile = await extractResponses(paths, routes);
   const { inputsByFile, securityByFile, hiddenFiles } = await extractMeta(config, paths, routes);
   const data = { responsesByFile, inputsByFile, securityByFile, hiddenFiles };
   await writeManifest(paths, routes, data);