@boon4681/giri 0.0.1 → 0.0.2-alpha-2

package/dist/cli.js

@@ -45,1286 +45,1335 @@ var init_es5 = __esm({
   }
 });
 
-// src/cli.ts
-var import_node_child_process = require("child_process");
-var import_node_fs9 = require("fs");
-var import_promises4 = require("fs/promises");
-var import_node_path15 = require("path");
-var prompts = __toESM(require("@clack/prompts"));
-
-// 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);
+// 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: () => {
       }
+    });
+    if (parsed) {
+      options = { ...parsed.options, noEmit: true };
     }
-    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: () => {
-      }
+  return import_typescript.default.createProgram(routeFiles, options);
+}
+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
     };
   }
-  await assertES5(res.unregister);
-  return res;
-};
-var load = async () => {
-  const defaultTsConfigExists = (0, import_node_fs.existsSync)((0, import_node_path.resolve)("giri.config.ts"));
-  const defaultJsConfigExists = (0, import_node_fs.existsSync)((0, import_node_path.resolve)("giri.config.js"));
-  const defaultConfigPath = defaultTsConfigExists ? "giri.config.ts" : defaultJsConfigExists ? "giri.config.js" : void 0;
-  if (!defaultConfigPath) {
-    import_prompts.log.error("Config file not found.");
-    (0, import_node_process.exit)(1);
-  }
-  const path = (0, import_node_path.resolve)(defaultConfigPath);
-  if (!(0, import_node_fs.existsSync)(path)) {
-    import_prompts.log.error(`${path} file does not exist`);
-    (0, import_node_process.exit)(1);
-  }
-  const { unregister } = await safeRegister();
-  const required = require(`${path}`);
-  const content = required.default ?? required;
-  unregister();
-  const res = import_value.Value.Check(configSchema, content);
-  if (!res) {
-    for (const error of [...import_value.Value.Errors(configSchema, content)]) {
-      import_prompts.log.error(error.message);
-    }
-    (0, import_node_process.exit)(1);
-  }
-  return content;
-};
+});
 
-// 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("/");
+// src/generator/schema/json-schema.ts
+function createWalkContext(checker, location) {
+  return {
+    checker,
+    location,
+    defs: {},
+    inProgress: /* @__PURE__ */ new Map(),
+    usedDefs: /* @__PURE__ */ new Set(),
+    warnings: []
+  };
 }
-function isRouteSourceFile(fileName) {
-  return /\.(?:[cm]?[jt]s|[jt]sx)$/.test(fileName) && !fileName.endsWith(".d.ts");
+function typeId(type) {
+  return type.id;
 }
-function methodFromFile(fileName) {
-  if (!isRouteSourceFile(fileName)) {
-    return void 0;
-  }
-  const stem = fileName.replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "").toLowerCase();
-  return METHOD_FROM_FILE.get(stem);
+function intrinsicName(type) {
+  return type.intrinsicName;
 }
-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;
+function isDateType(type) {
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  return symbol?.getName() === "Date";
+}
+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;
     }
   }
-  return void 0;
+  return values;
 }
-function physicalRouteSegments(routesDir, routeDir) {
-  const rel = (0, import_node_path2.relative)(routesDir, routeDir);
-  if (!rel) {
-    return [];
+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);
   }
-  return normalizeSlashes(rel).split("/").filter(Boolean);
+  const enumValues = literalValuesOf(members);
+  if (enumValues) {
+    return { enum: enumValues };
+  }
+  return { anyOf: members.map((member) => walkType(member, ctx)) };
 }
-function urlSegment(segment) {
-  if (/^\(.+\)$/.test(segment)) {
-    return {};
+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);
+    }
   }
-  const catchAll = /^\[\.\.\.(.+)\]$/.exec(segment);
-  if (catchAll) {
-    const name = catchAll[1];
-    return {
-      value: `:${name}{.*}`,
-      param: { name, catchAll: true }
-    };
+  const schema = { type: "object" };
+  if (Object.keys(properties).length > 0) {
+    schema.properties = properties;
   }
-  const param = /^\[(.+)\]$/.exec(segment);
-  if (param) {
-    const name = param[1];
-    return {
-      value: `:${name}`,
-      param: { name, catchAll: false }
-    };
+  if (required.length > 0) {
+    schema.required = required;
   }
-  return { value: segment };
-}
-function pathFromSegments(segments) {
-  const pathSegments = [];
-  const params = [];
-  for (const segment of segments) {
-    const converted = urlSegment(segment);
-    if (converted.value) {
-      pathSegments.push(converted.value);
-    }
-    if (converted.param) {
-      params.push(converted.param);
-    }
+  if (indexInfo) {
+    schema.additionalProperties = walkType(indexInfo.type, ctx);
+  } else if (Object.keys(properties).length > 0) {
+    schema.additionalProperties = false;
   }
-  return {
-    path: pathSegments.length > 0 ? `/${pathSegments.join("/")}` : "/",
-    params
-  };
+  return schema;
 }
-async function scanRouteFolders(routesDir) {
-  if (!(0, import_node_fs2.existsSync)(routesDir)) {
-    return [];
+function defName(type) {
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  const name = symbol?.getName();
+  if (name && name !== "__type" && name !== "__object") {
+    return name;
   }
-  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);
-      }
-    }
-  };
-  await walk(routesDir);
-  return folders;
-}
-function routeParamsForDir(routesDir, dir) {
-  return pathFromSegments(physicalRouteSegments(routesDir, dir)).params;
+  return `Anonymous${typeId(type)}`;
 }
