@boon4681/giri 0.0.3-alpha-1 → 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_typescript2.default.findConfigFile(paths.cwd, import_typescript2.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_typescript2.default.getParsedCommandLineOfConfigFile(configPath, {}, {
-      ...import_typescript2.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_typescript2.default.createProgram(routeFiles, options);
+  return import_typescript3.default.createProgram(routeFiles, options);
 }
-var import_typescript2, DEFAULT_OPTIONS;
+var import_typescript3, DEFAULT_OPTIONS;
 var init_program = __esm({
   "src/generator/schema/program.ts"() {
     "use strict";
-    import_typescript2 = __toESM(require("typescript"));
+    import_typescript3 = __toESM(require("typescript"));
     DEFAULT_OPTIONS = {
-      target: import_typescript2.default.ScriptTarget.ES2022,
-      module: import_typescript2.default.ModuleKind.NodeNext,
-      moduleResolution: import_typescript2.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_typescript3.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_typescript3.default.TypeFlags.Undefined | import_typescript3.default.TypeFlags.Void | import_typescript3.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_typescript3.default.IndexKind.String) ?? checker.getIndexInfoOfType(type, import_typescript3.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_typescript3.default.SymbolFlags.Optional) || Boolean(propType.flags & import_typescript3.default.TypeFlags.Union && propType.types.some((t) => t.flags & import_typescript3.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_typescript3.default.TypeFlags.Any | import_typescript3.default.TypeFlags.Unknown)) {
+  if (flags & (import_typescript4.default.TypeFlags.Any | import_typescript4.default.TypeFlags.Unknown)) {
     return {};
   }
-  if (flags & import_typescript3.default.TypeFlags.Null) {
+  if (flags & import_typescript4.default.TypeFlags.Null) {
     return { type: "null" };
   }
-  if (flags & (import_typescript3.default.TypeFlags.Undefined | import_typescript3.default.TypeFlags.Void)) {
+  if (flags & (import_typescript4.default.TypeFlags.Undefined | import_typescript4.default.TypeFlags.Void)) {
     return {};
   }
-  if (flags & (import_typescript3.default.TypeFlags.BigInt | import_typescript3.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_typescript3.default.TypeFlags.BooleanLiteral) {
+  if (flags & import_typescript4.default.TypeFlags.BooleanLiteral) {
     return { type: "boolean", const: intrinsicName(type) === "true" };
   }
-  if (flags & import_typescript3.default.TypeFlags.String) {
+  if (flags & import_typescript4.default.TypeFlags.String) {
     return { type: "string" };
   }
-  if (flags & import_typescript3.default.TypeFlags.Number) {
+  if (flags & import_typescript4.default.TypeFlags.Number) {
     return { type: "number" };
   }
-  if (flags & import_typescript3.default.TypeFlags.Boolean) {
+  if (flags & import_typescript4.default.TypeFlags.Boolean) {
     return { type: "boolean" };
   }
   if (type.isUnion()) {
     return walkUnion(type, ctx);
   }
-  if (flags & import_typescript3.default.TypeFlags.Object || type.isIntersection()) {
+  if (flags & import_typescript4.default.TypeFlags.Object || type.isIntersection()) {
     return walkObject(type, ctx);
   }
   return {};
 }
-var import_typescript3;
+var import_typescript4;
 var init_json_schema = __esm({
   "src/generator/schema/json-schema.ts"() {
     "use strict";
-    import_typescript3 = __toESM(require("typescript"));
+    import_typescript4 = __toESM(require("typescript"));
   }
 });
 
 // src/generator/schema/responses.ts
 function findHandleFunction(source) {
   let found;
-  const isExported = (node) => import_typescript4.default.canHaveModifiers(node) && (import_typescript4.default.getModifiers(node)?.some((m) => m.kind === import_typescript4.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_typescript4.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_typescript4.default.isVariableStatement(statement) && isExported(statement)) {
+    if (import_typescript5.default.isVariableStatement(statement) && isExported(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        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))) {
+        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_typescript4.default.isArrowFunction(fn) && !import_typescript4.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_typescript4.default.isFunctionDeclaration(node) || import_typescript4.default.isFunctionExpression(node) || import_typescript4.default.isArrowFunction(node)) {
+    if (import_typescript5.default.isFunctionDeclaration(node) || import_typescript5.default.isFunctionExpression(node) || import_typescript5.default.isArrowFunction(node)) {
       return;
     }
-    if (import_typescript4.default.isReturnStatement(node) && node.expression) {
+    if (import_typescript5.default.isReturnStatement(node) && node.expression) {
       expressions.push(node.expression);
     }
-    import_typescript4.default.forEachChild(node, visit);
+    import_typescript5.default.forEachChild(node, visit);
   };
-  import_typescript4.default.forEachChild(fn.body, visit);
+  import_typescript5.default.forEachChild(fn.body, visit);
   return expressions;
 }
 function propertyType(checker, type, name, location) {
@@ -286,10 +286,10 @@ function isTypedResponse(checker, type) {
 }
 function firstParameterName(fn) {
   const [first] = fn.parameters;
-  return first && import_typescript4.default.isIdentifier(first.name) ? first.name.text : void 0;
+  return first && import_typescript5.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)) {
+  if (!import_typescript5.default.isCallExpression(expression) || !import_typescript5.default.isPropertyAccessExpression(expression.expression)) {
     return void 0;
   }
   const method = expression.expression.name.text;
@@ -297,7 +297,7 @@ function readFromCall(checker, expression, contextName) {
     return void 0;
   }
   const target = expression.expression.expression;
-  const directContextCall = contextName && import_typescript4.default.isIdentifier(target) && target.text === contextName;
+  const directContextCall = contextName && import_typescript5.default.isIdentifier(target) && target.text === contextName;
   if (!directContextCall && !isTypedResponse(checker, checker.getTypeAtLocation(expression))) {
     return void 0;
   }
@@ -373,11 +373,11 @@ function extractRouteResponses(program, file) {
   result.$defs = ctx.defs;
   return result;
 }
-var import_typescript4;
+var import_typescript5;
 var init_responses = __esm({
   "src/generator/schema/responses.ts"() {
     "use strict";
-    import_typescript4 = __toESM(require("typescript"));
+    import_typescript5 = __toESM(require("typescript"));
     init_json_schema();
   }
 });
@@ -516,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])
@@ -533,6 +534,117 @@ function methodFromFile(fileName) {
   const stem = fileName.replace(/\.(?:[cm]?[jt]s|[jt]sx)$/, "").toLowerCase();
   return METHOD_FROM_FILE.get(stem);
 }
+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);
@@ -812,6 +924,11 @@ 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);
   if (options.lazy && (!options.loaderRegistered || !options.aliasResolverRegistered)) {
@@ -1292,7 +1409,7 @@ async function writeParamTypes(paths, folders) {
 
 // src/generator/route-meta.ts
 var import_node_fs6 = require("fs");
-var import_typescript = __toESM(require("typescript"));
+var import_typescript2 = __toESM(require("typescript"));
 
 // src/generator/inputs.ts
 function sanitize(schema) {
@@ -1354,33 +1471,33 @@ function readInput(routeModule) {
   }
   return input.body || input.query ? input : void 0;
 }
-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 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_typescript.default.isParenthesizedExpression(current) || import_typescript.default.isAsExpression(current) || import_typescript.default.isSatisfiesExpression(current)) {
+  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_typescript.default.SyntaxKind.TrueKeyword) {
+  if (value.kind === import_typescript2.default.SyntaxKind.TrueKeyword) {
     return true;
   }
-  if (value.kind === import_typescript.default.SyntaxKind.FalseKeyword) {
+  if (value.kind === import_typescript2.default.SyntaxKind.FalseKeyword) {
     return false;
   }
   return void 0;
 }
 function staticString(expression) {
   const value = unwrapExpression(expression);
-  return import_typescript.default.isStringLiteralLike(value) ? value.text : void 0;
+  return import_typescript2.default.isStringLiteralLike(value) ? value.text : void 0;
 }
 function staticStringArray(expression) {
   const value = unwrapExpression(expression);
-  if (!import_typescript.default.isArrayLiteralExpression(value)) {
+  if (!import_typescript2.default.isArrayLiteralExpression(value)) {
     return void 0;
   }
   const strings = [];
@@ -1393,8 +1510,8 @@ function staticStringArray(expression) {
   }
   return strings;
 }
-function propertyName(name) {
-  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
+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;
@@ -1402,7 +1519,7 @@ function propertyName(name) {
 function collectImportedNames(source) {
   const names = /* @__PURE__ */ new Set();
   for (const statement of source.statements) {
-    if (!import_typescript.default.isImportDeclaration(statement)) {
+    if (!import_typescript2.default.isImportDeclaration(statement)) {
       continue;
     }
     const clause = statement.importClause;
@@ -1413,10 +1530,10 @@ function collectImportedNames(source) {
       names.add(clause.name.text);
     }
     const bindings = clause.namedBindings;
-    if (bindings && import_typescript.default.isNamespaceImport(bindings)) {
+    if (bindings && import_typescript2.default.isNamespaceImport(bindings)) {
       names.add(bindings.name.text);
     }
-    if (bindings && import_typescript.default.isNamedImports(bindings)) {
+    if (bindings && import_typescript2.default.isNamedImports(bindings)) {
       for (const element of bindings.elements) {
         names.add(element.name.text);
       }
@@ -1431,11 +1548,11 @@ function expressionReferencesImportedMiddleware(expression, importedNames) {
     if (found) {
       return;
     }
-    if (import_typescript.default.isIdentifier(node) && importedNames.has(node.text) && !allowedImportedHelpers.has(node.text)) {
+    if (import_typescript2.default.isIdentifier(node) && importedNames.has(node.text) && !allowedImportedHelpers.has(node.text)) {
       found = true;
       return;
     }
-    import_typescript.default.forEachChild(node, visit);
+    import_typescript2.default.forEachChild(node, visit);
   };
   visit(expression);
   return found;
@@ -1446,15 +1563,15 @@ function parseStaticOpenApi(expression) {
   if (boolean !== void 0) {
     return boolean;
   }
-  if (!import_typescript.default.isObjectLiteralExpression(value)) {
+  if (!import_typescript2.default.isObjectLiteralExpression(value)) {
     return void 0;
   }
   const openapi = {};
   for (const property of value.properties) {
-    if (!import_typescript.default.isPropertyAssignment(property)) {
+    if (!import_typescript2.default.isPropertyAssignment(property)) {
       return void 0;
     }
-    const name = propertyName(property.name);
+    const name = propertyName2(property.name);
     if (!name) {
       return void 0;
     }
@@ -1491,7 +1608,7 @@ function parseStaticOpenApi(expression) {
 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);
+    source = import_typescript2.default.createSourceFile(file, (0, import_node_fs6.readFileSync)(file, "utf8"), import_typescript2.default.ScriptTarget.Latest, true);
   } catch {
     return void 0;
   }
@@ -1500,15 +1617,15 @@ function readStaticModuleMeta(file) {
   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)) {
+    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_typescript.default.isFunctionDeclaration(statement) && statement.name?.text === "handle") {
+    if (import_typescript2.default.isFunctionDeclaration(statement) && statement.name?.text === "handle") {
       continue;
     }
-    if (import_typescript.default.isVariableStatement(statement)) {
+    if (import_typescript2.default.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!import_typescript.default.isIdentifier(declaration.name)) {
+        if (!import_typescript2.default.isIdentifier(declaration.name)) {
           return void 0;
         }
         const name = declaration.name.text;
@@ -1522,7 +1639,7 @@ function readStaticModuleMeta(file) {
           }
           meta.openapi = openapi;
         } else if (name === "handle") {
-          if (!declaration.initializer || !import_typescript.default.isArrowFunction(declaration.initializer) && !import_typescript.default.isFunctionExpression(declaration.initializer)) {
+          if (!declaration.initializer || !import_typescript2.default.isArrowFunction(declaration.initializer) && !import_typescript2.default.isFunctionExpression(declaration.initializer)) {
             return void 0;
           }
           continue;
@@ -2050,7 +2167,7 @@ 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_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?$/;
@@ -2096,25 +2213,25 @@ function resolveSpecifier(specifier, fromFile, alias, cwd) {
 function importSpecifiers(file) {
   let source;
   try {
-    source = import_typescript5.default.createSourceFile(file, (0, import_node_fs9.readFileSync)(file, "utf8"), import_typescript5.default.ScriptTarget.Latest, false);
+    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_typescript5.default.isImportDeclaration(node) || import_typescript5.default.isExportDeclaration(node)) && node.moduleSpecifier && import_typescript5.default.isStringLiteral(node.moduleSpecifier)) {
+    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_typescript5.default.isImportEqualsDeclaration(node) && import_typescript5.default.isExternalModuleReference(node.moduleReference) && import_typescript5.default.isStringLiteralLike(node.moduleReference.expression)) {
+    } 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_typescript5.default.isCallExpression(node)) {
-      const isRequire = import_typescript5.default.isIdentifier(node.expression) && node.expression.text === "require";
-      const isDynamicImport = node.expression.kind === import_typescript5.default.SyntaxKind.ImportKeyword;
+    } 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_typescript5.default.isStringLiteralLike(first)) {
+      if ((isRequire || isDynamicImport) && first && import_typescript6.default.isStringLiteralLike(first)) {
         specifiers.push(first.text);
       }
     }
-    import_typescript5.default.forEachChild(node, visit);
+    import_typescript6.default.forEachChild(node, visit);
   };
   visit(source);
   return specifiers;
@@ -2135,6 +2252,7 @@ async function buildImportGraph(config, cwd) {
     if (file.startsWith(outDir)) {
       continue;
     }
+    nodes.add(toSlash(file));
     for (const specifier of importSpecifiers(file)) {
       const dep = resolveSpecifier(specifier, file, config.alias, root);
       if (!dep || dep.startsWith(outDir)) {
@@ -2142,7 +2260,6 @@ async function buildImportGraph(config, cwd) {
       }
       const from = toSlash(file);
       const to = toSlash(dep);
-      nodes.add(from);
       nodes.add(to);
       let set = importers.get(to);
       if (!set) {
@@ -2204,7 +2321,9 @@ 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;
@@ -2216,39 +2335,54 @@ function createWatchUpdater(config, initial) {
     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_path15.join)(paths.outDir, "types", "app.d.ts");
-      const program = createSchemaProgram2(paths, (0, import_node_fs10.existsSync)(appTypes) ? [key, appTypes] : [key]);
-      data.responsesByFile.set(key, extractRouteResponses2(program, key));
+      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);
-      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);
+      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();
       }
@@ -2260,9 +2394,21 @@ function createWatchUpdater(config, initial) {
       if ((0, import_node_fs10.statSync)(abs).isDirectory()) {
         return "skip";
       }
-      const graph = await buildImportGraph(config, paths.cwd);
+      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);
@@ -2270,13 +2416,20 @@ 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);
-      await writeSyncCache(paths, await syncFingerprint(config, paths), data);
-      purgeGeneratedModules(paths.outDir);
       return "incremental";
     }
   };
@@ -2368,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));
@@ -2717,7 +2876,9 @@ async function serveProject(config, flags) {
               let fullSync = false;
               const dirtySet = /* @__PURE__ */ new Set();
               for (const name of batch) {
-                const outcome = await updater.apply(name || null);
+                const outcome = await updater.apply(name || null, {
+                  deferMetadata: true
+                });
                 if (outcome === "skip") {
                   continue;
                 }
@@ -2743,7 +2904,7 @@ async function serveProject(config, flags) {
               }
             }
           } catch (error) {
-            log2.error(error instanceof Error ? error.message : String(error), "watch");
+            log2.error(formatError(error), "watch");
           } finally {
             syncing = false;
           }