@boon4681/giri 0.0.1

package/dist/cli.js

@@ -0,0 +1,2070 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loader/_es5.ts
+var es5_exports = {};
+__export(es5_exports, {
+  default: () => es5_default
+});
+var _, es5_default;
+var init_es5 = __esm({
+  "src/loader/_es5.ts"() {
+    "use strict";
+    _ = "";
+    es5_default = _;
+  }
+});
+
+// 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);
+  }
+};
+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 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("/");
+}
+function isRouteSourceFile(fileName) {
+  return /\.(?:[cm]?[jt]s|[jt]sx)$/.test(fileName) && !fileName.endsWith(".d.ts");
+}
+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 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;
+    }
+  }
+  return void 0;
+}
+function physicalRouteSegments(routesDir, routeDir) {
+  const rel = (0, import_node_path2.relative)(routesDir, routeDir);
+  if (!rel) {
+    return [];
+  }
+  return normalizeSlashes(rel).split("/").filter(Boolean);
+}
+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 };
+}
+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);
+    }
+  }
+  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;
+}
+function routeParamsForDir(routesDir, dir) {
+  return pathFromSegments(physicalRouteSegments(routesDir, dir)).params;
+}
+function sharedFilesForDir(routesDir, dir) {
+  const segments = physicalRouteSegments(routesDir, dir);
+  const dirs = [routesDir];
+  let current = routesDir;
+  for (const segment of segments) {
+    current = (0, import_node_path2.join)(current, segment);
+    dirs.push(current);
+  }
+  return dirs.map(sharedFileIn).filter((file) => Boolean(file));
+}
+async function scanRoutes(routesDir) {
+  if (!(0, import_node_fs2.existsSync)(routesDir)) {
+    return [];
+  }
+  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 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;
+  }
+  return value;
+}
+function normalizeMiddleware(value, file) {
+  const exported = interopDefault(value);
+  if (exported === void 0) {
+    return [];
+  }
+  if (typeof exported === "function") {
+    return [exported];
+  }
+  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;
+  }
+  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.`
+    );
+  }
+}
+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 = {};
+  if (routeModule.body !== void 0) {
+    assertBodySchema(routeModule.body, file);
+    input.body = routeModule.body;
+  }
+  if (routeModule.query !== void 0) {
+    assertQuerySchema(routeModule.query, file);
+    input.query = routeModule.query;
+  }
+  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 (request === key) {
+    return "";
+  }
+  const prefix = `${key}/`;
+  if (request.startsWith(prefix)) {
+    return request.slice(prefix.length);
+  }
+  return void 0;
+}
+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);
+  }
+  return void 0;
+}
+function registerAliasResolver(alias, cwd) {
+  if (!alias || Object.keys(alias).length === 0) {
+    return () => {
+    };
+  }
+  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;
+  }
+  giriResolverInstalled = true;
+  const moduleWithResolver = import_node_module.default;
+  const originalResolveFilename = moduleWithResolver._resolveFilename;
+  moduleWithResolver._resolveFilename = function resolveWithGiriInternalAlias(request, parent, isMain, options) {
+    const mapped = typeof request === "string" && request.startsWith(GIRI_ALIAS_PREFIX) && giriOutDir ? (0, import_node_path3.join)(giriOutDir, request.slice(GIRI_ALIAS_PREFIX.length)) : request;
+    return originalResolveFilename.call(this, mapped, parent, isMain, options);
+  };
+}
+function resolveGiriPaths(config, cwd = process.cwd()) {
+  return {
+    cwd: (0, import_node_path3.resolve)(cwd),
+    routesDir: (0, import_node_path3.resolve)(cwd, "src/routes"),
+    outDir: (0, import_node_path3.resolve)(cwd, config.outDir ?? ".giri")
+  };
+}
+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 importPath(fromFile, toFile) {
+  let path = slash((0, import_node_path4.relative)((0, import_node_path4.dirname)(fromFile), toFile)).replace(/\.d\.ts$/, "");
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  return path;
+}
+function relativeConfigPath(fromDir, toPath) {
+  let path = slash((0, import_node_path4.relative)(fromDir, toPath));
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  return path;
+}
+function moduleSpecifier(fromDir, target) {
+  let path = slash((0, import_node_path4.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  return path;
+}
+function typeFilePath(paths, routeDir) {
+  const sourceDir = (0, import_node_path4.relative)(paths.cwd, routeDir);
+  return (0, import_node_path4.join)(paths.outDir, "types", sourceDir, "$types.d.ts");
+}
+function assertSafeOutDir(paths) {
+  const rel = (0, import_node_path4.relative)(paths.cwd, paths.outDir);
+  if (!rel || rel.startsWith("..") || rel.includes(`..${import_node_path4.sep}`)) {
+    throw new Error(`Refusing to sync outside the project root: ${paths.outDir}`);
+  }
+}
+var writeCache = /* @__PURE__ */ new Map();
+async function writeGenerated(path, content) {
+  if (writeCache.get(path) === content && (0, import_node_fs3.existsSync)(path)) {
+    return;
+  }
+  await (0, import_promises2.mkdir)((0, import_node_path4.dirname)(path), { recursive: true });
+  await (0, import_promises2.writeFile)(path, content);
+  writeCache.set(path, content);
+}
+async function writeJson(path, value) {
+  await writeGenerated(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+async function pruneDir(dir, keep) {
+  let entries;
+  try {
+    entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = (0, import_node_path4.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      await pruneDir(full, keep);
+      await (0, import_promises2.rmdir)(full).catch(() => {
+      });
+    } else if (!keep.has(full)) {
+      await (0, import_promises2.rm)(full, { force: true });
+      writeCache.delete(full);
+    }
+  }
+}
+
+// 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 moduleSpecifier2(fromDir, target) {
+  let path = slash((0, import_node_path5.relative)(fromDir, target)).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+  if (!path.startsWith(".")) {
+    path = `./${path}`;
+  }
+  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 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);
+  }
+  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 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" } };
+  }
+  const out = {};
+  for (const response of responses) {
+    const key = response.status === "default" ? "default" : String(response.status);
+    const description = typeof response.status === "number" && REASON[response.status] || "Response";
+    out[key] = {
+      description,
+      content: { [mediaTypeFor(response.format)]: { schema: rewriteRefs(response.schema) } }
+    };
+  }
+  return 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" } });
+  }
+  return params;
+}
+function queryParameters(query) {
+  if (!query || query.type !== "object" || typeof query.properties !== "object") {
+    return [];
+  }
+  const properties = query.properties;
+  const required = Array.isArray(query.required) ? query.required : [];
+  return Object.entries(properties).map(([name, schema]) => ({
+    name,
+    in: "query",
+    required: required.includes(name),
+    schema: rewriteRefs(schema)
+  }));
+}
+function readProjectInfo(cwd) {
+  const file = (0, import_node_path7.join)(cwd, "package.json");
+  if ((0, import_node_fs5.existsSync)(file)) {
+    try {
+      const pkg = JSON.parse((0, import_node_fs5.readFileSync)(file, "utf8"));
+      return { title: pkg.name ?? "giri API", version: pkg.version ?? "0.0.0" };
+    } catch {
+    }
+  }
+  return { 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;
+  }
+  const document = {
+    openapi: "3.1.0",
+    info: readProjectInfo(paths.cwd),
+    paths: documentPaths
+  };
+  const components = {};
+  if (Object.keys(schemas).length > 0) {
+    components.schemas = schemas;
+  }
+  if (Object.keys(securitySchemes).length > 0) {
+    components.securitySchemes = securitySchemes;
+  }
+  if (Object.keys(components).length > 0) {
+    document.components = components;
+  }
+  return document;
+}
+async function writeOpenApi(paths, routes, data = {}) {
+  await writeJson((0, import_node_path7.join)(paths.outDir, "openapi.json"), buildOpenApiDocument(paths, routes, data));
+}
+
+// src/generator/param-types.ts
+var import_node_path8 = require("path");
+function paramsType(params) {
+  if (params.length === 0) {
+    return "{}";
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const param of params) {
+    unique.set(param.name, param);
+  }
+  const fields = [...unique.values()].map((param) => `  ${JSON.stringify(param.name)}: string;`).join("\n");
+  return `{
+${fields}
+}`;
+}
+function varsType(typesDir, sharedFiles) {
+  if (sharedFiles.length === 0) {
+    return "{}";
+  }
+  return sharedFiles.map((file) => {
+    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
+    return `(typeof import(${spec}) extends { middleware: infer M } ? import("@boon4681/giri").InferStackVars<M> : {})`;
+  }).join("\n    & ");
+}
+function methodExports(typesDir, verbs) {
+  return verbs.map(({ method, file }) => {
+    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
+    const input = `import("@boon4681/giri").RouteInputOf<typeof import(${spec})>`;
+    const vars = `Vars & import("@boon4681/giri").MiddlewareVarsOf<typeof import(${spec})>`;
+    return `export type ${method} = import("@boon4681/giri").Handle<Params, ${input}, ${vars}>;`;
+  });
+}
+async function writeParamTypes(paths, folders) {
+  for (const { dir, params, sharedFiles, verbs } of folders) {
+    const file = typeFilePath(paths, dir);
+    const typesDir = (0, import_node_path8.dirname)(file);
+    const lines = [
+      GENERATED_HEADER,
+      `export type Params = ${paramsType(params)};`,
+      "export type RouteParams = Params;",
+      `type Vars = ${varsType(typesDir, sharedFiles)};`,
+      "export type Middleware<Injects extends Record<string, unknown> = {}> =",
+      '  import("@boon4681/giri").Middleware<Params, import("@boon4681/giri").ValidatedInput, Injects>;',
+      'export type Handle<Input extends import("@boon4681/giri").ValidatedInput = import("@boon4681/giri").ValidatedInput> =',
+      '  import("@boon4681/giri").Handle<Params, Input, Vars>;'
+    ];
+    if (verbs.length > 0) {
+      lines.push(...methodExports(typesDir, verbs));
+    }
+    lines.push("");
+    await writeGenerated(file, lines.join("\n"));
+  }
+}
+
+// src/generator/inputs.ts
+function sanitize(schema) {
+  const { $schema, ...rest } = schema;
+  void $schema;
+  return rest;
+}
+function inputToJsonSchema(schema) {
+  if (!isGiriInputSchema(schema)) {
+    return void 0;
+  }
+  return sanitize(schema.toJsonSchema());
+}
+function bodyToJsonSchemas(value) {
+  if (!isGiriBodySchema(value)) {
+    return void 0;
+  }
+  const out = {};
+  for (const [contentType, schema] of Object.entries(value.contents)) {
+    const json = inputToJsonSchema(schema);
+    if (json) {
+      out[contentType] = json;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+
+// src/generator/route-meta.ts
+function loadModule2(file) {
+  const resolved = require.resolve(file);
+  delete require.cache[resolved];
+  return require(resolved);
+}
+function interopDefault2(value) {
+  if (value && typeof value === "object" && "default" in value) {
+    return value.default;
+  }
+  return value;
+}
+function middlewareFunctions(value) {
+  const exported = interopDefault2(value);
+  if (typeof exported === "function") {
+    return [exported];
+  }
+  if (Array.isArray(exported)) {
+    return exported.filter((fn) => typeof fn === "function");
+  }
+  return [];
+}
+function readInput(routeModule) {
+  const input = {};
+  const body = bodyToJsonSchemas(routeModule.body);
+  const query = inputToJsonSchema(routeModule.query);
+  if (body) {
+    input.body = body;
+  }
+  if (query) {
+    input.query = query;
+  }
+  return input.body || input.query ? input : void 0;
+}
+function hiddenFrom(value) {
+  if (value === false) {
+    return true;
+  }
+  if (value === true) {
+    return false;
+  }
+  if (value && typeof value === "object" && "hidden" in value) {
+    return Boolean(value.hidden);
+  }
+  return void 0;
+}
+function collectHidden(route, routeModule, loadShared) {
+  let hidden = false;
+  for (const file of route.sharedFiles) {
+    const opinion = hiddenFrom(loadShared(file).openapi);
+    if (opinion !== void 0) {
+      hidden = opinion;
+    }
+  }
+  const 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));
+    }
+  }
+  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);
+    }
+  }
+  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, {});
+      }
+    }
+    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();
+  }
+  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"));
+}
+
+// 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/schema/responses.ts
+var import_typescript3 = __toESM(require("typescript"));
+
+// src/generator/schema/json-schema.ts
+var import_typescript2 = __toESM(require("typescript"));
+function createWalkContext(checker, location) {
+  return {
+    checker,
+    location,
+    defs: {},
+    inProgress: /* @__PURE__ */ new Map(),
+    usedDefs: /* @__PURE__ */ new Set(),
+    warnings: []
+  };
+}
+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";
+}
+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 values;
+}
+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);
+  }
+  const enumValues = literalValuesOf(members);
+  if (enumValues) {
+    return { enum: enumValues };
+  }
+  return { anyOf: members.map((member) => walkType(member, ctx)) };
+}
+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 schema = { type: "object" };
+  if (Object.keys(properties).length > 0) {
+    schema.properties = properties;
+  }
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  if (indexInfo) {
+    schema.additionalProperties = walkType(indexInfo.type, ctx);
+  } else if (Object.keys(properties).length > 0) {
+    schema.additionalProperties = false;
+  }
+  return schema;
+}
+function defName(type) {
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  const name = symbol?.getName();
+  if (name && name !== "__type" && name !== "__object") {
+    return name;
+  }
+  return `Anonymous${typeId(type)}`;
+}
+function walkObject(type, ctx) {
+  const { checker } = ctx;
+  if (isDateType(type)) {
+    return { type: "string", format: "date-time" };
+  }
+  if (checker.isArrayType(type)) {
+    const [element] = checker.getTypeArguments(type);
+    return { type: "array", items: element ? walkType(element, ctx) : {} };
+  }
+  if (checker.isTupleType(type)) {
+    const elements = checker.getTypeArguments(type);
+    return { type: "array", items: elements.map((element) => walkType(element, ctx)) };
+  }
+  const id = typeId(type);
+  const existing = ctx.inProgress.get(id);
+  if (existing) {
+    ctx.usedDefs.add(existing);
+    return { $ref: `#/$defs/${existing}` };
+  }
+  const name = defName(type);
+  ctx.inProgress.set(id, name);
+  const schema = buildObjectSchema(type, ctx);
+  ctx.inProgress.delete(id);
+  if (ctx.usedDefs.has(name)) {
+    ctx.defs[name] = schema;
+    return { $ref: `#/$defs/${name}` };
+  }
+  return schema;
+}
+function walkType(type, ctx) {
+  const flags = type.flags;
+  if (flags & (import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown)) {
+    return {};
+  }
+  if (flags & import_typescript2.default.TypeFlags.Null) {
+    return { type: "null" };
+  }
+  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
+    return {};
+  }
+  if (flags & (import_typescript2.default.TypeFlags.BigInt | import_typescript2.default.TypeFlags.BigIntLiteral)) {
+    ctx.warnings.push("bigint is not JSON-serializable (JSON.stringify throws); documented as string.");
+    return { type: "string" };
+  }
+  if (type.isStringLiteral()) {
+    return { type: "string", const: type.value };
+  }
+  if (type.isNumberLiteral()) {
+    return { type: "number", const: type.value };
+  }
+  if (flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+    return { type: "boolean", const: intrinsicName(type) === "true" };
+  }
+  if (flags & import_typescript2.default.TypeFlags.String) {
+    return { type: "string" };
+  }
+  if (flags & import_typescript2.default.TypeFlags.Number) {
+    return { type: "number" };
+  }
+  if (flags & import_typescript2.default.TypeFlags.Boolean) {
+    return { type: "boolean" };
+  }
+  if (type.isUnion()) {
+    return walkUnion(type, ctx);
+  }
+  if (flags & import_typescript2.default.TypeFlags.Object || type.isIntersection()) {
+    return walkObject(type, ctx);
+  }
+  return {};
+}
+
+// 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;
+        }
+      }
+    }
+  }
+  return found;
+}
+function collectReturnExpressions(fn) {
+  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
+    return [fn.body];
+  }
+  if (!fn.body) {
+    return [];
+  }
+  const expressions = [];
+  const visit = (node) => {
+    if (import_typescript3.default.isFunctionDeclaration(node) || import_typescript3.default.isFunctionExpression(node) || import_typescript3.default.isArrowFunction(node)) {
+      return;
+    }
+    if (import_typescript3.default.isReturnStatement(node) && node.expression) {
+      expressions.push(node.expression);
+    }
+    import_typescript3.default.forEachChild(node, visit);
+  };
+  import_typescript3.default.forEachChild(fn.body, visit);
+  return expressions;
+}
+function propertyType(checker, type, name, location) {
+  const symbol = checker.getPropertyOfType(type, name);
+  return symbol ? checker.getTypeOfSymbolAtLocation(symbol, location) : void 0;
+}
+function isTypedResponse(checker, type) {
+  return Boolean(
+    checker.getPropertyOfType(type, "data") && checker.getPropertyOfType(type, "status") && checker.getPropertyOfType(type, "format")
+  );
+}
+function readFromCall(checker, expression) {
+  if (!import_typescript3.default.isCallExpression(expression) || !import_typescript3.default.isPropertyAccessExpression(expression.expression)) {
+    return void 0;
+  }
+  const method = expression.expression.name.text;
+  if (method !== "json" && method !== "text") {
+    return void 0;
+  }
+  if (!isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
+    return void 0;
+  }
+  const [dataArg, statusArg] = expression.arguments;
+  if (!dataArg) {
+    return void 0;
+  }
+  let status = 200;
+  if (statusArg) {
+    const statusType = checker.getTypeAtLocation(statusArg);
+    status = statusType.isNumberLiteral() ? statusType.value : "default";
+  }
+  return { status, format: method === "text" ? "text" : "json", data: checker.getTypeAtLocation(dataArg) };
+}
+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 };
+}
+function constituents(type) {
+  return type.isUnion() ? type.types : [type];
+}
+function extractRouteResponses(program, file) {
+  const result = { responses: [], opaque: false, warnings: [], $defs: {} };
+  const source = program.getSourceFile(file);
+  if (!source) {
+    return result;
+  }
+  const checker = program.getTypeChecker();
+  const fn = findHandleFunction(source);
+  if (!fn) {
+    return result;
+  }
+  const ctx = createWalkContext(checker, fn);
+  const byStatus = /* @__PURE__ */ new Map();
+  const record = (hit) => {
+    const schema = walkType(hit.data, ctx);
+    const bucket = byStatus.get(hit.status) ?? { format: hit.format, schemas: [] };
+    bucket.schemas.push(schema);
+    byStatus.set(hit.status, bucket);
+  };
+  for (const expression of collectReturnExpressions(fn)) {
+    const fromCall = readFromCall(checker, expression);
+    if (fromCall) {
+      record(fromCall);
+      continue;
+    }
+    let matched = false;
+    for (const member of constituents(checker.getTypeAtLocation(expression))) {
+      const hit = readFromType(checker, member, expression);
+      if (hit) {
+        record(hit);
+        matched = true;
+      }
+    }
+    if (!matched) {
+      result.opaque = true;
+    }
+  }
+  for (const [status, { format, schemas }] of byStatus) {
+    const schema = schemas.length === 1 ? schemas[0] : { anyOf: schemas };
+    result.responses.push({ status, format, schema });
+  }
+  result.responses.sort((a, b) => Number(a.status) - Number(b.status));
+  result.warnings = ctx.warnings;
+  result.$defs = ctx.defs;
+  return result;
+}
+
+// src/generator/tsconfig.ts
+var import_node_path10 = require("path");
+function normalizeAlias(alias, paths) {
+  const result = {};
+  for (const [key, value] of Object.entries(alias ?? {})) {
+    const targets = Array.isArray(value) ? value : [value];
+    result[key] = targets.map(
+      (target) => relativeConfigPath(paths.outDir, (0, import_node_path10.resolve)(paths.cwd, target))
+    );
+  }
+  return result;
+}
+async function writeTsConfig(paths, config) {
+  const file = (0, import_node_path10.join)(paths.outDir, "tsconfig.json");
+  await writeJson(file, {
+    compilerOptions: {
+      rootDirs: [
+        "..",
+        "./types"
+      ],
+      paths: {
+        // The tsconfig lives in outDir, so `$giri/*` maps to its own folder.
+        "$giri/*": ["./*"],
+        ...normalizeAlias(config.alias, paths)
+      },
+      plugins: [
+        {
+          name: "@boon4681/giri/tsc"
+        }
+      ]
+    },
+    include: [
+      relativeConfigPath(paths.outDir, (0, import_node_path10.join)(paths.cwd, "src")),
+      relativeConfigPath(paths.outDir, (0, import_node_path10.join)(paths.cwd, "giri.config.ts")),
+      "./types/**/*.d.ts"
+    ]
+  });
+}
+
+// src/generator/sync.ts
+async function typeFolders(paths, routes) {
+  const verbsByDir = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const key = slash(route.routeDir);
+    const list = verbsByDir.get(key) ?? [];
+    list.push({ method: route.method, file: route.file });
+    verbsByDir.set(key, list);
+  }
+  const dirs = await scanRouteFolders(paths.routesDir);
+  return dirs.map((dir) => ({
+    dir,
+    params: routeParamsForDir(paths.routesDir, dir),
+    sharedFiles: sharedFilesForDir(paths.routesDir, dir),
+    verbs: verbsByDir.get(slash(dir)) ?? []
+  }));
+}
+function extractResponses(paths, routes) {
+  const byFile = /* @__PURE__ */ new Map();
+  if (routes.length === 0) {
+    return byFile;
+  }
+  try {
+    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(
+      paths,
+      (0, import_node_fs6.existsSync)(appTypes) ? [...files, appTypes] : files
+    );
+    for (const file of files) {
+      byFile.set(file, extractRouteResponses(program, file));
+    }
+  } catch (error) {
+    console.warn(`giri: skipped response schema generation (${error.message}).`);
+  }
+  return byFile;
+}
+async function extractMeta(config, paths, routes) {
+  const inputsByFile = /* @__PURE__ */ new Map();
+  const securityByFile = /* @__PURE__ */ new Map();
+  const hiddenFiles = /* @__PURE__ */ new Set();
+  if (routes.length === 0) {
+    return { inputsByFile, securityByFile, hiddenFiles };
+  }
+  try {
+    const meta = await extractRouteMeta(config, paths, routes);
+    for (const [file, entry] of meta) {
+      if (entry.input) {
+        inputsByFile.set(file, entry.input);
+      }
+      if (entry.security) {
+        securityByFile.set(file, entry.security);
+      }
+      if (entry.hidden) {
+        hiddenFiles.add(file);
+      }
+    }
+  } catch (error) {
+    console.warn(`giri: skipped input/security generation (${error.message}).`);
+  }
+  return { inputsByFile, securityByFile, hiddenFiles };
+}
+async function syncProject(config, options = {}) {
+  const paths = resolveGiriPaths(config, options.cwd);
+  assertSafeOutDir(paths);
+  const routes = await scanRoutes(paths.routesDir);
+  const folders = await typeFolders(paths, routes);
+  await (0, import_promises3.mkdir)(paths.outDir, { recursive: true });
+  await writeParamTypes(paths, folders);
+  await writeRouteTypes(paths, routes);
+  await writeAppTypes(paths);
+  await writeTsConfig(paths, config);
+  const responsesByFile = extractResponses(paths, routes);
+  const { inputsByFile, securityByFile, hiddenFiles } = await extractMeta(config, paths, routes);
+  const data = { responsesByFile, inputsByFile, securityByFile, hiddenFiles };
+  await writeManifest(paths, routes, data);
+  await writeOpenApi(paths, routes, data);
+  await pruneDir(
+    paths.outDir,
+    /* @__PURE__ */ new Set([
+      (0, import_node_path11.join)(paths.outDir, "tsconfig.json"),
+      (0, import_node_path11.join)(paths.outDir, "manifest.json"),
+      (0, import_node_path11.join)(paths.outDir, "openapi.json"),
+      (0, import_node_path11.join)(paths.outDir, "routes.d.ts"),
+      (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts"),
+      ...folders.map((folder) => typeFilePath(paths, folder.dir))
+    ])
+  );
+  return { paths, routes, folders, data };
+}
+
+// src/generator/watch.ts
+var import_node_fs7 = require("fs");
+var import_node_path13 = require("path");
+
+// src/loader/module-loader.ts
+var import_node_path12 = require("path");
+var toSlash = (path) => path.split(import_node_path12.sep).join("/");
+var isProjectModule = (id, root) => {
+  return id.startsWith(root) && !id.includes(`${import_node_path12.sep}node_modules${import_node_path12.sep}`) && !id.includes(`${import_node_path12.sep}.giri${import_node_path12.sep}`);
+};
+var buildModuleGraph = (cwd) => {
+  const root = (0, import_node_path12.resolve)(cwd) + import_node_path12.sep;
+  const importers = /* @__PURE__ */ new Map();
+  const nodes = /* @__PURE__ */ new Set();
+  for (const id of Object.keys(require.cache)) {
+    if (!isProjectModule(id, root)) {
+      continue;
+    }
+    const mod = require.cache[id];
+    if (!mod) {
+      continue;
+    }
+    nodes.add(toSlash(id));
+    for (const child of mod.children) {
+      if (!isProjectModule(child.id, root)) {
+        continue;
+      }
+      nodes.add(toSlash(child.id));
+      const dep = toSlash(child.id);
+      let set = importers.get(dep);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        importers.set(dep, set);
+      }
+      set.add(toSlash(id));
+    }
+  }
+  return { importers, nodes };
+};
+var collectDependents = (graph, start) => {
+  const out = /* @__PURE__ */ new Set([start]);
+  const stack = [start];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const importer of graph.importers.get(current) ?? []) {
+      if (!out.has(importer)) {
+        out.add(importer);
+        stack.push(importer);
+      }
+    }
+  }
+  return out;
+};
+var purgeModules = (files) => {
+  for (const id of Object.keys(require.cache)) {
+    if (files.has(toSlash(id))) {
+      delete require.cache[id];
+    }
+  }
+};
+var purgeProjectModules = (cwd) => {
+  const root = (0, import_node_path12.resolve)(cwd) + import_node_path12.sep;
+  for (const id of Object.keys(require.cache)) {
+    if (isProjectModule(id, root)) {
+      delete require.cache[id];
+    }
+  }
+};
+
+// src/generator/watch.ts
+function createWatchUpdater(config, initial) {
+  const paths = initial.paths;
+  let routes = initial.routes;
+  const data = initial.data;
+  const fullResync = async () => {
+    purgeProjectModules(paths.cwd);
+    const result = await syncProject(config, { cwd: paths.cwd });
+    routes = result.routes;
+    data.responsesByFile = result.data.responsesByFile;
+    data.inputsByFile = result.data.inputsByFile;
+    data.securityByFile = result.data.securityByFile;
+    data.hiddenFiles = result.data.hiddenFiles;
+    return "full";
+  };
+  const reextractRoute = async (route) => {
+    const key = route.file;
+    try {
+      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));
+    } catch {
+    }
+    try {
+      const meta = await extractRouteMeta(config, paths, [route]);
+      const entry = meta.get(key);
+      data.inputsByFile.delete(key);
+      data.securityByFile.delete(key);
+      data.hiddenFiles.delete(key);
+      if (entry?.input) {
+        data.inputsByFile.set(key, entry.input);
+      }
+      if (entry?.security) {
+        data.securityByFile.set(key, entry.security);
+      }
+      if (entry?.hidden) {
+        data.hiddenFiles.add(key);
+      }
+    } catch {
+    }
+  };
+  return {
+    async apply(filename) {
+      if (!filename) {
+        return fullResync();
+      }
+      const abs = (0, import_node_path13.resolve)((0, import_node_path13.dirname)(paths.routesDir), filename);
+      const file = slash(abs);
+      if (!(0, import_node_fs7.existsSync)(abs)) {
+        return fullResync();
+      }
+      const graph = buildModuleGraph(paths.cwd);
+      const isRoute = routes.some((candidate) => slash(candidate.file) === file);
+      if (!graph.nodes.has(file) && !isRoute) {
+        return fullResync();
+      }
+      const dependents = collectDependents(graph, file);
+      const affected = routes.filter(
+        (route) => dependents.has(slash(route.file)) || route.sharedFiles.some((shared) => dependents.has(slash(shared)))
+      );
+      purgeModules(dependents);
+      for (const route of affected) {
+        await reextractRoute(route);
+      }
+      await writeManifest(paths, routes, data);
+      await writeOpenApi(paths, routes, data);
+      return "incremental";
+    }
+  };
+}
+
+// src/lifecycle.ts
+var import_node_fs8 = require("fs");
+var import_node_path14 = require("path");
+var MAIN_EXTENSIONS2 = ["ts", "tsx", "mts", "cts", "js", "jsx", "mjs", "cjs"];
+function resolveMainFile(cwd) {
+  for (const ext of MAIN_EXTENSIONS2) {
+    const file = (0, import_node_path14.join)(cwd, "src", `main.${ext}`);
+    if ((0, import_node_fs8.existsSync)(file)) {
+      return file;
+    }
+  }
+  return void 0;
+}
+async function loadLifecycle(cwd = process.cwd()) {
+  const file = resolveMainFile((0, import_node_path14.resolve)(cwd));
+  if (!file) {
+    return {};
+  }
+  const { unregister } = await safeRegister();
+  try {
+    const resolved = require.resolve(file);
+    delete require.cache[resolved];
+    const loaded = require(resolved);
+    const lifecycle = { file };
+    if (loaded.init !== void 0) {
+      if (typeof loaded.init !== "function") {
+        throw new Error(`${file}: "init" must be a function.`);
+      }
+      lifecycle.init = loaded.init;
+    }
+    if (loaded.teardown !== void 0) {
+      if (typeof loaded.teardown !== "function") {
+        throw new Error(`${file}: "teardown" must be a function.`);
+      }
+      lifecycle.teardown = loaded.teardown;
+    }
+    return lifecycle;
+  } finally {
+    unregister();
+  }
+}
+async function runInit(lifecycle) {
+  if (!lifecycle.init) {
+    return {};
+  }
+  const services = await lifecycle.init();
+  return services ?? {};
+}
+
+// src/logger.ts
+var noColor = !process.stdout.isTTY || process.env.NO_COLOR !== void 0 || process.env.TERM === "dumb" || process.env.FORCE_COLOR === "0";
+function paint(open, close) {
+  return (text) => noColor ? text : `\x1B[${open}m${text}\x1B[${close}m`;
+}
+var color = {
+  dim: paint(2, 22),
+  bold: paint(1, 22),
+  red: paint(31, 39),
+  green: paint(32, 39),
+  yellow: paint(33, 39),
+  blue: paint(34, 39),
+  magenta: paint(35, 39),
+  cyan: paint(36, 39),
+  gray: paint(90, 39)
+};
+var highlight = (text) => color.green(text);
+var muted = (text) => color.dim(text);
+function timestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
+var TAG = "giri";
+function line(tag2, message, scope) {
+  const parts = [color.gray(timestamp()), tag2];
+  if (scope) {
+    parts.push(color.dim(`(${scope})`));
+  }
+  parts.push(message);
+  return parts.join(" ");
+}
+var tag = {
+  info: color.bold(color.cyan(`[${TAG}]`)),
+  warn: color.bold(color.yellow(`[${TAG}]`)),
+  error: color.bold(color.red(`[${TAG}]`))
+};
+var log2 = {
+  info(message, scope) {
+    console.log(line(tag.info, message, scope));
+  },
+  success(message, scope) {
+    console.log(line(tag.info, color.green(message), scope));
+  },
+  warn(message, scope) {
+    console.warn(line(tag.warn, color.yellow(message), scope));
+  },
+  error(message, scope) {
+    console.error(line(tag.error, color.red(message), scope));
+  },
+  ready(url) {
+    console.log(line(tag.info, `${color.green("ready")} on ${color.cyan(url)}`));
+  },
+  change(verb, path, count) {
+    const suffix = count && count > 1 ? ` ${color.dim(`(x${count})`)}` : "";
+    console.log(line(tag.info, `${color.green(verb)} ${highlight(path)}${suffix}`, "watch"));
+  }
+};
+
+// src/cli.ts
+var ADAPTERS = [
+  {
+    value: "hono",
+    label: "Hono",
+    hint: "recommended, ships today",
+    available: true,
+    importLine: 'import { hono } from "@boon4681/giri/adapters/hono";',
+    expr: "hono()",
+    deps: ["hono", "@hono/node-server"]
+  }
+];
+function help() {
+  console.log(`giri
+
+Usage:
+  giri init [--adapter hono] [--pm npm|yarn|pnpm|bun] [--no-install] [-y]
+  giri sync
+  giri serve [--port 3000] [--host 127.0.0.1] [--no-watch]
+  giri build
+`);
+}
+function parseInitFlags(args) {
+  const flags = { yes: false };
+  const managers = ["npm", "yarn", "pnpm", "bun"];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--adapter" || arg === "-a") {
+      flags.adapter = args[++index];
+    } else if (arg === "--pm" || arg === "--package-manager") {
+      const value = args[++index];
+      if (!managers.includes(value)) {
+        throw new Error(`Unknown package manager: ${value} (expected ${managers.join(", ")})`);
+      }
+      flags.packageManager = value;
+    } else if (arg === "--install") {
+      flags.install = true;
+    } else if (arg === "--no-install") {
+      flags.install = false;
+    } else if (arg === "-y" || arg === "--yes") {
+      flags.yes = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return flags;
+}
+function parseFlags(args) {
+  const flags = { watch: true };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--port" || arg === "-p") {
+      flags.port = Number(args[++index]);
+    } else if (arg === "--host" || arg === "--hostname") {
+      flags.hostname = args[++index];
+    } else if (arg === "--no-watch") {
+      flags.watch = false;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return flags;
+}
+async function ensureGitignore(cwd) {
+  const file = (0, import_node_path15.join)(cwd, ".gitignore");
+  const entry = ".giri";
+  if (!(0, import_node_fs9.existsSync)(file)) {
+    await (0, import_promises4.writeFile)(file, `${entry}
+`);
+    return;
+  }
+  const content = await (0, import_promises4.readFile)(file, "utf8");
+  if (!content.split(/\r?\n/).includes(entry)) {
+    await (0, import_promises4.appendFile)(file, `${content.endsWith("\n") ? "" : "\n"}${entry}
+`);
+  }
+}
+async function ensureTsConfig(cwd) {
+  const file = (0, import_node_path15.join)(cwd, "tsconfig.json");
+  if ((0, import_node_fs9.existsSync)(file)) {
+    return;
+  }
+  await (0, import_promises4.writeFile)(
+    file,
+    `${JSON.stringify(
+      {
+        extends: "./.giri/tsconfig.json",
+        compilerOptions: {
+          target: "ES2022",
+          lib: ["ES2022", "DOM"],
+          module: "NodeNext",
+          moduleResolution: "NodeNext",
+          strict: true,
+          esModuleInterop: true,
+          forceConsistentCasingInFileNames: true,
+          skipLibCheck: true,
+          types: ["node"]
+        }
+      },
+      null,
+      2
+    )}
+`
+  );
+}
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  if (ua.startsWith("yarn")) return "yarn";
+  if (ua.startsWith("pnpm")) return "pnpm";
+  if (ua.startsWith("bun")) return "bun";
+  return "npm";
+}
+function installArgs(pm, deps, dev) {
+  if (pm === "npm") return ["install", ...dev ? ["--save-dev"] : [], ...deps];
+  if (pm === "bun") return ["add", ...dev ? ["--dev"] : [], ...deps];
+  return ["add", ...dev ? ["--dev"] : [], ...deps];
+}
+function runCommand(cmd, args, cwd) {
+  return new Promise((resolvePromise, reject) => {
+    const child = (0, import_node_child_process.spawn)(cmd, args, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolvePromise();
+      } else {
+        reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}`));
+      }
+    });
+  });
+}
+function configSource(adapter) {
+  return [
+    'import { defineConfig } from "@boon4681/giri";',
+    adapter.importLine,
+    "",
+    "export default defineConfig({",
+    `   adapter: ${adapter.expr},`,
+    "});",
+    ""
+  ].join("\n");
+}
+async function selectAdapter(interactive) {
+  if (!interactive || ADAPTERS.length === 1) {
+    return ADAPTERS[0];
+  }
+  const picked = await prompts.select({
+    message: "Which backend adapter?",
+    initialValue: "hono",
+    options: ADAPTERS.map((adapter) => ({
+      value: adapter.value,
+      label: adapter.label,
+      hint: adapter.hint
+    }))
+  });
+  if (prompts.isCancel(picked)) {
+    return null;
+  }
+  return ADAPTERS.find((adapter) => adapter.value === picked) ?? null;
+}
+async function initProject(cwd, flags) {
+  const interactive = Boolean(process.stdout.isTTY) && !flags.yes;
+  prompts.intro("giri init");
+  let adapter;
+  if (flags.adapter) {
+    adapter = ADAPTERS.find((choice) => choice.value === flags.adapter) ?? null;
+    if (!adapter) {
+      prompts.cancel(`Unknown adapter "${flags.adapter}". Available: ${ADAPTERS.map((a) => a.value).join(", ")}.`);
+      return;
+    }
+  } else {
+    adapter = await selectAdapter(interactive);
+    if (!adapter) {
+      prompts.cancel("Cancelled.");
+      return;
+    }
+  }
+  if (!adapter.available) {
+    prompts.cancel(`The ${adapter.label} adapter isn't available yet \u2014 only Hono ships today.`);
+    return;
+  }
+  const configPath = (0, import_node_path15.join)(cwd, "giri.config.ts");
+  if (!(0, import_node_fs9.existsSync)(configPath)) {
+    await (0, import_promises4.writeFile)(configPath, configSource(adapter));
+  }
+  const routePath = (0, import_node_path15.join)(cwd, "src", "routes", "+get.ts");
+  if (!(0, import_node_fs9.existsSync)(routePath)) {
+    await (0, import_promises4.mkdir)((0, import_node_path15.join)(cwd, "src", "routes"), { recursive: true });
+    await (0, import_promises4.writeFile)(
+      routePath,
+      [
+        'import type { Handle } from "@boon4681/giri";',
+        "",
+        "export const handle: Handle = (c) => c.json({ ok: true });",
+        ""
+      ].join("\n")
+    );
+  }
+  await ensureGitignore(cwd);
+  await ensureTsConfig(cwd);
+  prompts.log.success(`scaffolded a ${adapter.label} project`);
+  const pm = flags.packageManager ?? detectPackageManager();
+  let install = flags.install;
+  if (install === void 0) {
+    if (!interactive) {
+      install = flags.yes;
+    } else {
+      const answer = await prompts.confirm({ message: `Install dependencies with ${pm}?` });
+      if (prompts.isCancel(answer)) {
+        prompts.cancel("Cancelled \u2014 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);
+    } 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\`.`);
+      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`
+  );
+}
+function displayHost(address) {
+  if (!address || address === "::" || address === "0.0.0.0") {
+    return "localhost";
+  }
+  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));
+            }
+            current = await buildGiriApp(config, { services });
+          }
+        } 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);
+      });
+    }
+  }
+  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);
+}
+function registerShutdown(server, lifecycle, services) {
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    try {
+      await server.close();
+      if (lifecycle.teardown) {
+        await lifecycle.teardown(services);
+      }
+    } catch (error) {
+      log2.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    } finally {
+      process.exit(process.exitCode ?? 0);
+    }
+  };
+  process.once("SIGINT", () => void shutdown());
+  process.once("SIGTERM", () => void shutdown());
+}
+async function main() {
+  const [command = "help", ...args] = process.argv.slice(2);
+  const cwd = (0, import_node_path15.resolve)(process.cwd());
+  if (command === "help" || command === "--help" || command === "-h") {
+    help();
+    return;
+  }
+  if (command === "init") {
+    await initProject(cwd, parseInitFlags(args));
+    return;
+  }
+  if (command === "build") {
+    log2.warn("build is planned, but is currently a no-op", "build");
+    return;
+  }
+  const config = await load();
+  if (command === "sync") {
+    const result = await syncProject(config);
+    log2.success(
+      `synced ${result.routes.length} route${result.routes.length === 1 ? "" : "s"} ${muted(`at ${result.paths.outDir}`)}`,
+      "sync"
+    );
+    return;
+  }
+  if (command === "serve") {
+    await serveProject(config, parseFlags(args));
+    return;
+  }
+  throw new Error(`Unknown command: ${command}`);
+}
+main().catch((error) => {
+  log2.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map