-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 walkObject(type, ctx) {
+  const { checker } = ctx;
+  if (isDateType(type)) {
+    return { type: "string", format: "date-time" };
   }
-  return dirs.map(sharedFileIn).filter((file) => Boolean(file));
-}
-async function scanRoutes(routesDir) {
-  if (!(0, import_node_fs2.existsSync)(routesDir)) {
-    return [];
+  if (checker.isArrayType(type)) {
+    const [element] = checker.getTypeArguments(type);
+    return { type: "array", items: element ? walkType(element, ctx) : {} };
   }
-  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)
-    });
+  if (checker.isTupleType(type)) {
+    const elements = checker.getTypeArguments(type);
+    return { type: "array", items: elements.map((element) => walkType(element, ctx)) };
   }
-  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/types.ts
-var inputSchemaBrand = /* @__PURE__ */ Symbol.for("giri.input-schema");
-var bodySchemaBrand = /* @__PURE__ */ Symbol.for("giri.body-schema");
-
-// src/validation.ts
-function isGiriInputSchema(value) {
-  return Boolean(
-    value && typeof value === "object" && value[inputSchemaBrand] === true
-  );
-}
-function isGiriBodySchema(value) {
-  return Boolean(
-    value && typeof value === "object" && value[bodySchemaBrand] === true
-  );
-}
-
-// 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;
+  const id = typeId(type);
+  const existing = ctx.inProgress.get(id);
+  if (existing) {
+    ctx.usedDefs.add(existing);
+    return { $ref: `#/$defs/${existing}` };
   }
-  return value;
+  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 normalizeMiddleware(value, file) {
-  const exported = interopDefault(value);
-  if (exported === void 0) {
-    return [];
+function walkType(type, ctx) {
+  const flags = type.flags;
+  if (flags & (import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown)) {
+    return {};
   }
-  if (typeof exported === "function") {
-    return [exported];
+  if (flags & import_typescript2.default.TypeFlags.Null) {
+    return { type: "null" };
   }
-  if (Array.isArray(exported)) {
-    for (const middleware of exported) {
-      if (typeof middleware !== "function") {
-        throw new Error(`Middleware export in ${file} must contain only functions.`);
-      }
-    }
-    return exported;
+  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
+    return {};
   }
-  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.`
-    );
+  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" };
   }
-}
-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.`
-    );
+  if (type.isStringLiteral()) {
+    return { type: "string", const: type.value };
   }
-}
-function routeInput(routeModule, file) {
-  const input = {};
-  if (routeModule.body !== void 0) {
-    assertBodySchema(routeModule.body, file);
-    input.body = routeModule.body;
+  if (type.isNumberLiteral()) {
+    return { type: "number", const: type.value };
   }
-  if (routeModule.query !== void 0) {
-    assertQuerySchema(routeModule.query, file);
-    input.query = routeModule.query;
+  if (flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+    return { type: "boolean", const: intrinsicName(type) === "true" };
   }
-  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);
-}
-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 (flags & import_typescript2.default.TypeFlags.String) {
+    return { type: "string" };
   }
-  if (request === key) {
-    return "";
+  if (flags & import_typescript2.default.TypeFlags.Number) {
+    return { type: "number" };
   }
-  const prefix = `${key}/`;
-  if (request.startsWith(prefix)) {
-    return request.slice(prefix.length);
+  if (flags & import_typescript2.default.TypeFlags.Boolean) {
+    return { type: "boolean" };
   }
-  return void 0;
+  if (type.isUnion()) {
+    return walkUnion(type, ctx);
+  }
+  if (flags & import_typescript2.default.TypeFlags.Object || type.isIntersection()) {
+    return walkObject(type, ctx);
+  }
+  return {};
 }
-function resolveAliasRequest(request, alias, cwd) {
-  for (const [key, value] of Object.entries(alias ?? {})) {
-    const capture = matchAlias(request, key);
-    if (capture === void 0) {
-      continue;
+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;
     }
-    const [target] = aliasValues(value);
-    if (!target) {
-      continue;
+    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 resolveAliasTarget(cwd, target, capture);
   }
-  return void 0;
+  return found;
 }
-function registerAliasResolver(alias, cwd) {
-  if (!alias || Object.keys(alias).length === 0) {
-    return () => {
-    };
+function collectReturnExpressions(fn) {
+  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
+    return [fn.body];
   }
-  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 (!fn.body) {
+    return [];
   }
-  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);
+  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 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")
-  };
+function propertyType(checker, type, name, location) {
+  const symbol = checker.getPropertyOfType(type, name);
+  return symbol ? checker.getTypeOfSymbolAtLocation(symbol, location) : void 0;
 }
-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 };
-}
-
-// 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 isTypedResponse(checker, type) {
+  return Boolean(
+    checker.getPropertyOfType(type, "data") && checker.getPropertyOfType(type, "status") && checker.getPropertyOfType(type, "format")
+  );
 }
-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}`;
+function readFromCall(checker, expression) {
+  if (!import_typescript3.default.isCallExpression(expression) || !import_typescript3.default.isPropertyAccessExpression(expression.expression)) {
+    return void 0;
   }
-  return path;
-}
-function relativeConfigPath(fromDir, toPath) {
-  let path = slash((0, import_node_path4.relative)(fromDir, toPath));
-  if (!path.startsWith(".")) {
-    path = `./${path}`;
+  const method = expression.expression.name.text;
+  if (method !== "json" && method !== "text") {
+    return void 0;
   }
-  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}`;
+  if (!isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
+    return void 0;
   }
-  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}`);
+  const [dataArg, statusArg] = expression.arguments;
+  if (!dataArg) {
+    return void 0;
   }
-}
-var writeCache = /* @__PURE__ */ new Map();
-async function writeGenerated(path, content) {
-  if (writeCache.get(path) === content && (0, import_node_fs3.existsSync)(path)) {
-    return;
+  let status = 200;
+  if (statusArg) {
+    const statusType = checker.getTypeAtLocation(statusArg);
+    status = statusType.isNumberLiteral() ? statusType.value : "default";
   }
-  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)}
-`);
+  return { status, format: method === "text" ? "text" : "json", data: checker.getTypeAtLocation(dataArg) };
 }
