@boon4681/giri 0.0.3-alpha-1 → 0.0.3-alpha-2

package/dist/index.js

@@ -47,10 +47,10 @@ var init_es5 = __esm({
 // src/generator/schema/program.ts
 function createSchemaProgram(paths, routeFiles) {
   let options = { ...DEFAULT_OPTIONS };
-  const configPath = import_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: () => {
       }
     });
@@ -58,17 +58,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
@@ -102,7 +102,7 @@ function literalValuesOf(types) {
   for (const member of types) {
     if (member.isStringLiteral() || member.isNumberLiteral()) {
       values.push(member.value);
-    } else if (member.flags & import_typescript3.default.TypeFlags.BooleanLiteral) {
+    } else if (member.flags & import_typescript4.default.TypeFlags.BooleanLiteral) {
       values.push(intrinsicName(member) === "true");
     } else {
       return void 0;
@@ -111,7 +111,7 @@ function literalValuesOf(types) {
   return values;
 }
 function walkUnion(type, ctx) {
-  const flag = import_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);
@@ -124,13 +124,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);
@@ -189,16 +189,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" };
   }
@@ -208,45 +208,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;
         }
       }
@@ -255,7 +255,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) {
@@ -263,15 +263,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) {
@@ -285,10 +285,10 @@ function isTypedResponse2(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;
@@ -296,7 +296,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 && !isTypedResponse2(checker, checker.getTypeAtLocation(expression))) {
     return void 0;
   }
@@ -372,11 +372,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();
   }
 });
@@ -817,6 +817,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])
@@ -834,6 +835,108 @@ 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 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);
@@ -1097,6 +1200,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)) {
@@ -1577,7 +1685,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) {
@@ -1639,33 +1747,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 = [];
@@ -1678,8 +1786,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;
@@ -1687,7 +1795,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;
@@ -1698,10 +1806,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);
       }
@@ -1716,11 +1824,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;
@@ -1731,15 +1839,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;
     }
@@ -1776,7 +1884,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;
   }
@@ -1785,15 +1893,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;
@@ -1807,7 +1915,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;
@@ -2335,7 +2443,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");
 
 // src/loader/module-loader.ts