@boon4681/giri 0.0.2 → 0.0.3-alpha-1

package/dist/index.js

@@ -47,10 +47,10 @@ var init_es5 = __esm({
 // src/generator/schema/program.ts
 function createSchemaProgram(paths, routeFiles) {
   let options = { ...DEFAULT_OPTIONS };
-  const configPath = import_typescript.default.findConfigFile(paths.cwd, import_typescript.default.sys.fileExists, "tsconfig.json");
+  const configPath = import_typescript2.default.findConfigFile(paths.cwd, import_typescript2.default.sys.fileExists, "tsconfig.json");
   if (configPath) {
-    const parsed = import_typescript.default.getParsedCommandLineOfConfigFile(configPath, {}, {
-      ...import_typescript.default.sys,
+    const parsed = import_typescript2.default.getParsedCommandLineOfConfigFile(configPath, {}, {
+      ...import_typescript2.default.sys,
       onUnRecoverableConfigFileDiagnostic: () => {
       }
     });
@@ -58,17 +58,17 @@ function createSchemaProgram(paths, routeFiles) {
       options = { ...parsed.options, noEmit: true };
     }
   }
-  return import_typescript.default.createProgram(routeFiles, options);
+  return import_typescript2.default.createProgram(routeFiles, options);
 }
-var import_typescript, DEFAULT_OPTIONS;
+var import_typescript2, DEFAULT_OPTIONS;
 var init_program = __esm({
   "src/generator/schema/program.ts"() {
     "use strict";
-    import_typescript = __toESM(require("typescript"));
+    import_typescript2 = __toESM(require("typescript"));
     DEFAULT_OPTIONS = {
-      target: import_typescript.default.ScriptTarget.ES2022,
-      module: import_typescript.default.ModuleKind.NodeNext,
-      moduleResolution: import_typescript.default.ModuleResolutionKind.NodeNext,
+      target: import_typescript2.default.ScriptTarget.ES2022,
+      module: import_typescript2.default.ModuleKind.NodeNext,
+      moduleResolution: import_typescript2.default.ModuleResolutionKind.NodeNext,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -102,7 +102,7 @@ function literalValuesOf(types) {
   for (const member of types) {
     if (member.isStringLiteral() || member.isNumberLiteral()) {
       values.push(member.value);
-    } else if (member.flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+    } else if (member.flags & import_typescript3.default.TypeFlags.BooleanLiteral) {
       values.push(intrinsicName(member) === "true");
     } else {
       return void 0;
@@ -111,7 +111,7 @@ function literalValuesOf(types) {
   return values;
 }
 function walkUnion(type, ctx) {
-  const flag = import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void | import_typescript2.default.TypeFlags.Never;
+  const flag = import_typescript3.default.TypeFlags.Undefined | import_typescript3.default.TypeFlags.Void | import_typescript3.default.TypeFlags.Never;
   const members = type.types.filter((member) => !(member.flags & flag));
   if (members.length === 1) {
     return walkType(members[0], ctx);
@@ -124,13 +124,13 @@ function walkUnion(type, 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 indexInfo = checker.getIndexInfoOfType(type, import_typescript3.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript3.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));
+    const optional = Boolean(symbol.getFlags() & import_typescript3.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript3.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript3.default.TypeFlags.Undefined));
     properties[name] = walkType(propType, ctx);
     if (!optional) {
       required.push(name);
@@ -189,16 +189,16 @@ function walkObject(type, ctx) {
 }
 function walkType(type, ctx) {
   const flags = type.flags;
-  if (flags & (import_typescript2.default.TypeFlags.Any | import_typescript2.default.TypeFlags.Unknown)) {
+  if (flags & (import_typescript3.default.TypeFlags.Any | import_typescript3.default.TypeFlags.Unknown)) {
     return {};
   }
-  if (flags & import_typescript2.default.TypeFlags.Null) {
+  if (flags & import_typescript3.default.TypeFlags.Null) {
     return { type: "null" };
   }
-  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
+  if (flags & (import_typescript3.default.TypeFlags.Undefined | import_typescript3.default.TypeFlags.Void)) {
     return {};
   }
-  if (flags & (import_typescript2.default.TypeFlags.BigInt | import_typescript2.default.TypeFlags.BigIntLiteral)) {
+  if (flags & (import_typescript3.default.TypeFlags.BigInt | import_typescript3.default.TypeFlags.BigIntLiteral)) {
     ctx.warnings.push("bigint is not JSON-serializable (JSON.stringify throws); documented as string.");
     return { type: "string" };
   }
@@ -208,45 +208,45 @@ function walkType(type, ctx) {
   if (type.isNumberLiteral()) {
     return { type: "number", const: type.value };
   }
-  if (flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+  if (flags & import_typescript3.default.TypeFlags.BooleanLiteral) {
     return { type: "boolean", const: intrinsicName(type) === "true" };
   }
-  if (flags & import_typescript2.default.TypeFlags.String) {
+  if (flags & import_typescript3.default.TypeFlags.String) {
     return { type: "string" };
   }
-  if (flags & import_typescript2.default.TypeFlags.Number) {
+  if (flags & import_typescript3.default.TypeFlags.Number) {
     return { type: "number" };
   }
-  if (flags & import_typescript2.default.TypeFlags.Boolean) {
+  if (flags & import_typescript3.default.TypeFlags.Boolean) {
     return { type: "boolean" };
   }
   if (type.isUnion()) {
     return walkUnion(type, ctx);
   }
-  if (flags & import_typescript2.default.TypeFlags.Object || type.isIntersection()) {
+  if (flags & import_typescript3.default.TypeFlags.Object || type.isIntersection()) {
     return walkObject(type, ctx);
   }
   return {};
 }
-var import_typescript2;
+var import_typescript3;
 var init_json_schema = __esm({
   "src/generator/schema/json-schema.ts"() {
     "use strict";
-    import_typescript2 = __toESM(require("typescript"));
+    import_typescript3 = __toESM(require("typescript"));
   }
 });
 
 // src/generator/schema/responses.ts
 function findHandleFunction(source) {
   let found;
-  const isExported = (node) => import_typescript3.default.canHaveModifiers(node) && (import_typescript3.default.getModifiers(node)?.some((m) => m.kind === import_typescript3.default.SyntaxKind.ExportKeyword) ?? false);
+  const isExported = (node) => import_typescript4.default.canHaveModifiers(node) && (import_typescript4.default.getModifiers(node)?.some((m) => m.kind === import_typescript4.default.SyntaxKind.ExportKeyword) ?? false);
   for (const statement of source.statements) {
-    if (import_typescript3.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
+    if (import_typescript4.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
       found = statement;
     }
-    if (import_typescript3.default.isVariableStatement(statement) && isExported(statement)) {
+    if (import_typescript4.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))) {
+        if (import_typescript4.default.isIdentifier(declaration.name) && declaration.name.text === "handle" && declaration.initializer && (import_typescript4.default.isArrowFunction(declaration.initializer) || import_typescript4.default.isFunctionExpression(declaration.initializer))) {
           found = declaration.initializer;
         }
       }
@@ -255,7 +255,7 @@ function findHandleFunction(source) {
   return found;
 }
 function collectReturnExpressions(fn) {
-  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
+  if (import_typescript4.default.isArrowFunction(fn) && !import_typescript4.default.isBlock(fn.body)) {
     return [fn.body];
   }
   if (!fn.body) {
@@ -263,15 +263,15 @@ function collectReturnExpressions(fn) {
   }
   const expressions = [];
   const visit = (node) => {
-    if (import_typescript3.default.isFunctionDeclaration(node) || import_typescript3.default.isFunctionExpression(node) || import_typescript3.default.isArrowFunction(node)) {
+    if (import_typescript4.default.isFunctionDeclaration(node) || import_typescript4.default.isFunctionExpression(node) || import_typescript4.default.isArrowFunction(node)) {
       return;
     }
-    if (import_typescript3.default.isReturnStatement(node) && node.expression) {
+    if (import_typescript4.default.isReturnStatement(node) && node.expression) {
       expressions.push(node.expression);
     }
-    import_typescript3.default.forEachChild(node, visit);
+    import_typescript4.default.forEachChild(node, visit);
   };
-  import_typescript3.default.forEachChild(fn.body, visit);
+  import_typescript4.default.forEachChild(fn.body, visit);
   return expressions;
 }
 function propertyType(checker, type, name, location) {
@@ -283,15 +283,21 @@ function isTypedResponse2(checker, type) {
     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)) {
+function firstParameterName(fn) {
+  const [first] = fn.parameters;
+  return first && import_typescript4.default.isIdentifier(first.name) ? first.name.text : void 0;
+}
+function readFromCall(checker, expression, contextName) {
+  if (!import_typescript4.default.isCallExpression(expression) || !import_typescript4.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))) {
+  const target = expression.expression.expression;
+  const directContextCall = contextName && import_typescript4.default.isIdentifier(target) && target.text === contextName;
+  if (!directContextCall && !isTypedResponse2(checker, checker.getTypeAtLocation(expression))) {
     return void 0;
   }
   const [dataArg, statusArg] = expression.arguments;
@@ -331,6 +337,7 @@ function extractRouteResponses(program, file) {
     return result;
   }
   const ctx = createWalkContext(checker, fn);
+  const contextName = firstParameterName(fn);
   const byStatus = /* @__PURE__ */ new Map();
   const record = (hit) => {
     const schema = walkType(hit.data, ctx);
@@ -339,7 +346,7 @@ function extractRouteResponses(program, file) {
     byStatus.set(hit.status, bucket);
   };
   for (const expression of collectReturnExpressions(fn)) {
-    const fromCall = readFromCall(checker, expression);
+    const fromCall = readFromCall(checker, expression, contextName);
     if (fromCall) {
       record(fromCall);
       continue;
@@ -365,11 +372,11 @@ function extractRouteResponses(program, file) {
   result.$defs = ctx.defs;
   return result;
 }
-var import_typescript3;
+var import_typescript4;
 var init_responses = __esm({
   "src/generator/schema/responses.ts"() {
     "use strict";
-    import_typescript3 = __toESM(require("typescript"));
+    import_typescript4 = __toESM(require("typescript"));
     init_json_schema();
   }
 });
@@ -425,6 +432,21 @@ var bodySchemaBrand = /* @__PURE__ */ Symbol.for("giri.body-schema");
 
 // src/context.ts
 var BODYLESS_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+var pendingResponseBrand = /* @__PURE__ */ Symbol("giri.pending-response");
+function getPending(context) {
+  return context[pendingResponseBrand];
+}
+var unsupportedCookieJar = {
+  get: cookiesUnsupported,
+  all: cookiesUnsupported,
+  set: cookiesUnsupported,
+  delete: cookiesUnsupported,
+  getSigned: cookiesUnsupported,
+  setSigned: cookiesUnsupported
+};
+function cookiesUnsupported() {
+  throw new Error("The active adapter does not support cookies.");
+}
 function createTypedResponse(data, status, format, headers) {
   return {
     [typedResponseBrand]: { data, status, format },
@@ -441,6 +463,13 @@ function createContext(options) {
   const url = new URL(options.request.url);
   const store = /* @__PURE__ */ new Map();
   const validated = options.validated ?? {};
+  const pending = { headers: new Headers() };
+  const defaultStatus = () => pending.status ?? 200;
+  const cookies = options.cookies ? options.cookies({
+    request: options.request,
+    append: (header) => pending.headers.append("set-cookie", header),
+    secret: options.cookieSecret
+  }) : unsupportedCookieJar;
   const context = {
     params: options.params ?? {},
     app: options.app ?? {},
@@ -458,16 +487,45 @@ function createContext(options) {
           throw new Error(`No validated ${String(key)} data is available for this route.`);
         }
         return validated[key];
-      }
+      },
+      cookie: (name) => cookies.get(name),
+      cookies: () => cookies.all(),
+      signedCookie: (name) => cookies.getSigned(name)
     },
     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)
+    json: (data, status, headers) => createTypedResponse(data, status ?? defaultStatus(), "json", headers),
+    text: (text, status, headers) => createTypedResponse(text, status ?? defaultStatus(), "text", headers),
+    html: (html, status, headers) => createTypedResponse(html, status ?? defaultStatus(), "html", headers),
+    body: (data, status, headers) => new Response(data, { status: status ?? defaultStatus(), headers }),
+    newResponse: (data, status, headers) => new Response(data, { status: status ?? defaultStatus(), headers }),
+    redirect: (location, status) => new Response(null, { status: status ?? 302, headers: { Location: location } }),
+    notFound: () => new Response("404 Not Found", { status: 404 }),
+    header: (name, value, options2) => {
+      if (value === void 0) {
+        pending.headers.delete(name);
+      } else if (options2?.append) {
+        pending.headers.append(name, value);
+      } else {
+        pending.headers.set(name, value);
+      }
+    },
+    status: (code) => {
+      pending.status = code;
+    },
+    cookie: (name, value, options2) => {
+      if (value === null) {
+        cookies.delete(name, options2);
+      } else {
+        cookies.set(name, value, options2);
+      }
+    },
+    signedCookie: (name, value, options2) => cookies.setSigned(name, value, options2)
   };
   context[nativeContextBrand] = options.native;
+  context[pendingResponseBrand] = pending;
   return context;
 }
 function typedResponseToResponse(response) {
@@ -478,14 +536,41 @@ function typedResponseToResponse(response) {
   if (response.format === "text" && !headers.has("content-type")) {
     headers.set("content-type", "text/plain; charset=utf-8");
   }
+  if (response.format === "html" && !headers.has("content-type")) {
+    headers.set("content-type", "text/html; 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;
+function toResponse(response, context) {
+  const base = isTypedResponse(response) ? typedResponseToResponse(response) : response;
+  const pending = context ? getPending(context) : void 0;
+  if (!pending) {
+    return base;
+  }
+  let hasPending = false;
+  pending.headers.forEach(() => {
+    hasPending = true;
+  });
+  if (!hasPending) {
+    return base;
+  }
+  const headers = new Headers(base.headers);
+  pending.headers.forEach((value, key) => {
+    if (key === "set-cookie") {
+      return;
+    }
+    if (!headers.has(key)) {
+      headers.set(key, value);
+    }
+  });
+  for (const cookie of pending.headers.getSetCookie?.() ?? []) {
+    headers.append("set-cookie", cookie);
+  }
+  return new Response(base.body, { status: base.status, statusText: base.statusText, headers });
 }
 async function composeMiddleware(middleware, handle, context) {
   let index = -1;
@@ -686,7 +771,8 @@ var configSchema = 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())
+  errorSchema: import_typebox.Type.Optional(import_typebox.Type.Any()),
+  cookieSecret: import_typebox.Type.Optional(import_typebox.Type.String())
 }, { additionalProperties: false });
 
 // src/loader/loader.ts
@@ -748,13 +834,18 @@ function methodFromFile(fileName) {
   const stem = fileName.replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "").toLowerCase();
   return METHOD_FROM_FILE.get(stem);
 }
-function sharedFileIn(dir) {
+function sharedFileIn(dir, cache) {
+  if (cache?.has(dir)) {
+    return cache.get(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)) {
+      cache?.set(dir, file);
       return file;
     }
   }
+  cache?.set(dir, void 0);
   return void 0;
 }
 function physicalRouteSegments(routesDir, routeDir) {
@@ -823,7 +914,7 @@ async function scanRouteFolders(routesDir) {
 function routeParamsForDir(routesDir, dir) {
   return pathFromSegments(physicalRouteSegments(routesDir, dir)).params;
 }
-function sharedFilesForDir(routesDir, dir) {
+function sharedFilesForDir(routesDir, dir, cache) {
   const segments = physicalRouteSegments(routesDir, dir);
   const dirs = [routesDir];
   let current = routesDir;
@@ -831,7 +922,7 @@ function sharedFilesForDir(routesDir, dir) {
     current = (0, import_node_path2.join)(current, segment);
     dirs.push(current);
   }
-  return dirs.map(sharedFileIn).filter((file) => Boolean(file));
+  return dirs.map((currentDir) => sharedFileIn(currentDir, cache)).filter((file) => Boolean(file));
 }
 async function scanRoutes(routesDir) {
   if (!(0, import_node_fs2.existsSync)(routesDir)) {
@@ -843,6 +934,7 @@ async function scanRoutes(routesDir) {
     onlyFiles: true
   });
   const routes = [];
+  const sharedCache = /* @__PURE__ */ new Map();
   for (const file of files) {
     const method = methodFromFile((0, import_node_path2.basename)(file));
     if (!method) {
@@ -858,7 +950,7 @@ async function scanRoutes(routesDir) {
       routeDir,
       routeSegments,
       params,
-      sharedFiles: sharedFilesForDir(routesDir, routeDir)
+      sharedFiles: sharedFilesForDir(routesDir, routeDir, sharedCache)
     });
   }
   return routes.sort((left, right) => {
@@ -871,9 +963,11 @@ async function scanRoutes(routesDir) {
 }
 
 // src/app.ts
-function loadModule(file) {
+function loadModule(file, force = true) {
   const resolved = require.resolve(file);
-  delete require.cache[resolved];
+  if (force) {
+    delete require.cache[resolved];
+  }
   return require(resolved);
 }
 function interopDefault(value) {
@@ -935,20 +1029,13 @@ function resolveAliasTarget(cwd, target, capture = "") {
 }
 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);
+    const [prefix, suffix = ""] = key.split("*");
+    if (request.startsWith(prefix) && request.endsWith(suffix)) {
+      return request.slice(prefix.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;
+  return request === key ? "" : void 0;
 }
 function resolveAliasRequest(request, alias, cwd) {
   for (const [key, value] of Object.entries(alias ?? {})) {
@@ -1012,38 +1099,78 @@ async function buildGiriApp(config, options = {}) {
   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);
+  if (options.lazy && (!options.loaderRegistered || !options.aliasResolverRegistered)) {
+    throw new Error("Lazy route loading requires persistent loader and alias registrations.");
+  }
+  const loader = options.loaderRegistered ? void 0 : await safeRegister();
+  const unregisterAliasResolver = options.aliasResolverRegistered ? void 0 : registerAliasResolver(config.alias, paths.cwd);
   try {
-    for (const route of routes) {
-      const routeModule = loadModule(route.file);
+    const dirty = options.dirty;
+    const forceReload = dirty === void 0;
+    const isDirty = (file) => forceReload || dirty.has(file);
+    const sharedCache = /* @__PURE__ */ new Map();
+    const loadShared = (file) => {
+      if (!sharedCache.has(file)) {
+        sharedCache.set(file, loadModule(file, isDirty(file)));
+      }
+      return sharedCache.get(file);
+    };
+    const runtimeFor = (route) => {
+      const routeModule = loadModule(route.file, isDirty(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)
+        (file) => normalizeMiddleware(loadShared(file).middleware, file)
       );
       const verbMiddleware = normalizeMiddleware(routeModule.middleware, route.file);
-      config.adapter.register(app, {
+      return {
         method: route.method,
         path: route.path,
         handle: routeModule.handle,
         middleware: [...folderMiddleware, ...verbMiddleware],
         input: routeInput(routeModule, route.file),
-        services: options.services
+        services: options.services,
+        cookieSecret: config.cookieSecret
+      };
+    };
+    for (const route of routes) {
+      if (!options.lazy) {
+        config.adapter.register(app, runtimeFor(route));
+        continue;
+      }
+      let runtime;
+      const getRuntime = () => {
+        runtime ??= runtimeFor(route);
+        return runtime;
+      };
+      config.adapter.register(app, {
+        method: route.method,
+        path: route.path,
+        get handle() {
+          return getRuntime().handle;
+        },
+        get middleware() {
+          return getRuntime().middleware;
+        },
+        get input() {
+          return getRuntime().input;
+        },
+        services: options.services,
+        cookieSecret: config.cookieSecret
       });
     }
   } finally {
-    unregisterAliasResolver();
-    unregister();
+    unregisterAliasResolver?.();
+    loader?.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");
+var import_node_fs8 = require("fs");
+var import_promises4 = require("fs/promises");
+var import_node_path12 = require("path");
 
 // src/generator/app-types.ts
 var import_node_fs4 = require("fs");
@@ -1295,6 +1422,7 @@ function buildOpenApiDocument(paths, routes, data = {}) {
   const documentPaths = {};
   const schemas = {};
   const securitySchemes = {};
+  const tagOrder = [];
   for (const route of routes) {
     if (data.hiddenFiles?.has(route.file)) {
       continue;
@@ -1302,10 +1430,32 @@ function buildOpenApiDocument(paths, routes, data = {}) {
     const responses = data.responsesByFile?.get(route.file);
     const input = data.inputsByFile?.get(route.file);
     const security = data.securityByFile?.get(route.file);
+    const meta = data.openapiByFile?.get(route.file);
     for (const [name, schema] of Object.entries(responses?.$defs ?? {})) {
       schemas[name] = rewriteRefs(schema);
     }
-    const operation = { responses: buildResponses(responses?.responses ?? []) };
+    const operation = {};
+    if (meta?.tags && meta.tags.length > 0) {
+      operation.tags = meta.tags;
+      for (const tag of meta.tags) {
+        if (!tagOrder.includes(tag)) {
+          tagOrder.push(tag);
+        }
+      }
+    }
+    if (meta?.summary) {
+      operation.summary = meta.summary;
+    }
+    if (meta?.description) {
+      operation.description = meta.description;
+    }
+    if (meta?.operationId) {
+      operation.operationId = meta.operationId;
+    }
+    if (meta?.deprecated) {
+      operation.deprecated = true;
+    }
+    operation.responses = buildResponses(responses?.responses ?? []);
     const parameters = [...pathParameters(route), ...queryParameters(input?.query)];
     if (parameters.length > 0) {
       operation.parameters = parameters;
@@ -1337,6 +1487,9 @@ function buildOpenApiDocument(paths, routes, data = {}) {
     info: readProjectInfo(paths.cwd),
     paths: documentPaths
   };
+  if (tagOrder.length > 0) {
+    document.tags = tagOrder.map((name) => ({ name }));
+  }
   const components = {};
   if (Object.keys(schemas).length > 0) {
     components.schemas = schemas;
@@ -1368,14 +1521,29 @@ function paramsType(params) {
 ${fields}
 }`;
 }
-function varsType(typesDir, sharedFiles) {
-  if (sharedFiles.length === 0) {
-    return "{}";
+function middlewareVarsType(typesDir, sharedFile) {
+  const spec = JSON.stringify(moduleSpecifier(typesDir, sharedFile));
+  return `(typeof import(${spec}) extends { middleware: infer M } ? import("@boon4681/giri").InferStackVars<M> : {})`;
+}
+function ownSharedFile(dir, sharedFiles) {
+  for (let index = sharedFiles.length - 1; index >= 0; index -= 1) {
+    if ((0, import_node_path8.dirname)(sharedFiles[index]) === dir) {
+      return sharedFiles[index];
+    }
   }
-  return sharedFiles.map((file) => {
-    const spec = JSON.stringify(moduleSpecifier(typesDir, file));
-    return `(typeof import(${spec}) extends { middleware: infer M } ? import("@boon4681/giri").InferStackVars<M> : {})`;
-  }).join("\n    & ");
+  return void 0;
+}
+function varsType(paths, file, dir, sharedFiles) {
+  const typesDir = (0, import_node_path8.dirname)(file);
+  const parts = [];
+  if (dir !== paths.routesDir) {
+    parts.push(`import(${JSON.stringify(importPath(file, typeFilePath(paths, (0, import_node_path8.dirname)(dir))))}).Vars`);
+  }
+  const ownShared = ownSharedFile(dir, sharedFiles);
+  if (ownShared) {
+    parts.push(middlewareVarsType(typesDir, ownShared));
+  }
+  return parts.length > 0 ? parts.join("\n    & ") : "{}";
 }
 function methodExports(typesDir, verbs) {
   return verbs.map(({ method, file }) => {
@@ -1386,14 +1554,14 @@ function methodExports(typesDir, verbs) {
   });
 }
 async function writeParamTypes(paths, folders) {
-  for (const { dir, params, sharedFiles, verbs } of folders) {
+  await Promise.all(folders.map(({ dir, params, sharedFiles, verbs }) => {
     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 Vars = ${varsType(paths, file, dir, 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> =',
@@ -1403,10 +1571,14 @@ async function writeParamTypes(paths, folders) {
       lines.push(...methodExports(typesDir, verbs));
     }
     lines.push("");
-    await writeGenerated(file, lines.join("\n"));
-  }
+    return writeGenerated(file, lines.join("\n"));
+  }));
 }
 
+// src/generator/route-meta.ts
+var import_node_fs6 = require("fs");
+var import_typescript = __toESM(require("typescript"));
+
 // src/generator/inputs.ts
 function sanitize(schema) {
   const { $schema, ...rest } = schema;
@@ -1467,28 +1639,315 @@ function readInput(routeModule) {
   }
   return input.body || input.query ? input : void 0;
 }
-function hiddenFrom(value) {
-  if (value === false) {
+function hasExportModifier(node) {
+  return import_typescript.default.canHaveModifiers(node) && (import_typescript.default.getModifiers(node)?.some((modifier) => modifier.kind === import_typescript.default.SyntaxKind.ExportKeyword) ?? false);
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (import_typescript.default.isParenthesizedExpression(current) || import_typescript.default.isAsExpression(current) || import_typescript.default.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function staticBoolean(expression) {
+  const value = unwrapExpression(expression);
+  if (value.kind === import_typescript.default.SyntaxKind.TrueKeyword) {
     return true;
   }
-  if (value === true) {
+  if (value.kind === import_typescript.default.SyntaxKind.FalseKeyword) {
     return false;
   }
-  if (value && typeof value === "object" && "hidden" in value) {
-    return Boolean(value.hidden);
+  return void 0;
+}
+function staticString(expression) {
+  const value = unwrapExpression(expression);
+  return import_typescript.default.isStringLiteralLike(value) ? value.text : void 0;
+}
+function staticStringArray(expression) {
+  const value = unwrapExpression(expression);
+  if (!import_typescript.default.isArrayLiteralExpression(value)) {
+    return void 0;
+  }
+  const strings = [];
+  for (const element of value.elements) {
+    const string = staticString(element);
+    if (string === void 0) {
+      return void 0;
+    }
+    strings.push(string);
+  }
+  return strings;
+}
+function propertyName(name) {
+  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+    return name.text;
   }
   return void 0;
 }
-function collectHidden(route, routeModule, loadShared) {
+function collectImportedNames(source) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of source.statements) {
+    if (!import_typescript.default.isImportDeclaration(statement)) {
+      continue;
+    }
+    const clause = statement.importClause;
+    if (!clause) {
+      continue;
+    }
+    if (clause.name) {
+      names.add(clause.name.text);
+    }
+    const bindings = clause.namedBindings;
+    if (bindings && import_typescript.default.isNamespaceImport(bindings)) {
+      names.add(bindings.name.text);
+    }
+    if (bindings && import_typescript.default.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        names.add(element.name.text);
+      }
+    }
+  }
+  return names;
+}
+function expressionReferencesImportedMiddleware(expression, importedNames) {
+  let found = false;
+  const allowedImportedHelpers = /* @__PURE__ */ new Set(["stack", "fromHono"]);
+  const visit = (node) => {
+    if (found) {
+      return;
+    }
+    if (import_typescript.default.isIdentifier(node) && importedNames.has(node.text) && !allowedImportedHelpers.has(node.text)) {
+      found = true;
+      return;
+    }
+    import_typescript.default.forEachChild(node, visit);
+  };
+  visit(expression);
+  return found;
+}
+function parseStaticOpenApi(expression) {
+  const value = unwrapExpression(expression);
+  const boolean = staticBoolean(value);
+  if (boolean !== void 0) {
+    return boolean;
+  }
+  if (!import_typescript.default.isObjectLiteralExpression(value)) {
+    return void 0;
+  }
+  const openapi = {};
+  for (const property of value.properties) {
+    if (!import_typescript.default.isPropertyAssignment(property)) {
+      return void 0;
+    }
+    const name = propertyName(property.name);
+    if (!name) {
+      return void 0;
+    }
+    if (name === "hidden") {
+      const hidden = staticBoolean(property.initializer);
+      if (hidden === void 0) {
+        return void 0;
+      }
+      openapi.hidden = hidden;
+    } else if (name === "tags") {
+      const tags = staticStringArray(property.initializer);
+      if (!tags) {
+        return void 0;
+      }
+      openapi.tags = tags;
+    } else if (name === "summary" || name === "description" || name === "operationId") {
+      const string = staticString(property.initializer);
+      if (string === void 0) {
+        return void 0;
+      }
+      openapi[name] = string;
+    } else if (name === "deprecated") {
+      const deprecated = staticBoolean(property.initializer);
+      if (deprecated === void 0) {
+        return void 0;
+      }
+      openapi.deprecated = deprecated;
+    } else {
+      return void 0;
+    }
+  }
+  return openapi;
+}
+function readStaticModuleMeta(file) {
+  let source;
+  try {
+    source = import_typescript.default.createSourceFile(file, (0, import_node_fs6.readFileSync)(file, "utf8"), import_typescript.default.ScriptTarget.Latest, true);
+  } catch {
+    return void 0;
+  }
+  const importedNames = collectImportedNames(source);
+  const sourceText = source.getFullText();
+  const canSkipMiddlewareRuntime = !sourceText.includes("defineMiddleware") && !sourceText.includes(".openapi");
+  const meta = { middlewareSecurity: false };
+  for (const statement of source.statements) {
+    if (import_typescript.default.isImportDeclaration(statement) || import_typescript.default.isInterfaceDeclaration(statement) || import_typescript.default.isTypeAliasDeclaration(statement) || import_typescript.default.isEmptyStatement(statement) || !hasExportModifier(statement)) {
+      continue;
+    }
+    if (import_typescript.default.isFunctionDeclaration(statement) && statement.name?.text === "handle") {
+      continue;
+    }
+    if (import_typescript.default.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!import_typescript.default.isIdentifier(declaration.name)) {
+          return void 0;
+        }
+        const name = declaration.name.text;
+        if (name === "openapi") {
+          if (!declaration.initializer) {
+            return void 0;
+          }
+          const openapi = parseStaticOpenApi(declaration.initializer);
+          if (openapi === void 0) {
+            return void 0;
+          }
+          meta.openapi = openapi;
+        } else if (name === "handle") {
+          if (!declaration.initializer || !import_typescript.default.isArrowFunction(declaration.initializer) && !import_typescript.default.isFunctionExpression(declaration.initializer)) {
+            return void 0;
+          }
+          continue;
+        } else if (name === "middleware") {
+          if (!declaration.initializer || !canSkipMiddlewareRuntime || expressionReferencesImportedMiddleware(declaration.initializer, importedNames)) {
+            return void 0;
+          }
+          meta.middlewareSecurity = false;
+          continue;
+        } else {
+          return void 0;
+        }
+      }
+      continue;
+    }
+    return void 0;
+  }
+  return meta;
+}
+function resolveStaticOpenApi(route, routeModule, loadShared) {
   let hidden = false;
+  const tags = [];
+  const meta = {};
+  const apply = (value, isVerb) => {
+    if (value === false) {
+      hidden = true;
+      return;
+    }
+    if (value === true) {
+      hidden = false;
+      return;
+    }
+    if (!value) {
+      return;
+    }
+    if (typeof value.hidden === "boolean") {
+      hidden = value.hidden;
+    }
+    if (value.tags) {
+      tags.push(...value.tags);
+    }
+    if (typeof value.summary === "string") {
+      meta.summary = value.summary;
+    }
+    if (typeof value.description === "string") {
+      meta.description = value.description;
+    }
+    if (typeof value.deprecated === "boolean") {
+      meta.deprecated = value.deprecated;
+    }
+    if (isVerb && typeof value.operationId === "string") {
+      meta.operationId = value.operationId;
+    }
+  };
   for (const file of route.sharedFiles) {
-    const opinion = hiddenFrom(loadShared(file).openapi);
-    if (opinion !== void 0) {
-      hidden = opinion;
+    const shared = loadShared(file);
+    if (!shared) {
+      return void 0;
+    }
+    apply(shared.openapi, false);
+  }
+  apply(routeModule.openapi, true);
+  if (tags.length > 0) {
+    meta.tags = [...new Set(tags)];
+  }
+  return { hidden, meta };
+}
+function extractStaticMeta(route, routeModule, loadShared) {
+  const openapi = resolveStaticOpenApi(route, routeModule, loadShared);
+  if (!openapi) {
+    return void 0;
+  }
+  const meta = {};
+  if (openapi.hidden) {
+    meta.hidden = true;
+  }
+  if (Object.keys(openapi.meta).length > 0) {
+    meta.openapi = openapi.meta;
+  }
+  return meta;
+}
+function extractRuntimeSharedMeta(route, routeModule, loadShared) {
+  const meta = {};
+  const security = collectSecurity(route, {}, loadShared);
+  const { hidden, meta: openapi } = resolveOpenApi(route, { openapi: routeModule.openapi }, loadShared);
+  if (security) {
+    meta.security = security;
+  }
+  if (hidden) {
+    meta.hidden = true;
+  }
+  if (Object.keys(openapi).length > 0) {
+    meta.openapi = openapi;
+  }
+  return meta;
+}
+function resolveOpenApi(route, routeModule, loadShared) {
+  let hidden = false;
+  const tags = [];
+  const meta = {};
+  const apply = (value, isVerb) => {
+    if (value === false) {
+      hidden = true;
+      return;
+    }
+    if (value === true) {
+      hidden = false;
+      return;
+    }
+    if (!value || typeof value !== "object") {
+      return;
+    }
+    const o = value;
+    if ("hidden" in o) {
+      hidden = Boolean(o.hidden);
+    }
+    if (Array.isArray(o.tags)) {
+      tags.push(...o.tags.filter((tag) => typeof tag === "string"));
+    }
+    if (typeof o.summary === "string") {
+      meta.summary = o.summary;
+    }
+    if (typeof o.description === "string") {
+      meta.description = o.description;
+    }
+    if (typeof o.deprecated === "boolean") {
+      meta.deprecated = o.deprecated;
     }
+    if (isVerb && typeof o.operationId === "string") {
+      meta.operationId = o.operationId;
+    }
+  };
+  for (const file of route.sharedFiles) {
+    apply(loadShared(file).openapi, false);
+  }
+  apply(routeModule.openapi, true);
+  if (tags.length > 0) {
+    meta.tags = [...new Set(tags)];
   }
-  const verb = hiddenFrom(routeModule.openapi);
-  return verb ?? hidden;
+  return { hidden, meta };
 }
 function collectSecurity(route, routeModule, loadShared) {
   const skipInherited = Boolean(
@@ -1520,6 +1979,33 @@ function collectSecurity(route, routeModule, loadShared) {
 }
 async function extractRouteMeta(config, paths, routes) {
   const byFile = /* @__PURE__ */ new Map();
+  const remainingRoutes = [];
+  const runtimeSharedRoutes = [];
+  const staticCache = /* @__PURE__ */ new Map();
+  const loadStatic = (file) => {
+    if (!staticCache.has(file)) {
+      staticCache.set(file, readStaticModuleMeta(file));
+    }
+    return staticCache.get(file);
+  };
+  for (const route of routes) {
+    const routeModule = loadStatic(route.file);
+    if (!routeModule) {
+      remainingRoutes.push(route);
+      continue;
+    }
+    const meta = extractStaticMeta(route, routeModule, loadStatic);
+    if (meta) {
+      if (meta.hidden || meta.openapi) {
+        byFile.set(route.file, meta);
+      }
+      continue;
+    }
+    runtimeSharedRoutes.push({ route, routeModule });
+  }
+  if (remainingRoutes.length === 0 && runtimeSharedRoutes.length === 0) {
+    return byFile;
+  }
   const { unregister } = await safeRegister();
   const unregisterAlias = registerAliasResolver(config.alias, paths.cwd);
   const sharedCache = /* @__PURE__ */ new Map();
@@ -1534,13 +2020,19 @@ async function extractRouteMeta(config, paths, routes) {
     return sharedCache.get(file);
   };
   try {
-    for (const route of routes) {
+    for (const { route, routeModule } of runtimeSharedRoutes) {
+      const meta = extractRuntimeSharedMeta(route, routeModule, loadShared);
+      if (meta.input || meta.security || meta.hidden || meta.openapi) {
+        byFile.set(route.file, meta);
+      }
+    }
+    for (const route of remainingRoutes) {
       try {
         const routeModule = loadModule2(route.file);
         const meta = {};
         const input = readInput(routeModule);
         const security = collectSecurity(route, routeModule, loadShared);
-        const hidden = collectHidden(route, routeModule, loadShared);
+        const { hidden, meta: openapi } = resolveOpenApi(route, routeModule, loadShared);
         if (input) {
           meta.input = input;
         }
@@ -1550,7 +2042,10 @@ async function extractRouteMeta(config, paths, routes) {
         if (hidden) {
           meta.hidden = true;
         }
-        if (meta.input || meta.security || meta.hidden) {
+        if (Object.keys(openapi).length > 0) {
+          meta.openapi = openapi;
+        }
+        if (meta.input || meta.security || meta.hidden || meta.openapi) {
           byFile.set(route.file, meta);
         }
       } catch {
@@ -1622,6 +2117,103 @@ async function writeTsConfig(paths, config) {
   });
 }
 
+// src/generator/cache.ts
+var import_node_crypto = require("crypto");
+var import_node_fs7 = require("fs");
+var import_promises3 = require("fs/promises");
+var import_node_path11 = require("path");
+var import_tinyglobby2 = require("tinyglobby");
+var CACHE_VERSION = 1;
+var SYNC_CACHE_NAME = ".sync-cache.json";
+function stableConfig(config) {
+  const alias = Object.entries(config.alias ?? {}).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, Array.isArray(value) ? [...value] : value]);
+  return { alias, outDir: config.outDir ?? ".giri" };
+}
+async function syncFingerprint(config, paths) {
+  const outRelative = slash((0, import_node_path11.relative)(paths.cwd, paths.outDir));
+  const ignore = ["**/node_modules/**", "**/.git/**"];
+  if (outRelative && !outRelative.startsWith("..")) {
+    ignore.push(`${outRelative}/**`);
+  }
+  const files = await (0, import_tinyglobby2.glob)([
+    "src/**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs,json}",
+    "giri.config.{ts,js,mts,cts,mjs,cjs}",
+    "tsconfig*.json",
+    "package.json",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "bun.lock",
+    "bun.lockb"
+  ], {
+    cwd: paths.cwd,
+    absolute: false,
+    onlyFiles: true,
+    dot: true,
+    ignore
+  });
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(JSON.stringify(stableConfig(config)));
+  for (const file of files.sort()) {
+    hash.update("\0");
+    hash.update(slash(file));
+    hash.update("\0");
+    hash.update(await (0, import_promises3.readFile)((0, import_node_path11.resolve)(paths.cwd, file)));
+  }
+  return hash.digest("hex");
+}
+function cachePath(paths) {
+  return (0, import_node_path11.join)(paths.outDir, SYNC_CACHE_NAME);
+}
+function serializePath(paths, file) {
+  return slash((0, import_node_path11.relative)(paths.cwd, file));
+}
+function deserializePath(paths, file) {
+  return slash((0, import_node_path11.resolve)(paths.cwd, file.split("/").join(import_node_path11.sep)));
+}
+function serializeMap(paths, values) {
+  return [...values].map(([file, value]) => [serializePath(paths, file), value]);
+}
+function deserializeMap(paths, values) {
+  return new Map(values.map(([file, value]) => [deserializePath(paths, file), value]));
+}
+async function readSyncCache(paths, fingerprint) {
+  const file = cachePath(paths);
+  if (!(0, import_node_fs7.existsSync)(file)) {
+    return void 0;
+  }
+  try {
+    const cache = JSON.parse(await (0, import_promises3.readFile)(file, "utf8"));
+    if (cache.version !== CACHE_VERSION || cache.fingerprint !== fingerprint) {
+      return void 0;
+    }
+    return {
+      responsesByFile: deserializeMap(paths, cache.data.responsesByFile),
+      inputsByFile: deserializeMap(paths, cache.data.inputsByFile),
+      securityByFile: deserializeMap(paths, cache.data.securityByFile),
+      hiddenFiles: new Set(cache.data.hiddenFiles.map((entry) => deserializePath(paths, entry))),
+      openapiByFile: deserializeMap(paths, cache.data.openapiByFile)
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function writeSyncCache(paths, fingerprint, data) {
+  const cache = {
+    version: CACHE_VERSION,
+    fingerprint,
+    data: {
+      responsesByFile: serializeMap(paths, data.responsesByFile),
+      inputsByFile: serializeMap(paths, data.inputsByFile),
+      securityByFile: serializeMap(paths, data.securityByFile),
+      hiddenFiles: [...data.hiddenFiles].map((file) => serializePath(paths, file)),
+      openapiByFile: serializeMap(paths, data.openapiByFile)
+    }
+  };
+  await writeJson(cachePath(paths), cache);
+}
+
 // src/generator/sync.ts
 async function typeFolders(paths, routes) {
   const verbsByDir = /* @__PURE__ */ new Map();
@@ -1632,10 +2224,11 @@ async function typeFolders(paths, routes) {
     verbsByDir.set(key, list);
   }
   const dirs = await scanRouteFolders(paths.routesDir);
+  const sharedCache = /* @__PURE__ */ new Map();
   return dirs.map((dir) => ({
     dir,
     params: routeParamsForDir(paths.routesDir, dir),
-    sharedFiles: sharedFilesForDir(paths.routesDir, dir),
+    sharedFiles: sharedFilesForDir(paths.routesDir, dir, sharedCache),
     verbs: verbsByDir.get(slash(dir)) ?? []
   }));
 }
@@ -1647,11 +2240,9 @@ async function extractResponses(paths, routes) {
   try {
     const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
     const files = [...new Set(routes.map((route) => route.file))];
-    const appTypes = (0, import_node_path11.join)(paths.outDir, "types", "app.d.ts");
-    const program = createSchemaProgram2(
-      paths,
-      (0, import_node_fs6.existsSync)(appTypes) ? [...files, appTypes] : files
-    );
+    const appTypes = (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts");
+    const roots = (0, import_node_fs8.existsSync)(appTypes) ? [...files, appTypes] : files;
+    const program = createSchemaProgram2(paths, roots);
     for (const file of files) {
       byFile.set(file, extractRouteResponses2(program, file));
     }
@@ -1664,8 +2255,9 @@ async function extractMeta(config, paths, routes) {
   const inputsByFile = /* @__PURE__ */ new Map();
   const securityByFile = /* @__PURE__ */ new Map();
   const hiddenFiles = /* @__PURE__ */ new Set();
+  const openapiByFile = /* @__PURE__ */ new Map();
   if (routes.length === 0) {
-    return { inputsByFile, securityByFile, hiddenFiles };
+    return { inputsByFile, securityByFile, hiddenFiles, openapiByFile };
   }
   try {
     const meta = await extractRouteMeta(config, paths, routes);
@@ -1679,63 +2271,91 @@ async function extractMeta(config, paths, routes) {
       if (entry.hidden) {
         hiddenFiles.add(file);
       }
+      if (entry.openapi) {
+        openapiByFile.set(file, entry.openapi);
+      }
     }
   } catch (error) {
     console.warn(`giri: skipped input/security generation (${error.message}).`);
   }
-  return { inputsByFile, securityByFile, hiddenFiles };
+  return { inputsByFile, securityByFile, hiddenFiles, openapiByFile };
 }
 async function syncProject(config, options = {}) {
   const paths = resolveGiriPaths(config, options.cwd);
   assertSafeOutDir(paths);
+  const hadOutDir = (0, import_node_fs8.existsSync)(paths.outDir);
   const routes = await scanRoutes(paths.routesDir);
   const folders = await typeFolders(paths, routes);
-  await (0, import_promises3.mkdir)(paths.outDir, { recursive: true });
+  const fingerprint = await syncFingerprint(config, paths);
+  const cached = await readSyncCache(paths, fingerprint);
+  const generatedFiles = [
+    (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
+    (0, import_node_path12.join)(paths.outDir, "manifest.json"),
+    (0, import_node_path12.join)(paths.outDir, "openapi.json"),
+    (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
+    (0, import_node_path12.join)(paths.outDir, "types", "app.d.ts"),
+    ...folders.map((folder) => typeFilePath(paths, folder.dir))
+  ];
+  if (cached && generatedFiles.every(import_node_fs8.existsSync)) {
+    return { paths, routes, folders, data: cached };
+  }
+  await (0, import_promises4.mkdir)(paths.outDir, { recursive: true });
   await writeParamTypes(paths, folders);
   await writeRouteTypes(paths, routes);
   await writeAppTypes(paths);
   await writeTsConfig(paths, config);
-  const responsesByFile = await extractResponses(paths, routes);
-  const { inputsByFile, securityByFile, hiddenFiles } = await extractMeta(config, paths, routes);
-  const data = { responsesByFile, inputsByFile, securityByFile, hiddenFiles };
+  const data = cached ?? {
+    responsesByFile: await extractResponses(paths, routes),
+    ...await extractMeta(config, paths, routes)
+  };
   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))
-    ])
-  );
+  await writeSyncCache(paths, fingerprint, data);
+  if (hadOutDir) {
+    await pruneDir(
+      paths.outDir,
+      /* @__PURE__ */ new Set([
+        (0, import_node_path12.join)(paths.outDir, "tsconfig.json"),
+        (0, import_node_path12.join)(paths.outDir, "manifest.json"),
+        (0, import_node_path12.join)(paths.outDir, "openapi.json"),
+        (0, import_node_path12.join)(paths.outDir, "routes.d.ts"),
+        (0, import_node_path12.join)(paths.outDir, SYNC_CACHE_NAME),
+        (0, import_node_path12.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_fs10 = require("fs");
+var import_node_path15 = require("path");
+
+// src/loader/import-graph.ts
+var import_node_fs9 = require("fs");
 var import_node_path13 = require("path");
+var import_typescript5 = __toESM(require("typescript"));
+var import_tinyglobby3 = require("tinyglobby");
 
 // src/loader/module-loader.ts
-var import_node_path12 = require("path");
+var import_node_path14 = require("path");
 
 // src/lifecycle.ts
-var import_node_fs8 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path16 = 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)) {
+    const file = (0, import_node_path16.join)(cwd, "src", `main.${ext}`);
+    if ((0, import_node_fs11.existsSync)(file)) {
       return file;
     }
   }
   return void 0;
 }
 async function loadLifecycle(cwd = process.cwd()) {
-  const file = resolveMainFile((0, import_node_path14.resolve)(cwd));
+  const file = resolveMainFile((0, import_node_path16.resolve)(cwd));
   if (!file) {
     return {};
   }