-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);
-    }
+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 status = statusType.isNumberLiteral() ? statusType.value : "default";
+  const format = formatType.isStringLiteral() && formatType.value === "text" ? "text" : "json";
+  return { status, format, data: dataType };
 }
-
-// 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 constituents(type) {
+  return type.isUnion() ? type.types : [type];
 }
-function moduleSpecifier2(fromDir, target) {
-  let path = slash((0, import_node_path5.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
-  if (!path.startsWith(".")) {
-    path = `./${path}`;
+function extractRouteResponses(program, file) {
+  const result = { responses: [], opaque: false, warnings: [], $defs: {} };
+  const source = program.getSourceFile(file);
+  if (!source) {
+    return result;
   }
-  return path;
-}
-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 checker = program.getTypeChecker();
+  const fn = findHandleFunction(source);
+  if (!fn) {
+    return result;
   }
-  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);
-      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 } : {}
-      };
-    })
+  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);
   };
-  await writeJson((0, import_node_path6.join)(paths.outDir, "manifest.json"), manifest);
-}
-
-// 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);
+  for (const expression of collectReturnExpressions(fn)) {
+    const fromCall = readFromCall(checker, expression);
+    if (fromCall) {
+      record(fromCall);
+      continue;
+    }
+    let matched = false;
+    for (const member of constituents(checker.getTypeAtLocation(expression))) {
+      const hit = readFromType(checker, member, expression);
+      if (hit) {
+        record(hit);
+        matched = true;
       }
     }
-    return out;
-  }
-  return value;
-}
-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" } };
+    if (!matched) {
+      result.opaque = true;
+    }
   }
-  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) } }
-    };
+  for (const [status, { format, schemas }] of byStatus) {
+    const schema = schemas.length === 1 ? schemas[0] : { anyOf: schemas };
+    result.responses.push({ status, format, schema });
   }
-  return out;
+  result.responses.sort((a, b) => Number(a.status) - Number(b.status));
+  result.warnings = ctx.warnings;
+  result.$defs = ctx.defs;
+  return result;
 }
-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" } });
+var import_typescript3;
+var init_responses = __esm({
+  "src/generator/schema/responses.ts"() {
+    "use strict";
+    import_typescript3 = __toESM(require("typescript"));
+    init_json_schema();
   }
-  return params;
-}
-function queryParameters(query) {
-  if (!query || query.type !== "object" || typeof query.properties !== "object") {
-    return [];
+});
+
+// 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();
   }
-  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 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 {
+});
+
+// src/cli.ts
+var import_node_child_process = require("child_process");
+var import_node_fs9 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_node_path15 = require("path");
+var prompts = __toESM(require("@clack/prompts"));
+
+// 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);
   }
