@boon4681/giri 0.0.1

package/dist/index.js

@@ -0,0 +1,1762 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildGiriApp: () => buildGiriApp,
+  composeMiddleware: () => composeMiddleware,
+  createContext: () => createContext,
+  createTypedResponse: () => createTypedResponse,
+  defineBodySchema: () => defineBodySchema,
+  defineConfig: () => defineConfig,
+  defineInputSchema: () => defineInputSchema,
+  defineMiddleware: () => defineMiddleware,
+  isGiriBodySchema: () => isGiriBodySchema,
+  isGiriInputSchema: () => isGiriInputSchema,
+  isTypedResponse: () => isTypedResponse,
+  loadLifecycle: () => loadLifecycle,
+  prepareRequestInput: () => prepareRequestInput,
+  resolveGiriPaths: () => resolveGiriPaths,
+  runInit: () => runInit,
+  scanRoutes: () => scanRoutes,
+  stack: () => stack,
+  syncProject: () => syncProject,
+  toResponse: () => toResponse,
+  typedResponseToResponse: () => typedResponseToResponse
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var typedResponseBrand = /* @__PURE__ */ Symbol.for("giri.typed-response");
+var inputSchemaBrand = /* @__PURE__ */ Symbol.for("giri.input-schema");
+var bodySchemaBrand = /* @__PURE__ */ Symbol.for("giri.body-schema");
+
+// src/context.ts
+var BODYLESS_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+function createTypedResponse(data, status, format, headers) {
+  return {
+    [typedResponseBrand]: { data, status, format },
+    data,
+    status,
+    format,
+    headers
+  };
+}
+function isTypedResponse(value) {
+  return Boolean(value && typeof value === "object" && typedResponseBrand in value);
+}
+function createContext(options) {
+  const url = new URL(options.request.url);
+  const store = /* @__PURE__ */ new Map();
+  const validated = options.validated ?? {};
+  return {
+    params: options.params ?? {},
+    app: options.app ?? {},
+    req: {
+      raw: options.request,
+      url,
+      method: options.request.method,
+      header: (name) => options.request.headers.get(name),
+      json: () => options.request.json(),
+      text: () => options.request.text(),
+      arrayBuffer: () => options.request.arrayBuffer(),
+      formData: () => options.request.formData(),
+      valid: (key) => {
+        if (!(key in validated)) {
+          throw new Error(`No validated ${String(key)} data is available for this route.`);
+        }
+        return validated[key];
+      }
+    },
+    set: (key, value) => {
+      store.set(key, value);
+    },
+    get: (key) => store.get(key),
+    json: (data, status = 200, headers) => createTypedResponse(data, status, "json", headers),
+    text: (text, status = 200, headers) => createTypedResponse(text, status, "text", headers)
+  };
+}
+function typedResponseToResponse(response) {
+  const headers = new Headers(response.headers);
+  if (response.format === "json" && !headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  if (response.format === "text" && !headers.has("content-type")) {
+    headers.set("content-type", "text/plain; charset=utf-8");
+  }
+  const body = BODYLESS_STATUS.has(response.status) ? null : response.format === "json" ? JSON.stringify(response.data) : String(response.data);
+  return new Response(body, {
+    status: response.status,
+    headers
+  });
+}
+function toResponse(response) {
+  return isTypedResponse(response) ? typedResponseToResponse(response) : response;
+}
+async function composeMiddleware(middleware, handle, context) {
+  let index = -1;
+  let result;
+  const dispatch = async (i) => {
+    if (i <= index) {
+      throw new Error("next() called multiple times in giri middleware.");
+    }
+    index = i;
+    if (i === middleware.length) {
+      result = await handle(context);
+      return result;
+    }
+    const returned = await middleware[i](context, () => dispatch(i + 1));
+    if (returned !== void 0) {
+      result = returned;
+      return returned;
+    }
+    return result;
+  };
+  await dispatch(0);
+  if (result === void 0) {
+    throw new Error("Route completed without returning a response.");
+  }
+  return result;
+}
+function defineMiddleware(optionsOrMiddleware, maybeMiddleware) {
+  if (typeof optionsOrMiddleware === "function") {
+    return optionsOrMiddleware;
+  }
+  if (!maybeMiddleware) {
+    throw new Error("defineMiddleware(options, middleware) requires a middleware function.");
+  }
+  maybeMiddleware.openapi = optionsOrMiddleware.openapi;
+  return maybeMiddleware;
+}
+function stack(...middleware) {
+  return middleware;
+}
+
+// src/validation.ts
+function defineInputSchema(schema) {
+  return { [inputSchemaBrand]: true, ...schema };
+}
+function isGiriInputSchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[inputSchemaBrand] === true
+  );
+}
+function defineBodySchema(contents) {
+  return { [bodySchemaBrand]: true, contents };
+}
+function isGiriBodySchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[bodySchemaBrand] === true
+  );
+}
+var MIME_TO_CONTENT_TYPE = {
+  "application/json": "json",
+  "multipart/form-data": "form",
+  "application/x-www-form-urlencoded": "urlencoded",
+  "text/plain": "text"
+};
+function contentTypeFromHeader(header) {
+  if (!header) {
+    return void 0;
+  }
+  const mime = header.split(";", 1)[0].trim().toLowerCase();
+  return MIME_TO_CONTENT_TYPE[mime];
+}
+function formDataObject(form) {
+  const result = {};
+  form.forEach((value, key) => {
+    const current = result[key];
+    if (current === void 0) {
+      result[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      result[key] = [current, value];
+    }
+  });
+  return result;
+}
+async function readRawBody(request, contentType) {
+  const cloned = request.clone();
+  if (contentType === "json") {
+    return cloned.json();
+  }
+  if (contentType === "text") {
+    return cloned.text();
+  }
+  return formDataObject(await cloned.formData());
+}
+function queryObject(url) {
+  const result = {};
+  for (const [key, value] of url.searchParams) {
+    const current = result[key];
+    if (current === void 0) {
+      result[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      result[key] = [current, value];
+    }
+  }
+  return result;
+}
+async function runValidation(schema, value, label) {
+  if (!isGiriInputSchema(schema)) {
+    throw new Error(
+      `giri: ${label} schema must be wrapped with a validator, e.g. \`export const ${label} = zod(...)\` from @boon4681/giri/validators/zod.`
+    );
+  }
+  return schema.validate(value);
+}
+async function prepareRequestInput(request, input) {
+  const validated = {};
+  if (input?.query) {
+    const query = queryObject(new URL(request.url));
+    const result = await runValidation(input.query, query, "query");
+    if (!result.ok) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid query parameters.", issues: result.issues },
+          400,
+          "json"
+        )
+      };
+    }
+    validated.query = result.value;
+  }
+  if (input?.body) {
+    const contents = input.body.contents;
+    const declared = Object.keys(contents);
+    const requested = contentTypeFromHeader(request.headers.get("content-type"));
+    const chosen = requested && contents[requested] ? requested : contents.json ? "json" : void 0;
+    if (!chosen) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Unsupported media type.", issues: { accepted: declared } },
+          415,
+          "json"
+        )
+      };
+    }
+    let rawBody;
+    try {
+      rawBody = await readRawBody(request, chosen);
+    } catch (error) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid request body.", issues: error },
+          400,
+          "json"
+        )
+      };
+    }
+    const result = await runValidation(contents[chosen], rawBody, "body");
+    if (!result.ok) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid request body.", issues: result.issues },
+          400,
+          "json"
+        )
+      };
+    }
+    validated.body = declared.length > 1 ? { type: chosen, data: result.value } : result.value;
+  }
+  return { ok: true, validated };
+}
+
+// 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;
+};
+
+// 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/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 isTypedResponse2(checker, type) {
+  return Boolean(
+    checker.getPropertyOfType(type, "data") && checker.getPropertyOfType(type, "status") && checker.getPropertyOfType(type, "format")
+  );
+}
+function readFromCall(checker, expression) {
+  if (!import_typescript3.default.isCallExpression(expression) || !import_typescript3.default.isPropertyAccessExpression(expression.expression)) {
+    return void 0;
+  }
+  const method = expression.expression.name.text;
+  if (method !== "json" && method !== "text") {
+    return void 0;
+  }
+  if (!isTypedResponse2(checker, checker.getTypeAtLocation(expression))) {
+    return void 0;
+  }
+  const [dataArg, statusArg] = expression.arguments;
+  if (!dataArg) {
+    return void 0;
+  }
+  let status = 200;
+  if (statusArg) {
+    const statusType = checker.getTypeAtLocation(statusArg);
+    status = statusType.isNumberLiteral() ? statusType.value : "default";
+  }
+  return { status, format: method === "text" ? "text" : "json", data: checker.getTypeAtLocation(dataArg) };
+}
+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");
+
+// 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/index.ts
+function defineConfig(config) {
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildGiriApp,
+  composeMiddleware,
+  createContext,
+  createTypedResponse,
+  defineBodySchema,
+  defineConfig,
+  defineInputSchema,
+  defineMiddleware,
+  isGiriBodySchema,
+  isGiriInputSchema,
+  isTypedResponse,
+  loadLifecycle,
+  prepareRequestInput,
+  resolveGiriPaths,
+  runInit,
+  scanRoutes,
+  stack,
+  syncProject,
+  toResponse,
+  typedResponseToResponse
+});
+//# sourceMappingURL=index.js.map