@boon4681/giri 0.0.2 → 0.0.3-alpha-2

package/dist/cli.js

@@ -48,10 +48,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_typescript3.default.findConfigFile(paths.cwd, import_typescript3.default.sys.fileExists, "tsconfig.json");
   if (configPath) {
-    const parsed = import_typescript.default.getParsedCommandLineOfConfigFile(configPath, {}, {
-      ...import_typescript.default.sys,
+    const parsed = import_typescript3.default.getParsedCommandLineOfConfigFile(configPath, {}, {
+      ...import_typescript3.default.sys,
       onUnRecoverableConfigFileDiagnostic: () => {
       }
     });
@@ -59,17 +59,17 @@ function createSchemaProgram(paths, routeFiles) {
       options = { ...parsed.options, noEmit: true };
     }
   }
-  return import_typescript.default.createProgram(routeFiles, options);
+  return import_typescript3.default.createProgram(routeFiles, options);
 }
-var import_typescript, DEFAULT_OPTIONS;
+var import_typescript3, DEFAULT_OPTIONS;
 var init_program = __esm({
   "src/generator/schema/program.ts"() {
     "use strict";
-    import_typescript = __toESM(require("typescript"));
+    import_typescript3 = __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_typescript3.default.ScriptTarget.ES2022,
+      module: import_typescript3.default.ModuleKind.NodeNext,
+      moduleResolution: import_typescript3.default.ModuleResolutionKind.NodeNext,
       strict: true,
       skipLibCheck: true,
       noEmit: true
@@ -103,7 +103,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_typescript4.default.TypeFlags.BooleanLiteral) {
       values.push(intrinsicName(member) === "true");
     } else {
       return void 0;
@@ -112,7 +112,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_typescript4.default.TypeFlags.Undefined | import_typescript4.default.TypeFlags.Void | import_typescript4.default.TypeFlags.Never;
   const members = type.types.filter((member) => !(member.flags & flag));
   if (members.length === 1) {
     return walkType(members[0], ctx);
@@ -125,13 +125,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_typescript4.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript4.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_typescript4.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript4.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript4.default.TypeFlags.Undefined));
     properties[name] = walkType(propType, ctx);
     if (!optional) {
       required.push(name);
@@ -190,16 +190,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_typescript4.default.TypeFlags.Any | import_typescript4.default.TypeFlags.Unknown)) {
     return {};
   }
-  if (flags & import_typescript2.default.TypeFlags.Null) {
+  if (flags & import_typescript4.default.TypeFlags.Null) {
     return { type: "null" };
   }
-  if (flags & (import_typescript2.default.TypeFlags.Undefined | import_typescript2.default.TypeFlags.Void)) {
+  if (flags & (import_typescript4.default.TypeFlags.Undefined | import_typescript4.default.TypeFlags.Void)) {
     return {};
   }
-  if (flags & (import_typescript2.default.TypeFlags.BigInt | import_typescript2.default.TypeFlags.BigIntLiteral)) {
+  if (flags & (import_typescript4.default.TypeFlags.BigInt | import_typescript4.default.TypeFlags.BigIntLiteral)) {
     ctx.warnings.push("bigint is not JSON-serializable (JSON.stringify throws); documented as string.");
     return { type: "string" };
   }
@@ -209,45 +209,45 @@ function walkType(type, ctx) {
   if (type.isNumberLiteral()) {
     return { type: "number", const: type.value };
   }
-  if (flags & import_typescript2.default.TypeFlags.BooleanLiteral) {
+  if (flags & import_typescript4.default.TypeFlags.BooleanLiteral) {
     return { type: "boolean", const: intrinsicName(type) === "true" };
   }
-  if (flags & import_typescript2.default.TypeFlags.String) {
+  if (flags & import_typescript4.default.TypeFlags.String) {
     return { type: "string" };
   }
-  if (flags & import_typescript2.default.TypeFlags.Number) {
+  if (flags & import_typescript4.default.TypeFlags.Number) {
     return { type: "number" };
   }
-  if (flags & import_typescript2.default.TypeFlags.Boolean) {
+  if (flags & import_typescript4.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_typescript4.default.TypeFlags.Object || type.isIntersection()) {
     return walkObject(type, ctx);
   }
   return {};
 }
-var import_typescript2;
+var import_typescript4;
 var init_json_schema = __esm({
   "src/generator/schema/json-schema.ts"() {
     "use strict";
-    import_typescript2 = __toESM(require("typescript"));
+    import_typescript4 = __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_typescript5.default.canHaveModifiers(node) && (import_typescript5.default.getModifiers(node)?.some((m) => m.kind === import_typescript5.default.SyntaxKind.ExportKeyword) ?? false);
   for (const statement of source.statements) {
-    if (import_typescript3.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
+    if (import_typescript5.default.isFunctionDeclaration(statement) && statement.name?.text === "handle" && isExported(statement)) {
       found = statement;
     }
-    if (import_typescript3.default.isVariableStatement(statement) && isExported(statement)) {
+    if (import_typescript5.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_typescript5.default.isIdentifier(declaration.name) && declaration.name.text === "handle" && declaration.initializer && (import_typescript5.default.isArrowFunction(declaration.initializer) || import_typescript5.default.isFunctionExpression(declaration.initializer))) {
           found = declaration.initializer;
         }
       }
@@ -256,7 +256,7 @@ function findHandleFunction(source) {
   return found;
 }
 function collectReturnExpressions(fn) {
-  if (import_typescript3.default.isArrowFunction(fn) && !import_typescript3.default.isBlock(fn.body)) {
+  if (import_typescript5.default.isArrowFunction(fn) && !import_typescript5.default.isBlock(fn.body)) {
     return [fn.body];
   }
   if (!fn.body) {
@@ -264,15 +264,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_typescript5.default.isFunctionDeclaration(node) || import_typescript5.default.isFunctionExpression(node) || import_typescript5.default.isArrowFunction(node)) {
       return;
     }
-    if (import_typescript3.default.isReturnStatement(node) && node.expression) {
+    if (import_typescript5.default.isReturnStatement(node) && node.expression) {
       expressions.push(node.expression);
     }
-    import_typescript3.default.forEachChild(node, visit);
+    import_typescript5.default.forEachChild(node, visit);
   };
-  import_typescript3.default.forEachChild(fn.body, visit);
+  import_typescript5.default.forEachChild(fn.body, visit);
   return expressions;
 }
 function propertyType(checker, type, name, location) {
@@ -284,15 +284,21 @@ function isTypedResponse(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_typescript5.default.isIdentifier(first.name) ? first.name.text : void 0;
+}
+function readFromCall(checker, expression, contextName) {
+  if (!import_typescript5.default.isCallExpression(expression) || !import_typescript5.default.isPropertyAccessExpression(expression.expression)) {
     return void 0;
   }
   const method = expression.expression.name.text;
   if (method !== "json" && method !== "text") {
     return void 0;
   }
-  if (!isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
+  const target = expression.expression.expression;
+  const directContextCall = contextName && import_typescript5.default.isIdentifier(target) && target.text === contextName;
+  if (!directContextCall && !isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
     return void 0;
   }
   const [dataArg, statusArg] = expression.arguments;
@@ -332,6 +338,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);
@@ -340,7 +347,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;
@@ -366,11 +373,11 @@ function extractRouteResponses(program, file) {
   result.$defs = ctx.defs;
   return result;
 }
-var import_typescript3;
+var import_typescript5;
 var init_responses = __esm({
   "src/generator/schema/responses.ts"() {
     "use strict";
-    import_typescript3 = __toESM(require("typescript"));
+    import_typescript5 = __toESM(require("typescript"));
     init_json_schema();
   }
 });
@@ -394,9 +401,9 @@ var init_schema = __esm({
 
 // src/cli.ts
 var import_node_child_process = require("child_process");
-var import_node_fs9 = require("fs");
-var import_promises4 = require("fs/promises");
-var import_node_path15 = require("path");
+var import_node_fs12 = require("fs");
+var import_promises5 = require("fs/promises");
+var import_node_path17 = require("path");
 var prompts = __toESM(require("@clack/prompts"));
 
 // src/app.ts
@@ -422,7 +429,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
@@ -461,29 +469,44 @@ var safeRegister = async () => {
   await assertES5(res.unregister);
   return res;
 };
-var load = async () => {
-  const defaultTsConfigExists = (0, import_node_fs.existsSync)((0, import_node_path.resolve)("giri.config.ts"));
-  const defaultJsConfigExists = (0, import_node_fs.existsSync)((0, import_node_path.resolve)("giri.config.js"));
-  const defaultConfigPath = defaultTsConfigExists ? "giri.config.ts" : defaultJsConfigExists ? "giri.config.js" : void 0;
-  if (!defaultConfigPath) {
-    import_prompts.log.error("Config file not found.");
-    (0, import_node_process.exit)(1);
+var findConfigPath = (cwd = (0, import_node_path.resolve)()) => {
+  for (const name of ["giri.config.ts", "giri.config.js"]) {
+    const path = (0, import_node_path.resolve)(cwd, name);
+    if ((0, import_node_fs.existsSync)(path)) {
+      return path;
+    }
   }
-  const path = (0, import_node_path.resolve)(defaultConfigPath);
-  if (!(0, import_node_fs.existsSync)(path)) {
-    import_prompts.log.error(`${path} file does not exist`);
+  return void 0;
+};
+var load = async (opts = {}) => {
+  const fail = (message) => {
+    if (opts.throwOnError) {
+      throw new Error(message);
+    }
+    import_prompts.log.error(message);
     (0, import_node_process.exit)(1);
+  };
+  const path = findConfigPath();
+  if (!path) {
+    fail("Config file not found.");
   }
   const { unregister } = await safeRegister();
-  const required = require(`${path}`);
-  const content = required.default ?? required;
+  let content;
+  try {
+    const required = require(`${path}`);
+    content = required.default ?? required;
+  } finally {
+  }
   unregister();
   const res = import_value.Value.Check(configSchema, content);
   if (!res) {
-    for (const error of [...import_value.Value.Errors(configSchema, content)]) {
-      import_prompts.log.error(error.message);
+    const messages = [...import_value.Value.Errors(configSchema, content)].map((error) => error.message);
+    if (!opts.throwOnError) {
+      for (const message of messages) {
+        import_prompts.log.error(message);
+      }
     }
-    (0, import_node_process.exit)(1);
+    fail(messages.join("\n"));
   }
   return content;
 };
@@ -493,6 +516,7 @@ var import_node_fs2 = require("fs");
 var import_promises = require("fs/promises");
 var import_node_path2 = require("path");
 var import_tinyglobby = require("tinyglobby");
+var import_typescript = __toESM(require("typescript"));
 var METHOD_ORDER = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"];
 var METHOD_FROM_FILE = new Map(
   METHOD_ORDER.map((method) => [`+${method.toLowerCase()}`, method])
@@ -510,13 +534,129 @@ function methodFromFile(fileName) {
   const stem = fileName.replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "").toLowerCase();
   return METHOD_FROM_FILE.get(stem);
 }
-function sharedFileIn(dir) {
+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 hasDeclareModifier(node) {
+  return import_typescript.default.canHaveModifiers(node) && (import_typescript.default.getModifiers(node)?.some((modifier) => modifier.kind === import_typescript.default.SyntaxKind.DeclareKeyword) ?? false);
+}
+function propertyName(node) {
+  if (import_typescript.default.isIdentifier(node) || import_typescript.default.isStringLiteralLike(node) || import_typescript.default.isNumericLiteral(node)) {
+    return node.text;
+  }
+  if (import_typescript.default.isPropertyAccessExpression(node)) {
+    return node.name.text;
+  }
+  if (import_typescript.default.isElementAccessExpression(node) && node.argumentExpression) {
+    const argument = node.argumentExpression;
+    if (import_typescript.default.isStringLiteralLike(argument)) {
+      return argument.text;
+    }
+  }
+  return void 0;
+}
+function isExportsObject(node) {
+  return import_typescript.default.isIdentifier(node) && node.text === "exports";
+}
+function isModuleExports(node) {
+  return import_typescript.default.isPropertyAccessExpression(node) && import_typescript.default.isIdentifier(node.expression) && node.expression.text === "module" && node.name.text === "exports";
+}
+function isCommonJsHandleTarget(node) {
+  if (!import_typescript.default.isPropertyAccessExpression(node) && !import_typescript.default.isElementAccessExpression(node)) {
+    return false;
+  }
+  return propertyName(node) === "handle" && (isExportsObject(node.expression) || isModuleExports(node.expression));
+}
+function objectExportsHandle(node) {
+  if (!import_typescript.default.isObjectLiteralExpression(node)) {
+    return false;
+  }
+  return node.properties.some((property) => {
+    if (import_typescript.default.isShorthandPropertyAssignment(property)) {
+      return property.name.text === "handle";
+    }
+    return (import_typescript.default.isPropertyAssignment(property) || import_typescript.default.isMethodDeclaration(property)) && propertyName(property.name) === "handle";
+  });
+}
+function hasNamedHandleExport(source) {
+  for (const statement of source.statements) {
+    if (hasExportModifier(statement) && !hasDeclareModifier(statement) && import_typescript.default.isFunctionDeclaration(statement) && statement.name?.text === "handle") {
+      return true;
+    }
+    if (hasExportModifier(statement) && !hasDeclareModifier(statement) && import_typescript.default.isVariableStatement(statement)) {
+      if (statement.declarationList.declarations.some(
+        (declaration) => import_typescript.default.isIdentifier(declaration.name) && declaration.name.text === "handle"
+      )) {
+        return true;
+      }
+    }
+    if (import_typescript.default.isExportDeclaration(statement) && !statement.isTypeOnly && statement.exportClause && import_typescript.default.isNamedExports(statement.exportClause)) {
+      if (statement.exportClause.elements.some(
+        (element) => !element.isTypeOnly && element.name.text === "handle"
+      )) {
+        return true;
+      }
+    }
+    if (!import_typescript.default.isExpressionStatement(statement) || !import_typescript.default.isBinaryExpression(statement.expression)) {
+      continue;
+    }
+    const assignment = statement.expression;
+    if (assignment.operatorToken.kind !== import_typescript.default.SyntaxKind.EqualsToken) {
+      continue;
+    }
+    if (isCommonJsHandleTarget(assignment.left) || isModuleExports(assignment.left) && objectExportsHandle(assignment.right)) {
+      return true;
+    }
+  }
+  return false;
+}
+function parseSource(file) {
+  return import_typescript.default.createSourceFile(
+    file,
+    (0, import_node_fs2.readFileSync)(file, "utf8"),
+    import_typescript.default.ScriptTarget.Latest,
+    true
+  );
+}
+function parseDiagnostics(source) {
+  return source.parseDiagnostics ?? [];
+}
+function formatSyntaxDiagnostic(diagnostic) {
+  const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+  const message = import_typescript.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+  return `${diagnostic.file.fileName}:${position.line + 1}:${position.character + 1} - error TS${diagnostic.code}: ${message}`;
+}
+function assertSourceSyntax(file) {
+  if (!/\.(?:[cm]?[jt]s|[jt]sx)$/i.test(file)) {
+    return;
+  }
+  const diagnostics = parseDiagnostics(parseSource(file));
+  if (diagnostics.length > 0) {
+    throw new SyntaxError(diagnostics.map(formatSyntaxDiagnostic).join("\n"));
+  }
+}
+function assertRouteHandleExport(file) {
+  const source = parseSource(file);
+  const diagnostics = parseDiagnostics(source);
+  if (diagnostics.length > 0) {
+    throw new SyntaxError(diagnostics.map(formatSyntaxDiagnostic).join("\n"));
+  }
+  if (!hasNamedHandleExport(source)) {
+    throw new Error(`${file} must export a named handle function.`);
+  }
+}
+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) {
@@ -585,7 +725,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;
@@ -593,7 +733,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)) {
@@ -605,6 +745,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) {
@@ -620,7 +761,7 @@ async function scanRoutes(routesDir) {
       routeDir,
       routeSegments,
       params,
-      sharedFiles: sharedFilesForDir(routesDir, routeDir)
+      sharedFiles: sharedFilesForDir(routesDir, routeDir, sharedCache)
     });
   }
   return routes.sort((left, right) => {
@@ -649,9 +790,11 @@ function isGiriBodySchema(value) {
 }
 
 // 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) {
@@ -713,20 +856,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 ?? {})) {
@@ -788,40 +924,85 @@ function resolveGiriPaths(config, cwd = process.cwd()) {
 async function buildGiriApp(config, options = {}) {
   const paths = resolveGiriPaths(config, options.cwd);
   const routes = await scanRoutes(paths.routesDir);
+  if (options.lazy) {
+    for (const route of routes) {
+      assertRouteHandleExport(route.file);
+    }
+  }
   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");
@@ -1073,6 +1254,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;
@@ -1080,10 +1262,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 tag2 of meta.tags) {
+        if (!tagOrder.includes(tag2)) {
+          tagOrder.push(tag2);
+        }
+      }
+    }
+    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;
@@ -1115,6 +1319,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;
@@ -1146,14 +1353,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 }) => {
@@ -1164,14 +1386,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> =',
@@ -1181,10 +1403,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_typescript2 = __toESM(require("typescript"));
+
 // src/generator/inputs.ts
 function sanitize(schema) {
   const { $schema, ...rest } = schema;
@@ -1245,28 +1471,315 @@ function readInput(routeModule) {
   }
   return input.body || input.query ? input : void 0;
 }
-function hiddenFrom(value) {
-  if (value === false) {
+function hasExportModifier2(node) {
+  return import_typescript2.default.canHaveModifiers(node) && (import_typescript2.default.getModifiers(node)?.some((modifier) => modifier.kind === import_typescript2.default.SyntaxKind.ExportKeyword) ?? false);
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (import_typescript2.default.isParenthesizedExpression(current) || import_typescript2.default.isAsExpression(current) || import_typescript2.default.isSatisfiesExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function staticBoolean(expression) {
+  const value = unwrapExpression(expression);
+  if (value.kind === import_typescript2.default.SyntaxKind.TrueKeyword) {
     return true;
   }
-  if (value === true) {
+  if (value.kind === import_typescript2.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_typescript2.default.isStringLiteralLike(value) ? value.text : void 0;
+}
+function staticStringArray(expression) {
+  const value = unwrapExpression(expression);
+  if (!import_typescript2.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 propertyName2(name) {
+  if (import_typescript2.default.isIdentifier(name) || import_typescript2.default.isStringLiteral(name) || import_typescript2.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_typescript2.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_typescript2.default.isNamespaceImport(bindings)) {
+      names.add(bindings.name.text);
+    }
+    if (bindings && import_typescript2.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_typescript2.default.isIdentifier(node) && importedNames.has(node.text) && !allowedImportedHelpers.has(node.text)) {
+      found = true;
+      return;
+    }
+    import_typescript2.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_typescript2.default.isObjectLiteralExpression(value)) {
+    return void 0;
+  }
+  const openapi = {};
+  for (const property of value.properties) {
+    if (!import_typescript2.default.isPropertyAssignment(property)) {
+      return void 0;
+    }
+    const name = propertyName2(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_typescript2.default.createSourceFile(file, (0, import_node_fs6.readFileSync)(file, "utf8"), import_typescript2.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_typescript2.default.isImportDeclaration(statement) || import_typescript2.default.isInterfaceDeclaration(statement) || import_typescript2.default.isTypeAliasDeclaration(statement) || import_typescript2.default.isEmptyStatement(statement) || !hasExportModifier2(statement)) {
+      continue;
+    }
+    if (import_typescript2.default.isFunctionDeclaration(statement) && statement.name?.text === "handle") {
+      continue;
+    }
+    if (import_typescript2.default.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (!import_typescript2.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_typescript2.default.isArrowFunction(declaration.initializer) && !import_typescript2.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((tag2) => typeof tag2 === "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(
@@ -1298,6 +1811,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();
@@ -1312,13 +1852,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;
         }
@@ -1328,7 +1874,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 {
@@ -1400,6 +1949,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();
@@ -1410,10 +2056,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)) ?? []
   }));
 }
@@ -1425,11 +2072,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));
     }
@@ -1442,8 +2087,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);
@@ -1457,79 +2103,180 @@ 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_path13 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path15 = require("path");
 
-// src/loader/module-loader.ts
-var import_node_path12 = require("path");
-var toSlash = (path) => path.split(import_node_path12.sep).join("/");
-var isProjectModule = (id, root) => {
-  return id.startsWith(root) && !id.includes(`${import_node_path12.sep}node_modules${import_node_path12.sep}`) && !id.includes(`${import_node_path12.sep}.giri${import_node_path12.sep}`);
-};
-var buildModuleGraph = (cwd) => {
-  const root = (0, import_node_path12.resolve)(cwd) + import_node_path12.sep;
+// src/loader/import-graph.ts
+var import_node_fs9 = require("fs");
+var import_node_path13 = require("path");
+var import_typescript6 = __toESM(require("typescript"));
+var import_tinyglobby3 = require("tinyglobby");
+var RESOLVE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+var JS_EXT = /\.(?:c|m)?jsx?$/;
+var toSlash = (path) => path.split(import_node_path13.sep).join("/");
+function probeFile(base) {
+  if ((0, import_node_fs9.existsSync)(base) && (0, import_node_fs9.statSync)(base).isFile()) {
+    return base;
+  }
+  for (const ext of RESOLVE_EXTS) {
+    const candidate = base + ext;
+    if ((0, import_node_fs9.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  for (const ext of RESOLVE_EXTS) {
+    const candidate = (0, import_node_path13.join)(base, `index${ext}`);
+    if ((0, import_node_fs9.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function resolveSpecifier(specifier, fromFile, alias, cwd) {
+  let target;
+  if (specifier.startsWith(".")) {
+    target = (0, import_node_path13.resolve)((0, import_node_path13.dirname)(fromFile), specifier);
+  } else {
+    const aliased = resolveAliasRequest(specifier, alias, cwd);
+    if (aliased === void 0) {
+      return void 0;
+    }
+    target = aliased;
+  }
+  const resolved = probeFile(target);
+  if (resolved) {
+    return resolved;
+  }
+  if (JS_EXT.test(target)) {
+    return probeFile(target.replace(JS_EXT, ""));
+  }
+  return void 0;
+}
+function importSpecifiers(file) {
+  let source;
+  try {
+    source = import_typescript6.default.createSourceFile(file, (0, import_node_fs9.readFileSync)(file, "utf8"), import_typescript6.default.ScriptTarget.Latest, false);
+  } catch {
+    return [];
+  }
+  const specifiers = [];
+  const visit = (node) => {
+    if ((import_typescript6.default.isImportDeclaration(node) || import_typescript6.default.isExportDeclaration(node)) && node.moduleSpecifier && import_typescript6.default.isStringLiteral(node.moduleSpecifier)) {
+      specifiers.push(node.moduleSpecifier.text);
+    } else if (import_typescript6.default.isImportEqualsDeclaration(node) && import_typescript6.default.isExternalModuleReference(node.moduleReference) && import_typescript6.default.isStringLiteralLike(node.moduleReference.expression)) {
+      specifiers.push(node.moduleReference.expression.text);
+    } else if (import_typescript6.default.isCallExpression(node)) {
+      const isRequire = import_typescript6.default.isIdentifier(node.expression) && node.expression.text === "require";
+      const isDynamicImport = node.expression.kind === import_typescript6.default.SyntaxKind.ImportKeyword;
+      const [first] = node.arguments;
+      if ((isRequire || isDynamicImport) && first && import_typescript6.default.isStringLiteralLike(first)) {
+        specifiers.push(first.text);
+      }
+    }
+    import_typescript6.default.forEachChild(node, visit);
+  };
+  visit(source);
+  return specifiers;
+}
+async function buildImportGraph(config, cwd) {
+  const root = (0, import_node_path13.resolve)(cwd);
+  const outDir = (0, import_node_path13.resolve)(root, config.outDir ?? ".giri") + import_node_path13.sep;
+  const outRel = (0, import_node_path13.relative)(root, outDir).split(import_node_path13.sep).join("/").replace(/\/$/, "");
+  const files = await (0, import_tinyglobby3.glob)("**/*.{ts,tsx,mts,cts,js,jsx,mjs,cjs}", {
+    cwd: root,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ["**/node_modules/**", "**/.git/**", outRel ? `${outRel}/**` : ".giri/**"]
+  });
   const importers = /* @__PURE__ */ new Map();
   const nodes = /* @__PURE__ */ new Set();
-  for (const id of Object.keys(require.cache)) {
-    if (!isProjectModule(id, root)) {
-      continue;
-    }
-    const mod = require.cache[id];
-    if (!mod) {
+  for (const file of files) {
+    if (file.startsWith(outDir)) {
       continue;
     }
-    nodes.add(toSlash(id));
-    for (const child of mod.children) {
-      if (!isProjectModule(child.id, root)) {
+    nodes.add(toSlash(file));
+    for (const specifier of importSpecifiers(file)) {
+      const dep = resolveSpecifier(specifier, file, config.alias, root);
+      if (!dep || dep.startsWith(outDir)) {
         continue;
       }
-      nodes.add(toSlash(child.id));
-      const dep = toSlash(child.id);
-      let set = importers.get(dep);
+      const from = toSlash(file);
+      const to = toSlash(dep);
+      nodes.add(to);
+      let set = importers.get(to);
       if (!set) {
         set = /* @__PURE__ */ new Set();
-        importers.set(dep, set);
+        importers.set(to, set);
       }
-      set.add(toSlash(id));
+      set.add(from);
     }
   }
   return { importers, nodes };
+}
+
+// src/loader/module-loader.ts
+var import_node_path14 = require("path");
+var toSlash2 = (path) => path.split(import_node_path14.sep).join("/");
+var isProjectModule = (id, root) => {
+  return id.startsWith(root) && !id.includes(`${import_node_path14.sep}node_modules${import_node_path14.sep}`) && !id.includes(`${import_node_path14.sep}.giri${import_node_path14.sep}`);
 };
 var collectDependents = (graph, start) => {
   const out = /* @__PURE__ */ new Set([start]);
@@ -1547,26 +2294,36 @@ var collectDependents = (graph, start) => {
 };
 var purgeModules = (files) => {
   for (const id of Object.keys(require.cache)) {
-    if (files.has(toSlash(id))) {
+    if (files.has(toSlash2(id))) {
       delete require.cache[id];
     }
   }
 };
 var purgeProjectModules = (cwd) => {
-  const root = (0, import_node_path12.resolve)(cwd) + import_node_path12.sep;
+  const root = (0, import_node_path14.resolve)(cwd) + import_node_path14.sep;
   for (const id of Object.keys(require.cache)) {
     if (isProjectModule(id, root)) {
       delete require.cache[id];
     }
   }
 };
+var purgeGeneratedModules = (outDir) => {
+  const root = (0, import_node_path14.resolve)(outDir) + import_node_path14.sep;
+  for (const id of Object.keys(require.cache)) {
+    if ((0, import_node_path14.resolve)(id).startsWith(root)) {
+      delete require.cache[id];
+    }
+  }
+};
 
 // src/generator/watch.ts
 function createWatchUpdater(config, initial) {
   const paths = initial.paths;
   let routes = initial.routes;
   const data = initial.data;
+  let metadataQueue = Promise.resolve();
   const fullResync = async () => {
+    await metadataQueue;
     purgeProjectModules(paths.cwd);
     const result = await syncProject(config, { cwd: paths.cwd });
     routes = result.routes;
@@ -1574,48 +2331,84 @@ function createWatchUpdater(config, initial) {
     data.inputsByFile = result.data.inputsByFile;
     data.securityByFile = result.data.securityByFile;
     data.hiddenFiles = result.data.hiddenFiles;
+    data.openapiByFile = result.data.openapiByFile;
+    purgeGeneratedModules(paths.outDir);
     return "full";
   };
-  const reextractRoute = async (route) => {
-    const key = route.file;
+  const reextractRoutes = async (affected) => {
+    if (affected.length === 0) {
+      return;
+    }
     try {
       const { createSchemaProgram: createSchemaProgram2, extractRouteResponses: extractRouteResponses2 } = await Promise.resolve().then(() => (init_schema(), schema_exports));
-      const appTypes = (0, import_node_path13.join)(paths.outDir, "types", "app.d.ts");
-      const program = createSchemaProgram2(paths, (0, import_node_fs7.existsSync)(appTypes) ? [key, appTypes] : [key]);
-      data.responsesByFile.set(key, extractRouteResponses2(program, key));
+      const appTypes = (0, import_node_path15.join)(paths.outDir, "types", "app.d.ts");
+      const files = affected.map((route) => route.file);
+      const program = createSchemaProgram2(
+        paths,
+        (0, import_node_fs10.existsSync)(appTypes) ? [...files, appTypes] : files
+      );
+      for (const route of affected) {
+        data.responsesByFile.set(
+          route.file,
+          extractRouteResponses2(program, route.file)
+        );
+      }
     } catch {
     }
     try {
-      const meta = await extractRouteMeta(config, paths, [route]);
-      const entry = meta.get(key);
-      data.inputsByFile.delete(key);
-      data.securityByFile.delete(key);
-      data.hiddenFiles.delete(key);
-      if (entry?.input) {
-        data.inputsByFile.set(key, entry.input);
-      }
-      if (entry?.security) {
-        data.securityByFile.set(key, entry.security);
-      }
-      if (entry?.hidden) {
-        data.hiddenFiles.add(key);
+      const meta = await extractRouteMeta(config, paths, affected);
+      for (const route of affected) {
+        const key = route.file;
+        const entry = meta.get(key);
+        data.inputsByFile.delete(key);
+        data.securityByFile.delete(key);
+        data.hiddenFiles.delete(key);
+        data.openapiByFile.delete(key);
+        if (entry?.input) {
+          data.inputsByFile.set(key, entry.input);
+        }
+        if (entry?.security) {
+          data.securityByFile.set(key, entry.security);
+        }
+        if (entry?.hidden) {
+          data.hiddenFiles.add(key);
+        }
+        if (entry?.openapi) {
+          data.openapiByFile.set(key, entry.openapi);
+        }
       }
     } catch {
     }
   };
   return {
-    async apply(filename) {
+    settled: () => metadataQueue,
+    async apply(filename, options = {}) {
       if (!filename) {
         return fullResync();
       }
-      const abs = (0, import_node_path13.resolve)((0, import_node_path13.dirname)(paths.routesDir), filename);
+      const abs = (0, import_node_path15.resolve)((0, import_node_path15.dirname)(paths.routesDir), filename);
       const file = slash(abs);
-      if (!(0, import_node_fs7.existsSync)(abs)) {
+      if (!(0, import_node_fs10.existsSync)(abs)) {
         return fullResync();
       }
-      const graph = buildModuleGraph(paths.cwd);
+      if ((0, import_node_fs10.statSync)(abs).isDirectory()) {
+        return "skip";
+      }
+      assertSourceSyntax(abs);
       const isRoute = routes.some((candidate) => slash(candidate.file) === file);
-      if (!graph.nodes.has(file) && !isRoute) {
+      const isShared = routes.some(
+        (route) => route.sharedFiles.some((shared) => slash(shared) === file)
+      );
+      const isMethodFile = /^\+(?:get|post|put|patch|delete|options|head)\.(?:[cm]?[jt]s|[jt]sx)$/i.test((0, import_node_path15.basename)(file));
+      const isNewRouteStructure = file.startsWith(`${slash(paths.routesDir)}/`) && /^\+(?:get|post|put|patch|delete|options|head|shared)\.(?:[cm]?[jt]s|[jt]sx)$/i.test((0, import_node_path15.basename)(file)) && !isRoute && !isShared;
+      if (isRoute || isNewRouteStructure && isMethodFile) {
+        assertRouteHandleExport(abs);
+      }
+      if (isNewRouteStructure) {
+        return fullResync();
+      }
+      const graph = await buildImportGraph(config, paths.cwd);
+      if (!graph.nodes.has(file) && !isRoute && !isShared) {
         return fullResync();
       }
       const dependents = collectDependents(graph, file);
@@ -1623,31 +2416,40 @@ function createWatchUpdater(config, initial) {
         (route) => dependents.has(slash(route.file)) || route.sharedFiles.some((shared) => dependents.has(slash(shared)))
       );
       purgeModules(dependents);
-      for (const route of affected) {
-        await reextractRoute(route);
+      const refreshMetadata = async () => {
+        await reextractRoutes(affected);
+        await writeManifest(paths, routes, data);
+        await writeOpenApi(paths, routes, data);
+        await writeSyncCache(paths, await syncFingerprint(config, paths), data);
+        purgeGeneratedModules(paths.outDir);
+      };
+      const task = metadataQueue.then(refreshMetadata);
+      metadataQueue = task.catch((error) => {
+        console.error("giri: deferred metadata update failed", error);
+      });
+      if (!options.deferMetadata) {
+        await task;
       }
-      await writeManifest(paths, routes, data);
-      await writeOpenApi(paths, routes, data);
       return "incremental";
     }
   };
 }
 
 // src/lifecycle.ts
-var import_node_fs8 = require("fs");
-var import_node_path14 = require("path");
+var 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 {};
   }
@@ -1719,6 +2521,12 @@ var tag = {
   warn: color.bold(color.yellow(`[${TAG}]`)),
   error: color.bold(color.red(`[${TAG}]`))
 };
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.stack ?? `${error.name}: ${error.message}`;
+  }
+  return String(error);
+}
 var log2 = {
   info(message, scope) {
     console.log(line(tag.info, message, scope));
@@ -1805,25 +2613,25 @@ function parseFlags(args) {
   return flags;
 }
 async function ensureGitignore(cwd) {
-  const file = (0, import_node_path15.join)(cwd, ".gitignore");
+  const file = (0, import_node_path17.join)(cwd, ".gitignore");
   const entry = ".giri";
-  if (!(0, import_node_fs9.existsSync)(file)) {
-    await (0, import_promises4.writeFile)(file, `${entry}
+  if (!(0, import_node_fs12.existsSync)(file)) {
+    await (0, import_promises5.writeFile)(file, `${entry}
 `);
     return;
   }
-  const content = await (0, import_promises4.readFile)(file, "utf8");
+  const content = await (0, import_promises5.readFile)(file, "utf8");
   if (!content.split(/\r?\n/).includes(entry)) {
-    await (0, import_promises4.appendFile)(file, `${content.endsWith("\n") ? "" : "\n"}${entry}
+    await (0, import_promises5.appendFile)(file, `${content.endsWith("\n") ? "" : "\n"}${entry}
 `);
   }
 }
 async function ensureTsConfig(cwd) {
-  const file = (0, import_node_path15.join)(cwd, "tsconfig.json");
-  if ((0, import_node_fs9.existsSync)(file)) {
+  const file = (0, import_node_path17.join)(cwd, "tsconfig.json");
+  if ((0, import_node_fs12.existsSync)(file)) {
     return;
   }
-  await (0, import_promises4.writeFile)(
+  await (0, import_promises5.writeFile)(
     file,
     `${JSON.stringify(
       {
@@ -1849,7 +2657,7 @@ async function ensureTsConfig(cwd) {
 async function missingDeps(cwd, candidates) {
   let pkg = {};
   try {
-    pkg = JSON.parse(await (0, import_promises4.readFile)((0, import_node_path15.join)(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(await (0, import_promises5.readFile)((0, import_node_path17.join)(cwd, "package.json"), "utf8"));
   } catch {
   }
   const present = /* @__PURE__ */ new Set();
@@ -1918,7 +2726,7 @@ async function selectAdapter(interactive) {
   return ADAPTERS.find((adapter) => adapter.value === picked) ?? null;
 }
 async function initProject(cwd, flags) {
-  if (!(0, import_node_fs9.existsSync)((0, import_node_path15.join)(cwd, "package.json"))) {
+  if (!(0, import_node_fs12.existsSync)((0, import_node_path17.join)(cwd, "package.json"))) {
     throw new Error(
       "No package.json found. Run `giri init` inside an existing project - set one up first (e.g. `npm init -y` and install typescript), then re-run."
     );
@@ -1943,14 +2751,14 @@ async function initProject(cwd, flags) {
     prompts.cancel(`The ${adapter.label} adapter isn't available yet - only Hono ships today.`);
     return;
   }
-  const configPath = (0, import_node_path15.join)(cwd, "giri.config.ts");
-  if (!(0, import_node_fs9.existsSync)(configPath)) {
-    await (0, import_promises4.writeFile)(configPath, configSource(adapter));
+  const configPath = (0, import_node_path17.join)(cwd, "giri.config.ts");
+  if (!(0, import_node_fs12.existsSync)(configPath)) {
+    await (0, import_promises5.writeFile)(configPath, configSource(adapter));
   }
-  const routePath = (0, import_node_path15.join)(cwd, "src", "routes", "+get.ts");
-  if (!(0, import_node_fs9.existsSync)(routePath)) {
-    await (0, import_promises4.mkdir)((0, import_node_path15.join)(cwd, "src", "routes"), { recursive: true });
-    await (0, import_promises4.writeFile)(
+  const routePath = (0, import_node_path17.join)(cwd, "src", "routes", "+get.ts");
+  if (!(0, import_node_fs12.existsSync)(routePath)) {
+    await (0, import_promises5.mkdir)((0, import_node_path17.join)(cwd, "src", "routes"), { recursive: true });
+    await (0, import_promises5.writeFile)(
       routePath,
       [
         'import type { Handle } from "@boon4681/giri";',
@@ -2017,69 +2825,158 @@ function displayHost(address) {
   return address.includes(":") ? `[${address}]` : address;
 }
 async function serveProject(config, flags) {
-  const initial = await syncProject(config);
-  log2.success(
-    `synced ${initial.routes.length} route${initial.routes.length === 1 ? "" : "s"} ${muted(`at ${initial.paths.outDir}`)}`,
-    "sync"
-  );
-  const lifecycle = await loadLifecycle();
-  const services = await runInit(lifecycle);
-  let current = await buildGiriApp(config, { services });
-  const port = flags.port ?? config.server?.port ?? 3e3;
-  const hostname = flags.hostname ?? config.server?.hostname;
-  if (flags.watch) {
-    const srcDir = (0, import_node_path15.resolve)(current.paths.routesDir, "..");
-    if ((0, import_node_fs9.existsSync)(srcDir)) {
-      let timer;
-      let syncing = false;
-      const changed = /* @__PURE__ */ new Set();
-      const { watch } = await import("fs");
-      const updater = createWatchUpdater(config, initial);
-      const hmrCount = /* @__PURE__ */ new Map();
-      const bump = (key) => {
-        const next = (hmrCount.get(key) ?? 0) + 1;
-        hmrCount.set(key, next);
-        return next;
-      };
-      const flush = async () => {
-        if (syncing) {
-          return;
-        }
-        syncing = true;
-        try {
-          while (changed.size > 0) {
-            const batch = [...changed];
-            changed.clear();
-            for (const name of batch) {
-              const outcome = await updater.apply(name || null);
-              const rel = name ? `src/${name.replace(/\\/g, "/")}` : "src";
-              log2.change(outcome === "full" ? "sync" : "update", rel, bump(rel));
+  Error.stackTraceLimit = 30;
+  const { watch } = await import("chokidar");
+  let stop;
+  const boot = async (cfg) => {
+    const closers = [];
+    closers.push(registerAliasResolver(cfg.alias, (0, import_node_path17.resolve)(process.cwd())));
+    const lifecycle = await loadLifecycle();
+    const sync = syncProject(cfg).then((initial2) => {
+      log2.success(
+        `synced ${initial2.routes.length} route${initial2.routes.length === 1 ? "" : "s"} ${muted(`at ${initial2.paths.outDir}`)}`,
+        "sync"
+      );
+      return initial2;
+    });
+    const [initial, services] = await Promise.all([sync, runInit(lifecycle)]);
+    const loader = await safeRegister();
+    closers.push(loader.unregister);
+    let current = await buildGiriApp(cfg, {
+      services,
+      lazy: true,
+      loaderRegistered: true,
+      aliasResolverRegistered: true
+    });
+    const port = flags.port ?? cfg.server?.port ?? 3e3;
+    const hostname = flags.hostname ?? cfg.server?.hostname;
+    if (flags.watch) {
+      const srcDir = (0, import_node_path17.resolve)(current.paths.routesDir, "..");
+      if ((0, import_node_fs12.existsSync)(srcDir)) {
+        let timer;
+        let syncing = false;
+        const changed = /* @__PURE__ */ new Set();
+        const updater = createWatchUpdater(cfg, initial);
+        const hmrCount = /* @__PURE__ */ new Map();
+        const bump = (key) => {
+          const next = (hmrCount.get(key) ?? 0) + 1;
+          hmrCount.set(key, next);
+          return next;
+        };
+        const flush = async () => {
+          if (syncing) {
+            return;
+          }
+          syncing = true;
+          try {
+            while (changed.size > 0) {
+              const batch = [...changed];
+              changed.clear();
+              let rebuild = false;
+              let fullSync = false;
+              const dirtySet = /* @__PURE__ */ new Set();
+              for (const name of batch) {
+                const outcome = await updater.apply(name || null, {
+                  deferMetadata: true
+                });
+                if (outcome === "skip") {
+                  continue;
+                }
+                rebuild = true;
+                if (name) {
+                  dirtySet.add((0, import_node_path17.resolve)(srcDir, name));
+                }
+                const rel = name ? `src/${name.replace(/\\/g, "/")}` : "src";
+                log2.change(outcome === "full" ? "sync" : "update", rel, bump(rel));
+                if (outcome === "full") {
+                  fullSync = true;
+                  break;
+                }
+              }
+              if (rebuild) {
+                current = await buildGiriApp(cfg, {
+                  services,
+                  dirty: fullSync ? void 0 : dirtySet,
+                  lazy: true,
+                  loaderRegistered: true,
+                  aliasResolverRegistered: true
+                });
+              }
             }
-            current = await buildGiriApp(config, { services });
+          } catch (error) {
+            log2.error(formatError(error), "watch");
+          } finally {
+            syncing = false;
           }
-        } catch (error) {
-          log2.error(error instanceof Error ? error.message : String(error), "watch");
-        } finally {
-          syncing = false;
-        }
-        if (changed.size > 0) {
-          void flush();
-        }
-      };
-      watch(srcDir, { recursive: true }, (_event, filename) => {
-        changed.add(filename ? filename.toString() : "");
-        clearTimeout(timer);
-        timer = setTimeout(() => void flush(), 150);
-      });
+          if (changed.size > 0) {
+            void flush();
+          }
+        };
+        const watcher = watch(srcDir, { persistent: true, ignoreInitial: true });
+        const onFileChange = (filename) => {
+          changed.add((0, import_node_path17.isAbsolute)(filename) ? (0, import_node_path17.relative)(srcDir, filename) : filename);
+          clearTimeout(timer);
+          timer = setTimeout(() => void flush(), 150);
+        };
+        watcher.on("change", onFileChange);
+        watcher.on("add", onFileChange);
+        watcher.on("unlink", onFileChange);
+        closers.push(() => {
+          clearTimeout(timer);
+          watcher.close();
+        });
+      }
     }
+    const handler = (request) => cfg.adapter.fetch(current.app, request);
+    const server = cfg.adapter.serve(handler, { port, hostname }, (info) => {
+      log2.ready(`http://${displayHost(info.address)}:${info.port}`);
+    });
+    stop = async () => {
+      for (const close of closers) {
+        await close();
+      }
+      try {
+        await server.close();
+      } catch {
+      }
+      if (lifecycle.teardown) {
+        await lifecycle.teardown(services);
+      }
+    };
+  };
+  await boot(config);
+  const configPath = flags.watch ? findConfigPath((0, import_node_path17.resolve)(process.cwd())) : void 0;
+  if (configPath) {
+    let timer;
+    let restarting = false;
+    const configName = (0, import_node_path17.basename)(configPath);
+    const restart = async () => {
+      if (restarting) {
+        return;
+      }
+      restarting = true;
+      try {
+        log2.info(`${color.green("restart")} ${configName} changed`, "config");
+        delete require.cache[configPath];
+        const next = await load({ throwOnError: true });
+        await stop?.();
+        await boot(next);
+      } catch (error) {
+        log2.error(error instanceof Error ? error.message : String(error), "config");
+        log2.info("kept the previous server running \u2014 fix the config and save again", "config");
+      } finally {
+        restarting = false;
+      }
+    };
+    const configWatcher = watch(configPath, { persistent: true, ignoreInitial: true });
+    configWatcher.on("all", () => {
+      clearTimeout(timer);
+      timer = setTimeout(() => void restart(), 150);
+    });
   }
-  const handler = (request) => config.adapter.fetch(current.app, request);
-  const server = config.adapter.serve(handler, { port, hostname }, (info) => {
-    log2.ready(`http://${displayHost(info.address)}:${info.port}`);
-  });
-  registerShutdown(server, lifecycle, services);
+  registerShutdown(() => stop?.());
 }
-function registerShutdown(server, lifecycle, services) {
+function registerShutdown(cleanup) {
   let shuttingDown = false;
   const shutdown = async () => {
     if (shuttingDown) {
@@ -2087,10 +2984,7 @@ function registerShutdown(server, lifecycle, services) {
     }
     shuttingDown = true;
     try {
-      await server.close();
-      if (lifecycle.teardown) {
-        await lifecycle.teardown(services);
-      }
+      await cleanup();
     } catch (error) {
       log2.error(error instanceof Error ? error.message : String(error));
       process.exitCode = 1;
@@ -2103,7 +2997,7 @@ function registerShutdown(server, lifecycle, services) {
 }
 async function main() {
   const [command = "help", ...args] = process.argv.slice(2);
-  const cwd = (0, import_node_path15.resolve)(process.cwd());
+  const cwd = (0, import_node_path17.resolve)(process.cwd());
   if (command === "help" || command === "--help" || command === "-h") {
     help();
     return;