-  return { title: "giri API", version: "0.0.0" };
-}
-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 };
+};
+var safeRegister = async () => {
+  const { register } = await import("esbuild-register/dist/node");
+  let res;
+  try {
+    res = register({
+      format: "cjs",
+      loader: "ts"
+    });
+  } catch {
+    res = {
+      unregister: () => {
       }
+    };
+  }
+  await assertES5(res.unregister);
+  return res;
+};
+var findConfigPath = (cwd = (0, import_node_path.resolve)()) => {
+  for (const name of ["giri.config.ts", "giri.config.js"]) {
+    const path = (0, import_node_path.resolve)(cwd, name);
+    if ((0, import_node_fs.existsSync)(path)) {
+      return path;
     }
-    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;
   }
-  const document = {
-    openapi: "3.1.0",
-    info: readProjectInfo(paths.cwd),
-    paths: documentPaths
+  return void 0;
+};
+var load = async (opts = {}) => {
+  const fail = (message) => {
+    if (opts.throwOnError) {
+      throw new Error(message);
+    }
+    import_prompts.log.error(message);
+    (0, import_node_process.exit)(1);
   };
-  const components = {};
-  if (Object.keys(schemas).length > 0) {
-    components.schemas = schemas;
+  const path = findConfigPath();
+  if (!path) {
+    fail("Config file not found.");
   }
-  if (Object.keys(securitySchemes).length > 0) {
-    components.securitySchemes = securitySchemes;
+  const { unregister } = await safeRegister();
+  let content;
+  try {
+    const required = require(`${path}`);
+    content = required.default ?? required;
+  } finally {
   }
-  if (Object.keys(components).length > 0) {
-    document.components = components;
+  unregister();
+  const res = import_value.Value.Check(configSchema, content);
+  if (!res) {
+    const messages = [...import_value.Value.Errors(configSchema, content)].map((error) => error.message);
+    if (!opts.throwOnError) {
+      for (const message of messages) {
+        import_prompts.log.error(message);
+      }
+    }
+    fail(messages.join("\n"));
   }
-  return document;
+  return content;
+};
+
+// 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("/");
 }
-async function writeOpenApi(paths, routes, data = {}) {
-  await writeJson((0, import_node_path7.join)(paths.outDir, "openapi.json"), buildOpenApiDocument(paths, routes, data));
+function isRouteSourceFile(fileName) {
+  return /\.(?:[cm]?[jt]s|[jt]sx)$/.test(fileName) && !fileName.endsWith(".d.ts");
 }
-
-// src/generator/param-types.ts
-var import_node_path8 = require("path");
-function paramsType(params) {
-  if (params.length === 0) {
-    return "{}";
+function methodFromFile(fileName) {
+  if (!isRouteSourceFile(fileName)) {
+    return void 0;
   }
-  const unique = /* @__PURE__ */ new Map();
-  for (const param of params) {
-    unique.set(param.name, param);
+  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;
+    }
   }
-  const fields = [...unique.values()].map((param) => `  ${JSON.stringify(param.name)}: string;`).join("\n");
-  return `{
-${fields}
-}`;
+  return void 0;
 }
-function varsType(typesDir, sharedFiles) {
-  if (sharedFiles.length === 0) {
-    return "{}";
+function physicalRouteSegments(routesDir, routeDir) {
+  const rel = (0, import_node_path2.relative)(routesDir, routeDir);
+  if (!rel) {
+    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    & ");
+  return normalizeSlashes(rel).split("/").filter(Boolean);
 }
-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}>;`;
-  });
+function urlSegment(segment) {
+  if (/^\(.+\)$/.test(segment)) {
+    return {};
+  }
+  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 };
 }
-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));
+function pathFromSegments(segments) {
+  const pathSegments = [];
+  const params = [];
+  for (const segment of segments) {
+    const converted = urlSegment(segment);
+    if (converted.value) {
+      pathSegments.push(converted.value);
     }
-    lines.push("");
-    await writeGenerated(file, lines.join("\n"));
+    if (converted.param) {
+      params.push(converted.param);
+    }
+  }
+  return {
+    path: pathSegments.length > 0 ? `/${pathSegments.join("/")}` : "/",
+    params
+  };
+}
+async function scanRouteFolders(routesDir) {
+  if (!(0, import_node_fs2.existsSync)(routesDir)) {
+    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);
+      }
+    }
+  };
+  await walk(routesDir);
+  return folders;
 }
-
-// src/generator/inputs.ts
-function sanitize(schema) {
-  const { $schema, ...rest } = schema;
-  void $schema;
-  return rest;
+function routeParamsForDir(routesDir, dir) {
+  return pathFromSegments(physicalRouteSegments(routesDir, dir)).params;
 }
-function inputToJsonSchema(schema) {
-  if (!isGiriInputSchema(schema)) {
-    return 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);
   }
-  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/types.ts
+var inputSchemaBrand = /* @__PURE__ */ Symbol.for("giri.input-schema");
+var bodySchemaBrand = /* @__PURE__ */ Symbol.for("giri.body-schema");
+
+// src/validation.ts
+function isGiriInputSchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[inputSchemaBrand] === true
+  );
+}
+function isGiriBodySchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[bodySchemaBrand] === true
+  );
+}
+
+// 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;
-}
-
-// 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;`
-    );
-  }
-  lines.push("}", "");
-  await writeGenerated(file, lines.join("\n"));
+  return { app, routes, paths };
 }
 
-// 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 };
-    }
-  }
-  return import_typescript.default.createProgram(routeFiles, options);
-}
+// src/generator/sync.ts
+var import_node_fs6 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path11 = require("path");
 
-// src/generator/schema/responses.ts
-var import_typescript3 = __toESM(require("typescript"));
+// src/generator/app-types.ts
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
 
-// 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: []
-  };
-}
-function typeId(type) {
-  return type.id;
-}
-function intrinsicName(type) {
-  return type.intrinsicName;
-}
-function isDateType(type) {
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  return symbol?.getName() === "Date";
+// 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 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;
-    }
+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 values;
+  return path;
 }
-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 relativeConfigPath(fromDir, toPath) {
+  let path = slash((0, import_node_path4.relative)(fromDir, toPath));
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
   }
-  const enumValues = literalValuesOf(members);
-  if (enumValues) {
-    return { enum: enumValues };
+  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 { anyOf: members.map((member) => walkType(member, ctx)) };
+  return path;
 }
-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 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}`);
   }
-  const schema = { type: "object" };
-  if (Object.keys(properties).length > 0) {
-    schema.properties = properties;
+}
+var writeCache = /* @__PURE__ */ new Map();
+async function writeGenerated(path, content) {
+  if (writeCache.get(path) === content && (0, import_node_fs3.existsSync)(path)) {
+    return;
   }
-  if (required.length > 0) {
-    schema.required = required;
+  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;
   }
-  if (indexInfo) {
-    schema.additionalProperties = walkType(indexInfo.type, ctx);
-  } else if (Object.keys(properties).length > 0) {
-    schema.additionalProperties = false;
+  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 schema;
 }
-function defName(type) {
-  const symbol = type.getSymbol() ?? type.aliasSymbol;
-  const name = symbol?.getName();
-  if (name && name !== "__type" && name !== "__object") {
-    return name;
+
+// 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 `Anonymous${typeId(type)}`;
+  return void 0;
 }
-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) : {} };
+function moduleSpecifier2(fromDir, target) {
+  let path = slash((0, import_node_path5.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
   }
-  if (checker.isTupleType(type)) {
-    const elements = checker.getTypeArguments(type);
-    return { type: "array", items: elements.map((element) => walkType(element, ctx)) };
+  return path;
+}
+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 id = typeId(type);
-  const existing = ctx.inProgress.get(id);
-  if (existing) {
-    ctx.usedDefs.add(existing);
-    return { $ref: `#/$defs/${existing}` };
+  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);
+      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);
+}
+
+// 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);
   }
-  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}` };
+  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 schema;
+  return value;
 }
-function walkType(type, ctx) {
-  const flags = type.flags;
-  if (flags & (import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown)) {
-    return {};
+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" } };
   }
-  if (flags & import_typescript2.default.TypeFlags.Null) {
-    return { type: "null" };
+  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) } }
+    };
   }
-  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
-    return {};
+  return out;
+}
+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" } });
   }
-  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" };
+  return params;
+}
+function queryParameters(query) {
+  if (!query || query.type !== "object" || typeof query.properties !== "object") {
+    return [];
   }
-  if (type.isStringLiteral()) {
-    return { type: "string", const: type.value };
+  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 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 {
+    }
   }
-  if (type.isNumberLiteral()) {
-    return { type: "number", const: type.value };
+  return { title: "giri API", version: "0.0.0" };
+}
+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.BooleanLiteral) {
-    return { type: "boolean", const: intrinsicName(type) === "true" };
+  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.String) {
-    return { type: "string" };
+  if (Object.keys(securitySchemes).length > 0) {
+    components.securitySchemes = securitySchemes;
   }
-  if (flags & import_typescript2.default.TypeFlags.Number) {
-    return { type: "number" };
+  if (Object.keys(components).length > 0) {
+    document.components = components;
   }
-  if (flags & import_typescript2.default.TypeFlags.Boolean) {
-    return { type: "boolean" };
+  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 (type.isUnion()) {
-    return walkUnion(type, ctx);
+  const unique = /* @__PURE__ */ new Map();
+  for (const param of params) {
+    unique.set(param.name, param);
   }
-  if (flags & import_typescript2.default.TypeFlags.Object || type.isIntersection()) {
-    return walkObject(type, ctx);
+  const fields = [...unique.values()].map((param) => `  ${JSON.stringify(param.name)}: string;`).join("\n");
+  return `{
+${fields}
+}`;
+}
+function varsType(typesDir, sharedFiles) {
+  if (sharedFiles.length === 0) {
+    return "{}";
   }
-  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    & ");
 }
-
-// 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;
-        }
-      }
+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"));
   }
-  return found;
 }
-function collectReturnExpressions(fn) {
-  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
-    return [fn.body];
+
+// 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 (!fn.body) {
-    return [];
+  return sanitize(schema.toJsonSchema());
+}
+function bodyToJsonSchemas(value) {
+  if (!isGiriBodySchema(value)) {
+    return void 0;
   }
-  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);
+  const out = {};
+  for (const [contentType, schema] of Object.entries(value.contents)) {
+    const json = inputToJsonSchema(schema);
+    if (json) {
+      out[contentType] = json;
     }
-    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;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
 }
-function isTypedResponse(checker, type) {
-  return Boolean(
-    checker.getPropertyOfType(type, "data") && checker.getPropertyOfType(type, "status") && checker.getPropertyOfType(type, "format")
-  );
+
+// src/generator/route-meta.ts
+function loadModule2(file) {
+  const resolved = require.resolve(file);
+  delete require.cache[resolved];
+  return require(resolved);
 }
-function readFromCall(checker, expression) {
-  if (!import_typescript3.default.isCallExpression(expression) || !import_typescript3.default.isPropertyAccessExpression(expression.expression)) {
-    return void 0;
+function interopDefault2(value) {
+  if (value && typeof value === "object" && "default" in value) {
+    return value.default;
   }
-  const method = expression.expression.name.text;
-  if (method !== "json" && method !== "text") {
-    return void 0;
+  return value;
+}
+function middlewareFunctions(value) {
+  const exported = interopDefault2(value);
+  if (typeof exported === "function") {
+    return [exported];
   }
-  if (!isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
-    return void 0;
+  if (Array.isArray(exported)) {
+    return exported.filter((fn) => typeof fn === "function");
   }
-  const [dataArg, statusArg] = expression.arguments;
-  if (!dataArg) {
-    return void 0;
+  return [];
+}
+function readInput(routeModule) {
+  const input = {};
+  const body = bodyToJsonSchemas(routeModule.body);
+  const query = inputToJsonSchema(routeModule.query);
+  if (body) {
+    input.body = body;
   }
-  let status = 200;
-  if (statusArg) {
-    const statusType = checker.getTypeAtLocation(statusArg);
-    status = statusType.isNumberLiteral() ? statusType.value : "default";
+  if (query) {
+    input.query = query;
   }
-  return { status, format: method === "text" ? "text" : "json", data: checker.getTypeAtLocation(dataArg) };
+  return input.body || input.query ? input : 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 hiddenFrom(value) {
+  if (value === false) {
+    return true;
   }
-  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];
+  if (value === true) {
+    return false;
+  }
+  if (value && typeof value === "object" && "hidden" in value) {
+    return Boolean(value.hidden);
+  }
+  return void 0;
 }
-function extractRouteResponses(program, file) {
-  const result = { responses: [], opaque: false, warnings: [], $defs: {} };
-  const source = program.getSourceFile(file);
-  if (!source) {
-    return result;
+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 checker = program.getTypeChecker();
-  const fn = findHandleFunction(source);
-  if (!fn) {
-    return result;
+  const verb = hiddenFrom(routeModule.openapi);
+  return verb ?? hidden;
+}
+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
@@ -1383,20 +1432,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}).`);
@@ -1438,7 +1488,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);
@@ -1525,6 +1575,14 @@ var purgeProjectModules = (cwd) => {
     }
   }
 };
+var purgeGeneratedModules = (outDir) => {
+  const root = (0, import_node_path12.resolve)(outDir) + import_node_path12.sep;
+  for (const id of Object.keys(require.cache)) {
+    if ((0, import_node_path12.resolve)(id).startsWith(root)) {
+      delete require.cache[id];
+    }
+  }
+};
 
 // src/generator/watch.ts
 function createWatchUpdater(config, initial) {
@@ -1539,14 +1597,16 @@ function createWatchUpdater(config, initial) {
     data.inputsByFile = result.data.inputsByFile;
     data.securityByFile = result.data.securityByFile;
     data.hiddenFiles = result.data.hiddenFiles;
+    purgeGeneratedModules(paths.outDir);
     return "full";
   };
   const reextractRoute = async (route) => {
     const key = route.file;
     try {
+      const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
       const appTypes = (0, import_node_path13.join)(paths.outDir, "types", "app.d.ts");
-      const program = createSchemaProgram(paths, (0, import_node_fs7.existsSync)(appTypes) ? [key, appTypes] : [key]);
-      data.responsesByFile.set(key, extractRouteResponses(program, key));
+      const program = createSchemaProgram2(paths, (0, import_node_fs7.existsSync)(appTypes) ? [key, appTypes] : [key]);
+      data.responsesByFile.set(key, extractRouteResponses2(program, key));
     } catch {
     }
     try {
@@ -1592,6 +1652,7 @@ function createWatchUpdater(config, initial) {
       }
       await writeManifest(paths, routes, data);
       await writeOpenApi(paths, routes, data);
+      purgeGeneratedModules(paths.outDir);
       return "incremental";
     }
   };
@@ -1810,6 +1871,23 @@ async function ensureTsConfig(cwd) {
 `
   );
 }
+async function missingDeps(cwd, candidates) {
+  let pkg = {};
+  try {
+    pkg = JSON.parse(await (0, import_promises4.readFile)((0, import_node_path15.join)(cwd, "package.json"), "utf8"));
+  } catch {
+  }
+  const present = /* @__PURE__ */ new Set();
+  for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+    const map = pkg[field];
+    if (map && typeof map === "object") {
+      for (const name of Object.keys(map)) {
+        present.add(name);
+      }
+    }
+  }
+  return candidates.filter((name) => !present.has(name));
+}
 function detectPackageManager() {
   const ua = process.env.npm_config_user_agent ?? "";
   if (ua.startsWith("yarn")) return "yarn";
@@ -1865,6 +1943,11 @@ async function selectAdapter(interactive) {
   return ADAPTERS.find((adapter) => adapter.value === picked) ?? null;
 }
 async function initProject(cwd, flags) {
+  if (!(0, import_node_fs9.existsSync)((0, import_node_path15.join)(cwd, "package.json"))) {
+    throw new Error(
+      "No package.json found. Run `giri init` inside an existing project - set one up first (e.g. `npm init -y` and install typescript), then re-run."
+    );
+  }
   const interactive = Boolean(process.stdout.isTTY) && !flags.yes;
   prompts.intro("giri init");
   let adapter;
@@ -1882,7 +1965,7 @@ async function initProject(cwd, flags) {
     }
   }
   if (!adapter.available) {
-    prompts.cancel(`The ${adapter.label} adapter isn't available yet \u2014 only Hono ships today.`);
+    prompts.cancel(`The ${adapter.label} adapter isn't available yet - only Hono ships today.`);
     return;
   }
   const configPath = (0, import_node_path15.join)(cwd, "giri.config.ts");
@@ -1906,6 +1989,16 @@ async function initProject(cwd, flags) {
   await ensureTsConfig(cwd);
   prompts.log.success(`scaffolded a ${adapter.label} project`);
   const pm = flags.packageManager ?? detectPackageManager();
+  const deps = await missingDeps(cwd, ["@boon4681/giri", ...adapter.deps, "zod"]);
+  const devDeps = await missingDeps(cwd, ["typescript", "@types/node"]);
+  if (deps.length === 0 && devDeps.length === 0) {
+    prompts.outro("All dependencies already present. Run `giri serve` to start the dev server.");
+    return;
+  }
+  const planLines = [
+    ...deps.length ? [`  ${pm} ${installArgs(pm, deps, false).join(" ")}`] : [],
+    ...devDeps.length ? [`  ${pm} ${installArgs(pm, devDeps, true).join(" ")}`] : []
+  ];
   let install = flags.install;
   if (install === void 0) {
     if (!interactive) {
@@ -1913,34 +2006,34 @@ async function initProject(cwd, flags) {
     } else {
       const answer = await prompts.confirm({ message: `Install dependencies with ${pm}?` });
       if (prompts.isCancel(answer)) {
-        prompts.cancel("Cancelled \u2014 files written, skipped install.");
+        prompts.cancel("Cancelled - files written, skipped install.");
         return;
       }
       install = answer;
     }
   }
-  const deps = ["@boon4681/giri", ...adapter.deps, "zod"];
-  const devDeps = ["typescript", "@types/node"];
   if (install) {
     try {
-      prompts.log.step(`Installing ${deps.join(", ")}`);
-      await runCommand(pm, installArgs(pm, deps, false), cwd);
-      prompts.log.step(`Installing dev deps ${devDeps.join(", ")}`);
-      await runCommand(pm, installArgs(pm, devDeps, true), cwd);
+      if (deps.length) {
+        prompts.log.step(`Installing ${deps.join(", ")}`);
+        await runCommand(pm, installArgs(pm, deps, false), cwd);
+      }
+      if (devDeps.length) {
+        prompts.log.step(`Installing dev deps ${devDeps.join(", ")}`);
+        await runCommand(pm, installArgs(pm, devDeps, true), cwd);
+      }
     } catch (error) {
       prompts.log.error(error instanceof Error ? error.message : String(error));
-      prompts.outro(`Install failed \u2014 run \`${pm} ${installArgs(pm, deps, false).join(" ")}\` yourself, then \`giri serve\`.`);
+      prompts.outro(`Install failed - run these yourself, then \`giri serve\`:
+${planLines.join("\n")}`);
       return;
     }
     prompts.outro("Ready. Run `giri serve` to start the dev server.");
     return;
   }
-  prompts.outro(
-    `Next:
-  ${pm} ${installArgs(pm, deps, false).join(" ")}
-  ${pm} ${installArgs(pm, devDeps, true).join(" ")}
-  giri serve`
-  );
+  prompts.outro(`Next:
+${planLines.join("\n")}
+  giri serve`);
 }
 function displayHost(address) {
   if (!address || address === "::" || address === "0.0.0.0") {
@@ -1949,69 +2042,120 @@ function displayHost(address) {
   return address.includes(":") ? `[${address}]` : address;
 }
 async function serveProject(config, flags) {
-  const initial = await syncProject(config);
-  log2.success(
-    `synced ${initial.routes.length} route${initial.routes.length === 1 ? "" : "s"} ${muted(`at ${initial.paths.outDir}`)}`,
-    "sync"
-  );
-  const lifecycle = await loadLifecycle();
-  const services = await runInit(lifecycle);
-  let current = await buildGiriApp(config, { services });
-  const port = flags.port ?? config.server?.port ?? 3e3;
-  const hostname = flags.hostname ?? config.server?.hostname;
-  if (flags.watch) {
-    const srcDir = (0, import_node_path15.resolve)(current.paths.routesDir, "..");
-    if ((0, import_node_fs9.existsSync)(srcDir)) {
-      let timer;
-      let syncing = false;
-      const changed = /* @__PURE__ */ new Set();
-      const { watch } = await import("fs");
-      const updater = createWatchUpdater(config, initial);
-      const hmrCount = /* @__PURE__ */ new Map();
-      const bump = (key) => {
-        const next = (hmrCount.get(key) ?? 0) + 1;
-        hmrCount.set(key, next);
-        return next;
-      };
-      const flush = async () => {
-        if (syncing) {
-          return;
-        }
-        syncing = true;
-        try {
-          while (changed.size > 0) {
-            const batch = [...changed];
-            changed.clear();
-            for (const name of batch) {
-              const outcome = await updater.apply(name || null);
-              const rel = name ? `src/${name.replace(/\\/g, "/")}` : "src";
-              log2.change(outcome === "full" ? "sync" : "update", rel, bump(rel));
+  const { watch } = await import("fs");
+  let stop;
+  const boot = async (cfg) => {
+    const initial = await syncProject(cfg);
+    log2.success(
+      `synced ${initial.routes.length} route${initial.routes.length === 1 ? "" : "s"} ${muted(`at ${initial.paths.outDir}`)}`,
+      "sync"
+    );
+    const lifecycle = await loadLifecycle();
+    const services = await runInit(lifecycle);
+    let current = await buildGiriApp(cfg, { services });
+    const port = flags.port ?? cfg.server?.port ?? 3e3;
+    const hostname = flags.hostname ?? cfg.server?.hostname;
+    const closers = [];
+    if (flags.watch) {
+      const srcDir = (0, import_node_path15.resolve)(current.paths.routesDir, "..");
+      if ((0, import_node_fs9.existsSync)(srcDir)) {
+        let timer;
+        let syncing = false;
+        const changed = /* @__PURE__ */ new Set();
+        const updater = createWatchUpdater(cfg, initial);
+        const hmrCount = /* @__PURE__ */ new Map();
+        const bump = (key) => {
+          const next = (hmrCount.get(key) ?? 0) + 1;
+          hmrCount.set(key, next);
+          return next;
+        };
+        const flush = async () => {
+          if (syncing) {
+            return;
+          }
+          syncing = true;
+          try {
+            while (changed.size > 0) {
+              const batch = [...changed];
+              changed.clear();
+              for (const name of batch) {
+                const outcome = await updater.apply(name || null);
+                const rel = name ? `src/${name.replace(/\\/g, "/")}` : "src";
+                log2.change(outcome === "full" ? "sync" : "update", rel, bump(rel));
+              }
+              current = await buildGiriApp(cfg, { services });
             }
-            current = await buildGiriApp(config, { services });
+          } catch (error) {
+            log2.error(error instanceof Error ? error.message : String(error), "watch");
+          } finally {
+            syncing = false;
           }
-        } catch (error) {
-          log2.error(error instanceof Error ? error.message : String(error), "watch");
-        } finally {
-          syncing = false;
-        }
-        if (changed.size > 0) {
-          void flush();
-        }
-      };
-      watch(srcDir, { recursive: true }, (_event, filename) => {
-        changed.add(filename ? filename.toString() : "");
-        clearTimeout(timer);
-        timer = setTimeout(() => void flush(), 150);
-      });
+          if (changed.size > 0) {
+            void flush();
+          }
+        };
+        const watcher = watch(srcDir, { recursive: true }, (_event, filename) => {
+          changed.add(filename ? filename.toString() : "");
+          clearTimeout(timer);
+          timer = setTimeout(() => void flush(), 150);
+        });
+        closers.push(() => {
+          clearTimeout(timer);
+          watcher.close();
+        });
+      }
     }
+    const handler = (request) => cfg.adapter.fetch(current.app, request);
+    const server = cfg.adapter.serve(handler, { port, hostname }, (info) => {
+      log2.ready(`http://${displayHost(info.address)}:${info.port}`);
+    });
+    stop = async () => {
+      for (const close of closers) {
+        await close();
+      }
+      try {
+        await server.close();
+      } catch {
+      }
+      if (lifecycle.teardown) {
+        await lifecycle.teardown(services);
+      }
+    };
+  };
+  await boot(config);
+  const configPath = flags.watch ? findConfigPath((0, import_node_path15.resolve)(process.cwd())) : void 0;
+  if (configPath) {
+    let timer;
+    let restarting = false;
+    const configName = (0, import_node_path15.basename)(configPath);
+    const restart = async () => {
+      if (restarting) {
+        return;
+      }
+      restarting = true;
+      try {
+        log2.info(`${color.green("restart")} ${configName} changed`, "config");
+        delete require.cache[configPath];
+        const next = await load({ throwOnError: true });
+        await stop?.();
+        await boot(next);
+      } catch (error) {
+        log2.error(error instanceof Error ? error.message : String(error), "config");
+        log2.info("kept the previous server running \u2014 fix the config and save again", "config");
+      } finally {
+        restarting = false;
+      }
+    };
+    watch((0, import_node_path15.dirname)(configPath), { recursive: false }, (_event, filename) => {
+      if (filename && (0, import_node_path15.basename)(filename.toString()) === configName) {
+        clearTimeout(timer);
+        timer = setTimeout(() => void restart(), 150);
+      }
+    });
   }
-  const handler = (request) => config.adapter.fetch(current.app, request);
-  const server = config.adapter.serve(handler, { port, hostname }, (info) => {
-    log2.ready(`http://${displayHost(info.address)}:${info.port}`);
-  });
-  registerShutdown(server, lifecycle, services);
+  registerShutdown(() => stop?.());
 }
-function registerShutdown(server, lifecycle, services) {
+function registerShutdown(cleanup) {
   let shuttingDown = false;
   const shutdown = async () => {
     if (shuttingDown) {
@@ -2019,10 +2163,7 @@ function registerShutdown(server, lifecycle, services) {
     }
     shuttingDown = true;
     try {
-      await server.close();
-      if (lifecycle.teardown) {
-        await lifecycle.teardown(services);
-      }
+      await cleanup();
     } catch (error) {
       log2.error(error instanceof Error ? error.message : String(error));
       process.exitCode = 1;