@vertz/compiler 0.0.2

package/dist/index.js

@@ -0,0 +1,2814 @@
+// src/analyzers/app-analyzer.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+
+// src/errors.ts
+function createDiagnostic(options) {
+  return { ...options };
+}
+function createDiagnosticFromLocation(location, options) {
+  return {
+    ...options,
+    file: location.sourceFile,
+    line: location.sourceLine,
+    column: location.sourceColumn
+  };
+}
+function hasErrors(diagnostics) {
+  return diagnostics.some((d) => d.severity === "error");
+}
+function filterBySeverity(diagnostics, severity) {
+  return diagnostics.filter((d) => d.severity === severity);
+}
+function mergeDiagnostics(a, b) {
+  return [...a, ...b];
+}
+
+// src/utils/ast-helpers.ts
+import {
+  SyntaxKind
+} from "ts-morph";
+function matchPropertyAccess(call, objectName, methodName) {
+  const expr = call.getExpression();
+  if (!expr.isKind(SyntaxKind.PropertyAccessExpression))
+    return null;
+  const obj = expr.getExpression();
+  if (!obj.isKind(SyntaxKind.Identifier) || obj.getText() !== objectName || expr.getName() !== methodName) {
+    return null;
+  }
+  return expr;
+}
+function findCallExpressions(file, objectName, methodName) {
+  return file.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => matchPropertyAccess(call, objectName, methodName) !== null);
+}
+function findMethodCallsOnVariable(file, variableName, methodName) {
+  return file.getDescendantsOfKind(SyntaxKind.CallExpression).filter((call) => {
+    const access = matchPropertyAccess(call, variableName, methodName);
+    if (!access)
+      return false;
+    const obj = access.getExpression();
+    return obj.getDefinitionNodes().some((d) => d.isKind(SyntaxKind.VariableDeclaration));
+  });
+}
+function extractObjectLiteral(callExpr, argIndex) {
+  const arg = callExpr.getArguments()[argIndex];
+  if (arg?.isKind(SyntaxKind.ObjectLiteralExpression))
+    return arg;
+  return null;
+}
+function getPropertyValue(obj, key) {
+  for (const prop of obj.getProperties()) {
+    if (prop.isKind(SyntaxKind.PropertyAssignment) && prop.getName() === key) {
+      return prop.getInitializerOrThrow();
+    }
+    if (prop.isKind(SyntaxKind.ShorthandPropertyAssignment) && prop.getName() === key) {
+      return prop.getNameNode();
+    }
+  }
+  return null;
+}
+function getProperties(obj) {
+  const result = [];
+  for (const prop of obj.getProperties()) {
+    if (prop.isKind(SyntaxKind.PropertyAssignment)) {
+      result.push({ name: prop.getName(), value: prop.getInitializerOrThrow() });
+    } else if (prop.isKind(SyntaxKind.ShorthandPropertyAssignment)) {
+      result.push({ name: prop.getName(), value: prop.getNameNode() });
+    }
+  }
+  return result;
+}
+function getStringValue(expr) {
+  if (expr.isKind(SyntaxKind.StringLiteral) || expr.isKind(SyntaxKind.NoSubstitutionTemplateLiteral)) {
+    return expr.getLiteralValue();
+  }
+  return null;
+}
+function getBooleanValue(expr) {
+  if (expr.isKind(SyntaxKind.TrueKeyword))
+    return true;
+  if (expr.isKind(SyntaxKind.FalseKeyword))
+    return false;
+  return null;
+}
+function getNumberValue(expr) {
+  if (expr.isKind(SyntaxKind.NumericLiteral)) {
+    return expr.getLiteralValue();
+  }
+  if (expr.isKind(SyntaxKind.PrefixUnaryExpression)) {
+    const operator = expr.getOperatorToken();
+    const operand = expr.getOperand();
+    if (operand.isKind(SyntaxKind.NumericLiteral)) {
+      if (operator === SyntaxKind.MinusToken)
+        return -operand.getLiteralValue();
+      if (operator === SyntaxKind.PlusToken)
+        return operand.getLiteralValue();
+    }
+  }
+  return null;
+}
+function getArrayElements(expr) {
+  if (expr.isKind(SyntaxKind.ArrayLiteralExpression)) {
+    return expr.getElements();
+  }
+  return [];
+}
+function getVariableNameForCall(callExpr) {
+  const parent = callExpr.getParent();
+  if (parent?.isKind(SyntaxKind.VariableDeclaration)) {
+    return parent.getName();
+  }
+  return null;
+}
+function getSourceLocation(node) {
+  const file = node.getSourceFile();
+  const pos = node.getStart();
+  const { line, column } = file.getLineAndColumnAtPos(pos);
+  return {
+    sourceFile: file.getFilePath(),
+    sourceLine: line,
+    sourceColumn: column
+  };
+}
+
+// src/utils/import-resolver.ts
+function resolveIdentifier(identifier, project) {
+  const importInfo = findImportForIdentifier(identifier);
+  if (!importInfo)
+    return null;
+  const moduleSourceFile = importInfo.importDecl.getModuleSpecifierSourceFile();
+  if (!moduleSourceFile)
+    return null;
+  return resolveExport(moduleSourceFile, importInfo.originalName, project);
+}
+function resolveExport(file, exportName, project) {
+  for (const exportDecl of file.getExportDeclarations()) {
+    const moduleSourceFile = exportDecl.getModuleSpecifierSourceFile();
+    if (!moduleSourceFile)
+      continue;
+    for (const named of exportDecl.getNamedExports()) {
+      const name = named.getAliasNode()?.getText() ?? named.getName();
+      if (name === exportName) {
+        return resolveExport(moduleSourceFile, named.getName(), project);
+      }
+    }
+  }
+  const exportedDecls = file.getExportedDeclarations().get(exportName);
+  if (exportedDecls && exportedDecls.length > 0) {
+    const decl = exportedDecls.at(0);
+    if (!decl)
+      return null;
+    return {
+      declaration: decl,
+      sourceFile: decl.getSourceFile(),
+      exportName
+    };
+  }
+  return null;
+}
+function isFromImport(identifier, moduleSpecifier) {
+  const importInfo = findImportForIdentifier(identifier);
+  if (!importInfo)
+    return false;
+  return importInfo.importDecl.getModuleSpecifierValue() === moduleSpecifier;
+}
+function findImportForIdentifier(identifier) {
+  const sourceFile = identifier.getSourceFile();
+  const name = identifier.getText();
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    for (const specifier of importDecl.getNamedImports()) {
+      const localName = specifier.getAliasNode()?.getText() ?? specifier.getName();
+      if (localName === name) {
+        return { importDecl, originalName: specifier.getName() };
+      }
+    }
+    const nsImport = importDecl.getNamespaceImport();
+    if (nsImport && nsImport.getText() === name) {
+      return { importDecl, originalName: "*" };
+    }
+  }
+  return null;
+}
+
+// src/analyzers/base-analyzer.ts
+class BaseAnalyzer {
+  project;
+  config;
+  _diagnostics = [];
+  constructor(project, config) {
+    this.project = project;
+    this.config = config;
+  }
+  addDiagnostic(diagnostic) {
+    this._diagnostics.push(diagnostic);
+  }
+  getDiagnostics() {
+    return [...this._diagnostics];
+  }
+}
+
+// src/analyzers/app-analyzer.ts
+class AppAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    const allAppCalls = [];
+    for (const file2 of this.project.getSourceFiles()) {
+      const appCalls = findCallExpressions(file2, "vertz", "app");
+      for (const call2 of appCalls) {
+        allAppCalls.push({ call: call2, file: file2 });
+      }
+    }
+    if (allAppCalls.length === 0) {
+      this.addDiagnostic(createDiagnosticFromLocation({ sourceFile: "", sourceLine: 0, sourceColumn: 0 }, {
+        severity: "error",
+        code: "VERTZ_APP_NOT_FOUND",
+        message: "No vertz.app() call found in the project."
+      }));
+      return {
+        app: {
+          basePath: "/",
+          globalMiddleware: [],
+          moduleRegistrations: [],
+          sourceFile: "",
+          sourceLine: 0,
+          sourceColumn: 0
+        }
+      };
+    }
+    if (allAppCalls.length > 1) {
+      const loc2 = getSourceLocation(allAppCalls[1].call);
+      this.addDiagnostic(createDiagnosticFromLocation(loc2, {
+        severity: "error",
+        code: "VERTZ_APP_DUPLICATE",
+        message: "Multiple vertz.app() calls found. Only one is allowed."
+      }));
+    }
+    const { call, file } = allAppCalls[0];
+    const obj = extractObjectLiteral(call, 0);
+    const basePathExpr = obj ? getPropertyValue(obj, "basePath") : null;
+    const basePath = basePathExpr ? getStringValue(basePathExpr) ?? "/" : "/";
+    const versionExpr = obj ? getPropertyValue(obj, "version") : null;
+    const version = versionExpr ? getStringValue(versionExpr) ?? undefined : undefined;
+    const loc = getSourceLocation(call);
+    if (basePath !== "/" && !basePath.startsWith("/")) {
+      this.addDiagnostic(createDiagnosticFromLocation(loc, {
+        severity: "warning",
+        code: "VERTZ_APP_BASEPATH_FORMAT",
+        message: `basePath "${basePath}" should start with "/".`
+      }));
+    }
+    const chainedCalls = this.collectChainedCalls(call);
+    const globalMiddleware = this.extractMiddlewares(chainedCalls, file);
+    const moduleRegistrations = this.extractRegistrations(chainedCalls);
+    return {
+      app: {
+        basePath,
+        version,
+        globalMiddleware,
+        moduleRegistrations,
+        ...loc
+      }
+    };
+  }
+  collectChainedCalls(appCall) {
+    const results = [];
+    let current = appCall;
+    while (current.getParent()?.isKind(SyntaxKind2.PropertyAccessExpression)) {
+      const propAccess = current.getParentOrThrow();
+      if (!propAccess.isKind(SyntaxKind2.PropertyAccessExpression))
+        break;
+      const methodName = propAccess.getName();
+      const parentCall = propAccess.getParent();
+      if (!parentCall?.isKind(SyntaxKind2.CallExpression))
+        break;
+      results.push({ methodName, call: parentCall });
+      current = parentCall;
+    }
+    return results;
+  }
+  extractMiddlewares(chainedCalls, file) {
+    const middleware = [];
+    for (const { methodName, call } of chainedCalls) {
+      if (methodName !== "middlewares")
+        continue;
+      const arrArg = call.getArguments().at(0);
+      if (!arrArg)
+        continue;
+      const elements = getArrayElements(arrArg);
+      for (const el of elements) {
+        if (el.isKind(SyntaxKind2.Identifier)) {
+          const resolved = resolveIdentifier(el, this.project);
+          middleware.push({
+            name: el.getText(),
+            sourceFile: resolved ? resolved.sourceFile.getFilePath() : file.getFilePath()
+          });
+        }
+      }
+    }
+    return middleware;
+  }
+  extractRegistrations(chainedCalls) {
+    const registrations = [];
+    for (const { methodName, call } of chainedCalls) {
+      if (methodName !== "register")
+        continue;
+      const args = call.getArguments();
+      const moduleArg = args.at(0);
+      if (!moduleArg)
+        continue;
+      const moduleName = moduleArg.isKind(SyntaxKind2.Identifier) ? moduleArg.getText() : undefined;
+      if (!moduleName) {
+        this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+          severity: "warning",
+          code: "VERTZ_APP_INLINE_MODULE",
+          message: ".register() argument should be a module identifier, not an inline expression."
+        }));
+        continue;
+      }
+      const optionsObj = extractObjectLiteral(call, 1);
+      const options = optionsObj ? this.extractOptions(optionsObj) : undefined;
+      registrations.push({ moduleName, options });
+    }
+    return registrations;
+  }
+  extractOptions(obj) {
+    const result = {};
+    for (const prop of obj.getProperties()) {
+      if (!prop.isKind(SyntaxKind2.PropertyAssignment))
+        continue;
+      const name = prop.getName();
+      const init = prop.getInitializerOrThrow();
+      const strValue = getStringValue(init);
+      if (strValue !== null) {
+        result[name] = strValue;
+      } else if (init.isKind(SyntaxKind2.TrueKeyword)) {
+        result[name] = true;
+      } else if (init.isKind(SyntaxKind2.FalseKeyword)) {
+        result[name] = false;
+      } else if (init.isKind(SyntaxKind2.NumericLiteral)) {
+        result[name] = Number(init.getText());
+      } else if (init.isKind(SyntaxKind2.ObjectLiteralExpression)) {
+        result[name] = this.extractOptions(init);
+      }
+    }
+    return result;
+  }
+}
+// src/analyzers/dependency-graph-analyzer.ts
+class DependencyGraphAnalyzer extends BaseAnalyzer {
+  input = { modules: [], middleware: [] };
+  setInput(input) {
+    this.input = input;
+  }
+  async analyze(input) {
+    const { modules, middleware } = input ?? this.input;
+    const nodes = this.buildNodes(modules, middleware);
+    const serviceTokenMap = this.buildServiceTokenMap(modules);
+    const edges = this.buildEdges(modules, middleware, serviceTokenMap);
+    const moduleNames = modules.map((m) => m.name);
+    const { initializationOrder, circularDependencies } = this.computeModuleOrder(moduleNames, edges);
+    this.emitCycleDiagnostics(circularDependencies);
+    this.emitUnresolvedInjectDiagnostics(modules, middleware, serviceTokenMap);
+    if (initializationOrder.length > 0) {
+      this.addDiagnostic(createDiagnostic({
+        severity: "info",
+        code: "VERTZ_DEP_INIT_ORDER",
+        message: `Module initialization order: ${initializationOrder.join(", ")}`
+      }));
+    }
+    return {
+      graph: { nodes, edges, initializationOrder, circularDependencies }
+    };
+  }
+  buildNodes(modules, middleware) {
+    const nodes = [];
+    for (const mod of modules) {
+      nodes.push({ id: `module:${mod.name}`, kind: "module", name: mod.name });
+      for (const svc of mod.services) {
+        nodes.push({
+          id: `service:${mod.name}.${svc.name}`,
+          kind: "service",
+          name: svc.name,
+          moduleName: mod.name
+        });
+      }
+      for (const router of mod.routers) {
+        nodes.push({
+          id: `router:${mod.name}.${router.name}`,
+          kind: "router",
+          name: router.name,
+          moduleName: mod.name
+        });
+      }
+    }
+    for (const mw of middleware) {
+      nodes.push({ id: `middleware:${mw.name}`, kind: "middleware", name: mw.name });
+    }
+    return nodes;
+  }
+  buildServiceTokenMap(modules) {
+    const map = new Map;
+    for (const mod of modules) {
+      for (const svc of mod.services) {
+        map.set(svc.name, `service:${mod.name}.${svc.name}`);
+      }
+    }
+    return map;
+  }
+  buildEdges(modules, middleware, serviceTokenMap) {
+    const edges = [];
+    for (const mod of modules) {
+      const seen = new Set;
+      for (const imp of mod.imports) {
+        if (imp.isEnvImport || !imp.sourceModule)
+          continue;
+        if (seen.has(imp.sourceModule))
+          continue;
+        seen.add(imp.sourceModule);
+        edges.push({
+          from: `module:${mod.name}`,
+          to: `module:${imp.sourceModule}`,
+          kind: "imports"
+        });
+      }
+    }
+    for (const mod of modules) {
+      for (const svc of mod.services) {
+        this.addInjectEdges(edges, `service:${mod.name}.${svc.name}`, svc.inject, serviceTokenMap);
+      }
+      for (const router of mod.routers) {
+        this.addInjectEdges(edges, `router:${mod.name}.${router.name}`, router.inject, serviceTokenMap);
+      }
+    }
+    for (const mw of middleware) {
+      this.addInjectEdges(edges, `middleware:${mw.name}`, mw.inject, serviceTokenMap);
+    }
+    for (const mod of modules) {
+      for (const router of mod.routers) {
+        for (const route of router.routes) {
+          for (const mwRef of route.middleware) {
+            edges.push({
+              from: `router:${mod.name}.${router.name}`,
+              to: `middleware:${mwRef.name}`,
+              kind: "uses-middleware"
+            });
+          }
+        }
+      }
+    }
+    for (const mod of modules) {
+      for (const exportName of mod.exports) {
+        const targetId = serviceTokenMap.get(exportName);
+        if (targetId) {
+          edges.push({ from: `module:${mod.name}`, to: targetId, kind: "exports" });
+        }
+      }
+    }
+    return edges;
+  }
+  addInjectEdges(edges, fromId, injectRefs, serviceTokenMap) {
+    for (const inj of injectRefs) {
+      const targetId = serviceTokenMap.get(inj.resolvedToken);
+      if (targetId) {
+        edges.push({ from: fromId, to: targetId, kind: "inject" });
+      }
+    }
+  }
+  computeModuleOrder(moduleNames, edges) {
+    const inDegree = new Map;
+    const adjacency = new Map;
+    for (const name of moduleNames) {
+      inDegree.set(name, 0);
+      adjacency.set(name, []);
+    }
+    for (const edge of edges) {
+      if (edge.kind !== "imports")
+        continue;
+      const fromMod = edge.from.replace("module:", "");
+      const toMod = edge.to.replace("module:", "");
+      adjacency.get(toMod)?.push(fromMod);
+      inDegree.set(fromMod, (inDegree.get(fromMod) ?? 0) + 1);
+    }
+    const queue = [];
+    for (const name of moduleNames) {
+      if (inDegree.get(name) === 0) {
+        queue.push(name);
+      }
+    }
+    const initializationOrder = [];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (!current)
+        break;
+      initializationOrder.push(current);
+      for (const neighbor of adjacency.get(current) ?? []) {
+        const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+    const circularDependencies = this.detectCycles(moduleNames, initializationOrder, edges);
+    const sorted = new Set(initializationOrder);
+    for (const name of moduleNames) {
+      if (!sorted.has(name)) {
+        initializationOrder.push(name);
+      }
+    }
+    return { initializationOrder, circularDependencies };
+  }
+  detectCycles(moduleNames, sortedNames, edges) {
+    const sorted = new Set(sortedNames);
+    const unsorted = moduleNames.filter((n) => !sorted.has(n));
+    if (unsorted.length === 0)
+      return [];
+    const depAdj = new Map;
+    for (const name of unsorted) {
+      depAdj.set(name, []);
+    }
+    for (const edge of edges) {
+      if (edge.kind !== "imports")
+        continue;
+      const fromMod = edge.from.replace("module:", "");
+      const toMod = edge.to.replace("module:", "");
+      if (depAdj.has(fromMod) && depAdj.has(toMod)) {
+        depAdj.get(fromMod)?.push(toMod);
+      }
+    }
+    const cycles = [];
+    const visited = new Set;
+    for (const start of unsorted) {
+      if (visited.has(start))
+        continue;
+      const component = [];
+      const stack = [start];
+      while (stack.length > 0) {
+        const node = stack.pop();
+        if (!node)
+          break;
+        if (visited.has(node))
+          continue;
+        visited.add(node);
+        component.push(node);
+        for (const dep of depAdj.get(node) ?? []) {
+          if (!visited.has(dep))
+            stack.push(dep);
+        }
+        for (const [other, deps] of depAdj) {
+          if (deps.includes(node) && !visited.has(other)) {
+            stack.push(other);
+          }
+        }
+      }
+      if (component.length >= 1) {
+        cycles.push(component);
+      }
+    }
+    return cycles;
+  }
+  emitCycleDiagnostics(circularDependencies) {
+    for (const cycle of circularDependencies) {
+      const path = [...cycle, cycle.at(0)].join(" -> ");
+      this.addDiagnostic(createDiagnostic({
+        severity: "error",
+        code: "VERTZ_DEP_CIRCULAR",
+        message: `Circular dependency detected: ${path}`
+      }));
+    }
+  }
+  emitUnresolvedInjectDiagnostics(modules, middleware, serviceTokenMap) {
+    for (const mod of modules) {
+      for (const svc of mod.services) {
+        this.warnUnresolvedInjects(svc.inject, serviceTokenMap, `service "${svc.name}" of module "${mod.name}"`);
+      }
+      for (const router of mod.routers) {
+        this.warnUnresolvedInjects(router.inject, serviceTokenMap, `router "${router.name}" of module "${mod.name}"`);
+      }
+    }
+    for (const mw of middleware) {
+      this.warnUnresolvedInjects(mw.inject, serviceTokenMap, `middleware "${mw.name}"`);
+    }
+  }
+  warnUnresolvedInjects(injectRefs, serviceTokenMap, context) {
+    for (const inj of injectRefs) {
+      if (!serviceTokenMap.has(inj.resolvedToken)) {
+        this.addDiagnostic(createDiagnostic({
+          severity: "warning",
+          code: "VERTZ_DEP_UNRESOLVED_INJECT",
+          message: `Unresolved inject "${inj.resolvedToken}" in ${context}.`
+        }));
+      }
+    }
+  }
+}
+// src/analyzers/env-analyzer.ts
+import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+
+// src/analyzers/schema-analyzer.ts
+import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+class SchemaAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    const schemas = [];
+    for (const file of this.project.getSourceFiles()) {
+      if (!isSchemaFile(file))
+        continue;
+      for (const exportSymbol of file.getExportSymbols()) {
+        const declarations = exportSymbol.getDeclarations();
+        for (const decl of declarations) {
+          if (!decl.isKind(SyntaxKind3.VariableDeclaration))
+            continue;
+          const initializer = decl.getInitializer();
+          if (!initializer)
+            continue;
+          if (!isSchemaExpression(file, initializer))
+            continue;
+          const name = exportSymbol.getName();
+          const loc = getSourceLocation(decl);
+          const id = extractSchemaId(initializer);
+          schemas.push({
+            name,
+            ...loc,
+            id: id ?? undefined,
+            namingConvention: parseSchemaName(name),
+            isNamed: id !== null
+          });
+        }
+      }
+    }
+    return { schemas };
+  }
+}
+var VALID_OPERATIONS = ["create", "read", "update", "list", "delete"];
+var VALID_PARTS = ["Body", "Response", "Query", "Params", "Headers"];
+function parseSchemaName(name) {
+  for (const op of VALID_OPERATIONS) {
+    if (!name.startsWith(op))
+      continue;
+    const rest = name.slice(op.length);
+    if (rest.length === 0)
+      continue;
+    for (const part of VALID_PARTS) {
+      if (!rest.endsWith(part))
+        continue;
+      const entity = rest.slice(0, -part.length);
+      if (entity.length === 0)
+        continue;
+      const firstChar = entity.at(0);
+      if (!firstChar || firstChar !== firstChar.toUpperCase())
+        continue;
+      return { operation: op, entity, part };
+    }
+  }
+  return {};
+}
+function isSchemaExpression(_file, expr) {
+  const root = findRootIdentifier(expr);
+  if (!root)
+    return false;
+  return isFromImport(root, "@vertz/schema");
+}
+function extractSchemaId(expr) {
+  let current = expr;
+  while (current.isKind(SyntaxKind3.CallExpression)) {
+    const access = current.getExpression();
+    if (access.isKind(SyntaxKind3.PropertyAccessExpression) && access.getName() === "id") {
+      const args = current.getArguments();
+      if (args.length === 1) {
+        const firstArg = args.at(0);
+        const value = firstArg ? getStringValue(firstArg) : null;
+        if (value !== null)
+          return value;
+      }
+    }
+    if (access.isKind(SyntaxKind3.PropertyAccessExpression)) {
+      current = access.getExpression();
+    } else {
+      break;
+    }
+  }
+  return null;
+}
+function isSchemaFile(file) {
+  return file.getImportDeclarations().some((decl) => decl.getModuleSpecifierValue() === "@vertz/schema");
+}
+function createNamedSchemaRef(schemaName, sourceFile) {
+  return { kind: "named", schemaName, sourceFile };
+}
+function createInlineSchemaRef(sourceFile) {
+  return { kind: "inline", sourceFile };
+}
+function findRootIdentifier(expr) {
+  if (expr.isKind(SyntaxKind3.CallExpression)) {
+    return findRootIdentifier(expr.getExpression());
+  }
+  if (expr.isKind(SyntaxKind3.PropertyAccessExpression)) {
+    return findRootIdentifier(expr.getExpression());
+  }
+  if (expr.isKind(SyntaxKind3.Identifier)) {
+    return expr;
+  }
+  return null;
+}
+
+// src/analyzers/env-analyzer.ts
+class EnvAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    let env;
+    for (const file of this.project.getSourceFiles()) {
+      const calls = findCallExpressions(file, "vertz", "env");
+      for (const call of calls) {
+        const obj = extractObjectLiteral(call, 0);
+        if (!obj)
+          continue;
+        const loc = getSourceLocation(call);
+        if (env) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+            severity: "error",
+            code: "VERTZ_ENV_DUPLICATE",
+            message: "Multiple vertz.env() calls found. Only one is allowed."
+          }));
+          continue;
+        }
+        const loadExpr = getPropertyValue(obj, "load");
+        const loadFiles = loadExpr ? getArrayElements(loadExpr).map((e) => getStringValue(e)).filter((v) => v !== null) : [];
+        const schemaExpr = getPropertyValue(obj, "schema");
+        let schema;
+        if (schemaExpr?.isKind(SyntaxKind4.Identifier)) {
+          schema = createNamedSchemaRef(schemaExpr.getText(), file.getFilePath());
+        }
+        env = {
+          ...loc,
+          loadFiles,
+          schema,
+          variables: []
+        };
+      }
+    }
+    return { env };
+  }
+}
+// src/analyzers/middleware-analyzer.ts
+import { SyntaxKind as SyntaxKind6 } from "ts-morph";
+
+// src/analyzers/service-analyzer.ts
+import { SyntaxKind as SyntaxKind5 } from "ts-morph";
+class ServiceAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    return { services: [] };
+  }
+  async analyzeForModule(moduleDefVarName, moduleName) {
+    const services = [];
+    for (const file of this.project.getSourceFiles()) {
+      const calls = findMethodCallsOnVariable(file, moduleDefVarName, "service");
+      for (const call of calls) {
+        const name = getVariableNameForCall(call);
+        if (!name)
+          continue;
+        const obj = extractObjectLiteral(call, 0);
+        const inject = obj ? parseInjectFromObj(obj) : [];
+        const methods = obj ? parseMethodsFromObj(obj) : [];
+        const loc = getSourceLocation(call);
+        services.push({
+          name,
+          moduleName,
+          ...loc,
+          inject,
+          methods
+        });
+      }
+    }
+    return services;
+  }
+}
+function parseInjectFromObj(obj) {
+  const injectExpr = getPropertyValue(obj, "inject");
+  if (!injectExpr?.isKind(SyntaxKind5.ObjectLiteralExpression))
+    return [];
+  return parseInjectRefs(injectExpr);
+}
+function parseMethodsFromObj(obj) {
+  const methodsExpr = getPropertyValue(obj, "methods");
+  if (!methodsExpr)
+    return [];
+  return extractMethodSignatures(methodsExpr);
+}
+function parseInjectRefs(obj) {
+  return getProperties(obj).map(({ name, value }) => {
+    const resolvedToken = value.isKind(SyntaxKind5.Identifier) ? value.getText() : name;
+    return { localName: name, resolvedToken };
+  });
+}
+function extractMethodSignatures(expr) {
+  if (!expr.isKind(SyntaxKind5.ArrowFunction) && !expr.isKind(SyntaxKind5.FunctionExpression)) {
+    return [];
+  }
+  const body = expr.getBody();
+  let returnObj = null;
+  if (body.isKind(SyntaxKind5.ObjectLiteralExpression)) {
+    returnObj = body;
+  } else if (body.isKind(SyntaxKind5.ParenthesizedExpression)) {
+    const inner = body.getExpression();
+    if (inner.isKind(SyntaxKind5.ObjectLiteralExpression)) {
+      returnObj = inner;
+    }
+  } else if (body.isKind(SyntaxKind5.Block)) {
+    const returnStmt = body.getStatements().find((s) => s.isKind(SyntaxKind5.ReturnStatement));
+    const retExpr = returnStmt?.asKind(SyntaxKind5.ReturnStatement)?.getExpression();
+    if (retExpr?.isKind(SyntaxKind5.ObjectLiteralExpression)) {
+      returnObj = retExpr;
+    }
+  }
+  if (!returnObj)
+    return [];
+  const methods = [];
+  for (const prop of returnObj.getProperties()) {
+    if (!prop.isKind(SyntaxKind5.PropertyAssignment))
+      continue;
+    const methodName = prop.getName();
+    const init = prop.getInitializer();
+    if (!init)
+      continue;
+    const params = extractFunctionParams(init);
+    const returnType = inferReturnType(init);
+    methods.push({
+      name: methodName,
+      parameters: params,
+      returnType
+    });
+  }
+  return methods;
+}
+function extractFunctionParams(expr) {
+  if (!expr.isKind(SyntaxKind5.ArrowFunction) && !expr.isKind(SyntaxKind5.FunctionExpression)) {
+    return [];
+  }
+  return expr.getParameters().map((p) => ({
+    name: p.getName(),
+    type: p.getType().getText(p)
+  }));
+}
+function inferReturnType(expr) {
+  if (expr.isKind(SyntaxKind5.ArrowFunction) || expr.isKind(SyntaxKind5.FunctionExpression)) {
+    const retType = expr.getReturnType();
+    return retType.getText(expr);
+  }
+  return "unknown";
+}
+
+// src/analyzers/middleware-analyzer.ts
+class MiddlewareAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    const middleware = [];
+    for (const file of this.project.getSourceFiles()) {
+      const calls = findCallExpressions(file, "vertz", "middleware");
+      for (const call of calls) {
+        const obj = extractObjectLiteral(call, 0);
+        if (!obj) {
+          const callLoc = getSourceLocation(call);
+          this.addDiagnostic(createDiagnosticFromLocation(callLoc, {
+            severity: "warning",
+            code: "VERTZ_MW_NON_OBJECT_CONFIG",
+            message: "Middleware config must be an object literal for static analysis.",
+            suggestion: "Pass an inline object literal to vertz.middleware()."
+          }));
+          continue;
+        }
+        const loc = getSourceLocation(call);
+        const nameExpr = getPropertyValue(obj, "name");
+        if (!nameExpr) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+            severity: "error",
+            code: "VERTZ_MW_MISSING_NAME",
+            message: "Middleware must have a 'name' property.",
+            suggestion: "Add a 'name' property to the middleware config."
+          }));
+          continue;
+        }
+        const name = getStringValue(nameExpr);
+        if (!name) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+            severity: "warning",
+            code: "VERTZ_MW_DYNAMIC_NAME",
+            message: "Middleware name should be a string literal for static analysis.",
+            suggestion: "Use a string literal for the middleware name."
+          }));
+          continue;
+        }
+        const handlerExpr = getPropertyValue(obj, "handler");
+        if (!handlerExpr) {
+          this.addDiagnostic(createDiagnosticFromLocation(loc, {
+            severity: "error",
+            code: "VERTZ_MW_MISSING_HANDLER",
+            message: "Middleware must have a 'handler' property.",
+            suggestion: "Add a 'handler' property to the middleware config."
+          }));
+          continue;
+        }
+        const injectExpr = getPropertyValue(obj, "inject");
+        const inject = injectExpr?.isKind(SyntaxKind6.ObjectLiteralExpression) ? parseInjectRefs(injectExpr) : [];
+        const filePath = file.getFilePath();
+        const headers = this.resolveSchemaRef(obj, "headers", filePath);
+        const params = this.resolveSchemaRef(obj, "params", filePath);
+        const query = this.resolveSchemaRef(obj, "query", filePath);
+        const body = this.resolveSchemaRef(obj, "body", filePath);
+        const requires = this.resolveSchemaRef(obj, "requires", filePath);
+        const provides = this.resolveSchemaRef(obj, "provides", filePath);
+        middleware.push({
+          name,
+          ...loc,
+          inject,
+          headers,
+          params,
+          query,
+          body,
+          requires,
+          provides
+        });
+      }
+    }
+    return { middleware };
+  }
+  resolveSchemaRef(obj, prop, filePath) {
+    const expr = getPropertyValue(obj, prop);
+    if (!expr)
+      return;
+    if (expr.isKind(SyntaxKind6.Identifier)) {
+      const resolved = resolveIdentifier(expr, this.project);
+      const resolvedPath = resolved ? resolved.sourceFile.getFilePath() : filePath;
+      return createNamedSchemaRef(expr.getText(), resolvedPath);
+    }
+    if (isSchemaExpression(expr.getSourceFile(), expr)) {
+      return createInlineSchemaRef(filePath);
+    }
+    return;
+  }
+}
+// src/analyzers/module-analyzer.ts
+import { SyntaxKind as SyntaxKind7 } from "ts-morph";
+class ModuleAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    const modules = [];
+    const defVarToIndex = new Map;
+    for (const file of this.project.getSourceFiles()) {
+      const defCalls = findCallExpressions(file, "vertz", "moduleDef");
+      for (const call of defCalls) {
+        const obj = extractObjectLiteral(call, 0);
+        if (!obj)
+          continue;
+        const nameExpr = getPropertyValue(obj, "name");
+        const name = nameExpr ? getStringValue(nameExpr) : null;
+        if (!name) {
+          this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+            severity: "error",
+            code: "VERTZ_MODULE_DYNAMIC_NAME",
+            message: "vertz.moduleDef() requires a static string `name` property."
+          }));
+          continue;
+        }
+        const varName = getVariableNameForCall(call);
+        const importsExpr = getPropertyValue(obj, "imports");
+        const imports = importsExpr?.isKind(SyntaxKind7.ObjectLiteralExpression) ? parseImports(importsExpr) : [];
+        const optionsExpr = getPropertyValue(obj, "options");
+        let options;
+        if (optionsExpr?.isKind(SyntaxKind7.Identifier)) {
+          options = createNamedSchemaRef(optionsExpr.getText(), file.getFilePath());
+        }
+        const loc = getSourceLocation(call);
+        const idx = modules.length;
+        modules.push({
+          name,
+          ...loc,
+          imports,
+          options,
+          services: [],
+          routers: [],
+          exports: []
+        });
+        if (varName) {
+          defVarToIndex.set(varName, idx);
+        }
+      }
+    }
+    for (const file of this.project.getSourceFiles()) {
+      const moduleCalls = findCallExpressions(file, "vertz", "module");
+      for (const call of moduleCalls) {
+        const args = call.getArguments();
+        if (args.length < 2)
+          continue;
+        const defArg = args.at(0);
+        if (!defArg?.isKind(SyntaxKind7.Identifier))
+          continue;
+        const defVarName = defArg.getText();
+        const idx = defVarToIndex.get(defVarName);
+        if (idx === undefined)
+          continue;
+        const mod = modules.at(idx);
+        if (!mod)
+          continue;
+        const assemblyObj = extractObjectLiteral(call, 1);
+        if (!assemblyObj)
+          continue;
+        const exportsExpr = getPropertyValue(assemblyObj, "exports");
+        if (exportsExpr) {
+          mod.exports = extractIdentifierNames(exportsExpr);
+        }
+      }
+    }
+    return { modules };
+  }
+}
+function parseImports(obj) {
+  return getProperties(obj).map(({ name }) => ({
+    localName: name,
+    isEnvImport: false
+  }));
+}
+function extractIdentifierNames(expr) {
+  if (!expr.isKind(SyntaxKind7.ArrayLiteralExpression))
+    return [];
+  return expr.getElements().filter((e) => e.isKind(SyntaxKind7.Identifier)).map((e) => e.getText());
+}
+// src/analyzers/route-analyzer.ts
+import { SyntaxKind as SyntaxKind8 } from "ts-morph";
+var HTTP_METHODS = {
+  get: "GET",
+  post: "POST",
+  put: "PUT",
+  patch: "PATCH",
+  delete: "DELETE",
+  head: "HEAD"
+};
+
+class RouteAnalyzer extends BaseAnalyzer {
+  async analyze() {
+    return { routers: [] };
+  }
+  async analyzeForModules(context) {
+    const routers = [];
+    const knownModuleDefVars = new Set(context.moduleDefVariables.keys());
+    for (const file of this.project.getSourceFiles()) {
+      for (const [moduleDefVar, moduleName] of context.moduleDefVariables) {
+        const routerCalls = findMethodCallsOnVariable(file, moduleDefVar, "router");
+        for (const call of routerCalls) {
+          const varName = getVariableNameForCall(call);
+          if (!varName)
+            continue;
+          const obj = extractObjectLiteral(call, 0);
+          const prefixExpr = obj ? getPropertyValue(obj, "prefix") : null;
+          const prefix = prefixExpr ? getStringValue(prefixExpr) ?? "/" : "/";
+          if (!prefixExpr) {
+            this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+              severity: "warning",
+              code: "VERTZ_RT_MISSING_PREFIX",
+              message: "Router should have a 'prefix' property.",
+              suggestion: "Add a 'prefix' property to the router config."
+            }));
+          }
+          const loc = getSourceLocation(call);
+          const injectExpr = obj ? getPropertyValue(obj, "inject") : null;
+          const inject = injectExpr?.isKind(SyntaxKind8.ObjectLiteralExpression) ? parseInjectRefs(injectExpr) : [];
+          const routes = this.extractRoutes(file, varName, prefix, moduleName);
+          routers.push({
+            name: varName,
+            moduleName,
+            ...loc,
+            prefix,
+            inject,
+            routes
+          });
+        }
+      }
+      this.detectUnknownRouterCalls(file, knownModuleDefVars);
+    }
+    return { routers };
+  }
+  detectUnknownRouterCalls(file, knownModuleDefVars) {
+    const allCalls = file.getDescendantsOfKind(SyntaxKind8.CallExpression);
+    for (const call of allCalls) {
+      const expr = call.getExpression();
+      if (!expr.isKind(SyntaxKind8.PropertyAccessExpression))
+        continue;
+      if (expr.getName() !== "router")
+        continue;
+      const obj = expr.getExpression();
+      if (!obj.isKind(SyntaxKind8.Identifier))
+        continue;
+      if (knownModuleDefVars.has(obj.getText()))
+        continue;
+      const varName = getVariableNameForCall(call);
+      if (!varName)
+        continue;
+      const hasHttpMethodCalls = Object.keys(HTTP_METHODS).some((method) => findMethodCallsOnVariable(file, varName, method).length > 0);
+      if (!hasHttpMethodCalls)
+        continue;
+      this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+        severity: "error",
+        code: "VERTZ_RT_UNKNOWN_MODULE_DEF",
+        message: `'${obj.getText()}' is not a known moduleDef variable.`,
+        suggestion: "Ensure the variable is declared with vertz.moduleDef() and is included in the module context."
+      }));
+    }
+  }
+  extractRoutes(file, routerVarName, prefix, moduleName) {
+    const routes = [];
+    const usedOperationIds = new Set;
+    for (const [methodName, httpMethod] of Object.entries(HTTP_METHODS)) {
+      const directCalls = findMethodCallsOnVariable(file, routerVarName, methodName);
+      const chainedCalls = this.findChainedHttpCalls(file, routerVarName, methodName);
+      const allCalls = [...directCalls, ...chainedCalls];
+      for (const call of allCalls) {
+        const route = this.extractRoute(call, httpMethod, prefix, moduleName, file, usedOperationIds);
+        if (route)
+          routes.push(route);
+      }
+    }
+    return routes;
+  }
+  findChainedHttpCalls(file, routerVarName, methodName) {
+    return file.getDescendantsOfKind(SyntaxKind8.CallExpression).filter((call) => {
+      const expr = call.getExpression();
+      if (!expr.isKind(SyntaxKind8.PropertyAccessExpression))
+        return false;
+      if (expr.getName() !== methodName)
+        return false;
+      const obj = expr.getExpression();
+      if (!obj.isKind(SyntaxKind8.CallExpression))
+        return false;
+      return this.chainResolvesToVariable(obj, routerVarName);
+    });
+  }
+  chainResolvesToVariable(expr, varName) {
+    if (expr.isKind(SyntaxKind8.Identifier)) {
+      return expr.getText() === varName;
+    }
+    if (expr.isKind(SyntaxKind8.CallExpression)) {
+      const inner = expr.getExpression();
+      if (inner.isKind(SyntaxKind8.PropertyAccessExpression)) {
+        return this.chainResolvesToVariable(inner.getExpression(), varName);
+      }
+    }
+    return false;
+  }
+  extractRoute(call, method, prefix, moduleName, file, usedOperationIds) {
+    const args = call.getArguments();
+    const pathArg = args[0];
+    if (!pathArg)
+      return null;
+    const path = getStringValue(pathArg);
+    if (path === null) {
+      this.addDiagnostic(createDiagnosticFromLocation(getSourceLocation(call), {
+        severity: "error",
+        code: "VERTZ_RT_DYNAMIC_PATH",
+        message: "Route paths must be string literals for static analysis.",
+        suggestion: "Use a string literal for the route path."
+      }));
+      return null;
+    }
+    const fullPath = joinPaths(prefix, path);
+    const loc = getSourceLocation(call);
+    const filePath = file.getFilePath();
+    const obj = extractObjectLiteral(call, 1);
+    if (!obj && args.length > 1) {
+      this.addDiagnostic(createDiagnosticFromLocation(loc, {
+        severity: "warning",
+        code: "VERTZ_RT_DYNAMIC_CONFIG",
+        message: "Route config must be an object literal for static analysis.",
+        suggestion: "Pass an inline object literal as the second argument."
+      }));
+    }
+    const params = obj ? this.resolveSchemaRef(obj, "params", filePath) : undefined;
+    const query = obj ? this.resolveSchemaRef(obj, "query", filePath) : undefined;
+    const body = obj ? this.resolveSchemaRef(obj, "body", filePath) : undefined;
+    const headers = obj ? this.resolveSchemaRef(obj, "headers", filePath) : undefined;
+    const response = obj ? this.resolveSchemaRef(obj, "response", filePath) : undefined;
+    const middleware = obj ? this.extractMiddlewareRefs(obj, filePath) : [];
+    const descriptionExpr = obj ? getPropertyValue(obj, "description") : null;
+    const description = descriptionExpr ? getStringValue(descriptionExpr) ?? undefined : undefined;
+    const tagsExpr = obj ? getPropertyValue(obj, "tags") : null;
+    const tags = tagsExpr ? getArrayElements(tagsExpr).map((e) => getStringValue(e)).filter((v) => v !== null) : [];
+    const handlerExpr = obj ? getPropertyValue(obj, "handler") : null;
+    const operationId = this.generateOperationId(moduleName, method, path, handlerExpr, usedOperationIds);
+    if (obj && !handlerExpr) {
+      this.addDiagnostic(createDiagnosticFromLocation(loc, {
+        severity: "error",
+        code: "VERTZ_RT_MISSING_HANDLER",
+        message: "Route must have a 'handler' property.",
+        suggestion: "Add a 'handler' property to the route config."
+      }));
+      return null;
+    }
+    return {
+      method,
+      path,
+      fullPath,
+      ...loc,
+      operationId,
+      params,
+      query,
+      body,
+      headers,
+      response,
+      middleware,
+      description,
+      tags
+    };
+  }
+  resolveSchemaRef(obj, prop, filePath) {
+    const expr = getPropertyValue(obj, prop);
+    if (!expr)
+      return;
+    if (expr.isKind(SyntaxKind8.Identifier)) {
+      const resolved = resolveIdentifier(expr, this.project);
+      const resolvedPath = resolved ? resolved.sourceFile.getFilePath() : filePath;
+      return createNamedSchemaRef(expr.getText(), resolvedPath);
+    }
+    if (isSchemaExpression(expr.getSourceFile(), expr)) {
+      return createInlineSchemaRef(filePath);
+    }
+    return;
+  }
+  extractMiddlewareRefs(obj, filePath) {
+    const expr = getPropertyValue(obj, "middlewares");
+    if (!expr)
+      return [];
+    const elements = getArrayElements(expr);
+    return elements.filter((el) => el.isKind(SyntaxKind8.Identifier)).map((el) => {
+      const resolved = resolveIdentifier(el, this.project);
+      return {
+        name: el.getText(),
+        sourceFile: resolved ? resolved.sourceFile.getFilePath() : filePath
+      };
+    });
+  }
+  generateOperationId(moduleName, method, path, handlerExpr, usedIds) {
+    let handlerName = null;
+    if (handlerExpr?.isKind(SyntaxKind8.Identifier)) {
+      handlerName = handlerExpr.getText();
+    } else if (handlerExpr?.isKind(SyntaxKind8.PropertyAccessExpression)) {
+      handlerName = handlerExpr.getName();
+    }
+    const id = handlerName ? `${moduleName}_${handlerName}` : `${moduleName}_${method.toLowerCase()}_${sanitizePath(path)}`;
+    if (!usedIds.has(id)) {
+      usedIds.add(id);
+      return id;
+    }
+    let counter = 2;
+    while (usedIds.has(`${id}_${counter}`))
+      counter++;
+    const uniqueId = `${id}_${counter}`;
+    usedIds.add(uniqueId);
+    return uniqueId;
+  }
+}
+function joinPaths(prefix, path) {
+  const normalizedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+  if (path === "/")
+    return normalizedPrefix || "/";
+  return normalizedPrefix + path;
+}
+function sanitizePath(path) {
+  return path.replace(/^\//, "").replace(/[/:.]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "") || "root";
+}
+// src/compiler.ts
+import { Project } from "ts-morph";
+
+// src/config.ts
+function defineConfig(config) {
+  return config;
+}
+function resolveConfig(config) {
+  return {
+    strict: config?.strict ?? false,
+    forceGenerate: config?.forceGenerate ?? false,
+    compiler: {
+      sourceDir: config?.compiler?.sourceDir ?? "src",
+      outputDir: config?.compiler?.outputDir ?? ".vertz/generated",
+      entryFile: config?.compiler?.entryFile ?? "src/app.ts",
+      schemas: {
+        enforceNaming: config?.compiler?.schemas?.enforceNaming ?? true,
+        enforcePlacement: config?.compiler?.schemas?.enforcePlacement ?? true
+      },
+      openapi: {
+        output: config?.compiler?.openapi?.output ?? ".vertz/generated/openapi.json",
+        info: {
+          title: config?.compiler?.openapi?.info?.title ?? "Vertz API",
+          version: config?.compiler?.openapi?.info?.version ?? "1.0.0",
+          description: config?.compiler?.openapi?.info?.description
+        }
+      },
+      validation: {
+        requireResponseSchema: config?.compiler?.validation?.requireResponseSchema ?? true,
+        detectDeadCode: config?.compiler?.validation?.detectDeadCode ?? true
+      }
+    }
+  };
+}
+
+// src/generators/boot-generator.ts
+import { writeFile } from "node:fs/promises";
+import { relative } from "node:path";
+
+// src/generators/base-generator.ts
+import { join } from "node:path";
+
+class BaseGenerator {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  resolveOutputPath(outputDir, fileName) {
+    return join(outputDir, fileName);
+  }
+}
+
+// src/generators/boot-generator.ts
+function buildBootManifest(ir) {
+  const moduleMap = new Map(ir.modules.map((m) => [m.name, m]));
+  const registrationMap = new Map(ir.app.moduleRegistrations.map((r) => [r.moduleName, r]));
+  const modules = [];
+  for (const name of ir.dependencyGraph.initializationOrder) {
+    const mod = moduleMap.get(name);
+    if (!mod)
+      continue;
+    const reg = registrationMap.get(name);
+    modules.push({
+      name: mod.name,
+      importPath: mod.sourceFile,
+      variableName: `${mod.name}Module`,
+      ...reg?.options && { options: reg.options }
+    });
+  }
+  const globalMiddleware = ir.app.globalMiddleware.map((ref) => ({
+    name: ref.name,
+    importPath: ref.sourceFile,
+    variableName: ref.name
+  }));
+  return {
+    initializationOrder: ir.dependencyGraph.initializationOrder,
+    modules,
+    globalMiddleware
+  };
+}
+function resolveImportPath(from, to) {
+  const rel = relative(from, to).replace(/\.ts$/, "");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function renderBootFile(manifest, outputDir) {
+  const lines = [];
+  lines.push("// Auto-generated by @vertz/compiler — do not edit");
+  for (const mod of manifest.modules) {
+    const importPath = resolveImportPath(outputDir, mod.importPath);
+    lines.push(`import { ${mod.variableName} } from '${importPath}';`);
+  }
+  for (const mw of manifest.globalMiddleware) {
+    const importPath = resolveImportPath(outputDir, mw.importPath);
+    lines.push(`import { ${mw.variableName} } from '${importPath}';`);
+  }
+  lines.push("");
+  lines.push("export const bootSequence = {");
+  lines.push(`  initializationOrder: [${manifest.initializationOrder.map((n) => `'${n}'`).join(", ")}],`);
+  lines.push("  modules: {");
+  for (const mod of manifest.modules) {
+    if (mod.options) {
+      lines.push(`    ${mod.name}: { module: ${mod.variableName}, options: ${JSON.stringify(mod.options)} },`);
+    } else {
+      lines.push(`    ${mod.name}: { module: ${mod.variableName} },`);
+    }
+  }
+  lines.push("  },");
+  lines.push(`  globalMiddleware: [${manifest.globalMiddleware.map((mw) => mw.variableName).join(", ")}],`);
+  lines.push("} as const;");
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+class BootGenerator extends BaseGenerator {
+  name = "boot";
+  async generate(ir, outputDir) {
+    const manifest = buildBootManifest(ir);
+    const content = renderBootFile(manifest, outputDir);
+    const outputPath = this.resolveOutputPath(outputDir, "boot.ts");
+    await writeFile(outputPath, content);
+  }
+}
+
+// src/generators/manifest-generator.ts
+import { writeFile as writeFile2 } from "node:fs/promises";
+function groupImportsByModule(imports) {
+  const groups = new Map;
+  for (const imp of imports) {
+    if (!imp.sourceModule)
+      continue;
+    const existing = groups.get(imp.sourceModule) ?? [];
+    existing.push(imp.localName);
+    groups.set(imp.sourceModule, existing);
+  }
+  return Array.from(groups.entries()).map(([from, items]) => ({ from, items }));
+}
+function resolveSchemaRef(ref) {
+  if (!ref)
+    return;
+  if (ref.kind === "named")
+    return { $ref: `#/schemas/${ref.schemaName}` };
+  return ref.jsonSchema;
+}
+function buildManifest(ir) {
+  return {
+    version: "1.0.0",
+    app: {
+      basePath: ir.app.basePath,
+      ...ir.app.version && { version: ir.app.version }
+    },
+    modules: ir.modules.map((mod) => ({
+      name: mod.name,
+      services: mod.services.map((s) => s.name),
+      routers: mod.routers.map((r) => r.name),
+      exports: mod.exports,
+      imports: groupImportsByModule(mod.imports)
+    })),
+    routes: ir.modules.flatMap((mod) => mod.routers.flatMap((router) => router.routes.map((route) => {
+      const params = resolveSchemaRef(route.params);
+      const query = resolveSchemaRef(route.query);
+      const body = resolveSchemaRef(route.body);
+      const headers = resolveSchemaRef(route.headers);
+      const response = resolveSchemaRef(route.response);
+      return {
+        method: route.method,
+        path: route.fullPath,
+        operationId: route.operationId,
+        module: mod.name,
+        router: router.name,
+        middleware: route.middleware.map((m) => m.name),
+        ...params && { params },
+        ...query && { query },
+        ...body && { body },
+        ...headers && { headers },
+        ...response && { response }
+      };
+    }))),
+    schemas: Object.fromEntries(ir.schemas.filter((s) => s.isNamed && s.jsonSchema).map((s) => [s.name, s.jsonSchema])),
+    middleware: ir.middleware.map((mw) => ({
+      name: mw.name,
+      ...mw.provides?.jsonSchema && { provides: mw.provides.jsonSchema },
+      ...mw.requires?.jsonSchema && { requires: mw.requires.jsonSchema }
+    })),
+    dependencyGraph: {
+      initializationOrder: ir.dependencyGraph.initializationOrder,
+      edges: ir.dependencyGraph.edges.map((e) => ({
+        from: e.from,
+        to: e.to,
+        type: e.kind
+      }))
+    },
+    diagnostics: {
+      errors: ir.diagnostics.filter((d) => d.severity === "error").length,
+      warnings: ir.diagnostics.filter((d) => d.severity === "warning").length,
+      items: ir.diagnostics.map((d) => ({
+        severity: d.severity,
+        code: d.code,
+        message: d.message,
+        ...d.file && { file: d.file },
+        ...d.line && { line: d.line },
+        ...d.suggestion && { suggestion: d.suggestion }
+      }))
+    }
+  };
+}
+
+class ManifestGenerator extends BaseGenerator {
+  name = "manifest";
+  async generate(ir, outputDir) {
+    const manifest = buildManifest(ir);
+    const content = JSON.stringify(manifest, null, 2);
+    const outputPath = this.resolveOutputPath(outputDir, "manifest.json");
+    await writeFile2(outputPath, content);
+  }
+}
+
+// src/generators/openapi-generator.ts
+import { writeFile as writeFile3 } from "node:fs/promises";
+class OpenAPIGenerator extends BaseGenerator {
+  name = "openapi";
+  async generate(ir, outputDir) {
+    const doc = this.buildDocument(ir);
+    const outputPath = this.resolveOutputPath(outputDir, "openapi.json");
+    await writeFile3(outputPath, JSON.stringify(doc, null, 2));
+  }
+  buildDocument(ir) {
+    const version = ir.app.version ?? this.config.compiler.openapi.info.version;
+    const { description } = this.config.compiler.openapi.info;
+    const middlewareMap = new Map;
+    for (const mw of ir.middleware) {
+      middlewareMap.set(mw.name, mw);
+    }
+    const paths = {};
+    const components = {};
+    for (const mod of ir.modules) {
+      for (const router of mod.routers) {
+        for (const route of router.routes) {
+          const pathKey = this.convertPath(route.fullPath);
+          if (!paths[pathKey])
+            paths[pathKey] = {};
+          const method = route.method.toLowerCase();
+          const operation = this.buildOperation(route, middlewareMap, components);
+          paths[pathKey][method] = operation;
+        }
+      }
+    }
+    for (const schema of ir.schemas) {
+      if (schema.isNamed && schema.id && schema.jsonSchema) {
+        components[schema.id] = schema.jsonSchema;
+      }
+    }
+    const info = {
+      title: this.config.compiler.openapi.info.title,
+      version
+    };
+    if (description) {
+      info.description = description;
+    }
+    return {
+      openapi: "3.1.0",
+      info,
+      servers: [{ url: ir.app.basePath || "/" }],
+      paths,
+      components: { schemas: components },
+      tags: this.collectTags(ir)
+    };
+  }
+  buildOperation(route, middlewareMap, components) {
+    const operation = {
+      operationId: route.operationId,
+      tags: route.tags,
+      parameters: this.buildParameters(route, middlewareMap),
+      responses: this.buildResponses(route, components)
+    };
+    if (route.description) {
+      operation.description = route.description;
+    }
+    if (route.body) {
+      operation.requestBody = {
+        required: true,
+        content: {
+          "application/json": { schema: this.resolveAndLift(route.body, components) }
+        }
+      };
+    }
+    return operation;
+  }
+  buildResponses(route, components) {
+    if (!route.response) {
+      if (route.method === "DELETE") {
+        return { "204": { description: "No Content" } };
+      }
+      return { "200": { description: "OK" } };
+    }
+    const statusCode = this.getSuccessStatusCode(route.method);
+    return {
+      [statusCode]: {
+        description: "OK",
+        content: {
+          "application/json": { schema: this.resolveAndLift(route.response, components) }
+        }
+      }
+    };
+  }
+  resolveAndLift(schemaRef, components) {
+    const resolved = this.resolveSchemaRef(schemaRef);
+    if (schemaRef.kind === "inline" && resolved.$defs) {
+      return this.liftDefsToComponents(resolved, components);
+    }
+    return resolved;
+  }
+  getSuccessStatusCode(method) {
+    if (method === "POST")
+      return "201";
+    return "200";
+  }
+  convertPath(routePath) {
+    return routePath.replace(/:(\w+)/g, "{$1}");
+  }
+  buildParameters(route, middlewareMap) {
+    const params = [];
+    const headerMap = new Map;
+    for (const mwRef of route.middleware) {
+      const mw = middlewareMap.get(mwRef.name);
+      if (mw?.headers?.jsonSchema) {
+        this.extractHeaderParams(mw.headers.jsonSchema, headerMap);
+      }
+    }
+    if (route.params?.jsonSchema) {
+      const schema = route.params.jsonSchema;
+      for (const [name, propSchema] of Object.entries(schema.properties ?? {})) {
+        params.push({ name, in: "path", required: true, schema: propSchema });
+      }
+    }
+    if (route.query?.jsonSchema) {
+      this.extractParamsFromSchema(route.query.jsonSchema, "query", params);
+    }
+    if (route.headers?.jsonSchema) {
+      this.extractHeaderParams(route.headers.jsonSchema, headerMap);
+    }
+    params.push(...headerMap.values());
+    return params;
+  }
+  resolveSchemaRef(schemaRef) {
+    if (schemaRef.kind === "named") {
+      return { $ref: `#/components/schemas/${schemaRef.schemaName}` };
+    }
+    return schemaRef.jsonSchema ?? {};
+  }
+  extractParamsFromSchema(schema, location, target) {
+    const required = new Set(schema.required ?? []);
+    for (const [name, propSchema] of Object.entries(schema.properties ?? {})) {
+      target.push({ name, in: location, required: required.has(name), schema: propSchema });
+    }
+  }
+  extractHeaderParams(schema, headerMap) {
+    const required = new Set(schema.required ?? []);
+    for (const [name, propSchema] of Object.entries(schema.properties ?? {})) {
+      headerMap.set(name, { name, in: "header", required: required.has(name), schema: propSchema });
+    }
+  }
+  liftDefsToComponents(schema, components) {
+    const result = { ...schema };
+    if (result.$defs) {
+      for (const [name, defSchema] of Object.entries(result.$defs)) {
+        const lifted = this.liftDefsToComponents(defSchema, components);
+        let targetName = name;
+        if (components[name] && JSON.stringify(components[name]) !== JSON.stringify(lifted)) {
+          let suffix = 2;
+          while (components[`${name}_${suffix}`])
+            suffix++;
+          targetName = `${name}_${suffix}`;
+        }
+        components[targetName] = lifted;
+      }
+      delete result.$defs;
+    }
+    return this.rewriteRefs(result);
+  }
+  rewriteRefs(schema) {
+    const result = { ...schema };
+    if (result.$ref?.startsWith("#/$defs/")) {
+      result.$ref = result.$ref.replace("#/$defs/", "#/components/schemas/");
+    }
+    if (result.properties) {
+      const newProps = {};
+      for (const [key, value] of Object.entries(result.properties)) {
+        newProps[key] = this.rewriteRefs(value);
+      }
+      result.properties = newProps;
+    }
+    if (result.items) {
+      result.items = this.rewriteRefs(result.items);
+    }
+    for (const key of ["oneOf", "allOf", "anyOf"]) {
+      if (result[key]) {
+        result[key] = result[key].map((s) => this.rewriteRefs(s));
+      }
+    }
+    if (result.additionalProperties && typeof result.additionalProperties === "object") {
+      result.additionalProperties = this.rewriteRefs(result.additionalProperties);
+    }
+    return result;
+  }
+  collectTags(ir) {
+    const tagNames = new Set;
+    for (const mod of ir.modules) {
+      for (const router of mod.routers) {
+        for (const route of router.routes) {
+          for (const tag of route.tags) {
+            tagNames.add(tag);
+          }
+        }
+      }
+    }
+    return [...tagNames].sort().map((name) => ({ name }));
+  }
+}
+
+// src/generators/route-table-generator.ts
+import { writeFile as writeFile4 } from "node:fs/promises";
+function schemaRefName(ref) {
+  if (!ref || ref.kind !== "named")
+    return;
+  return ref.schemaName;
+}
+function buildRouteTable(ir) {
+  const routes = [];
+  for (const mod of ir.modules) {
+    for (const router of mod.routers) {
+      for (const route of router.routes) {
+        routes.push({
+          method: route.method,
+          path: route.fullPath,
+          operationId: route.operationId,
+          moduleName: mod.name,
+          routerName: router.name,
+          middleware: route.middleware.map((m) => m.name),
+          schemas: {
+            params: schemaRefName(route.params),
+            query: schemaRefName(route.query),
+            body: schemaRefName(route.body),
+            headers: schemaRefName(route.headers),
+            response: schemaRefName(route.response)
+          }
+        });
+      }
+    }
+  }
+  routes.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+  return { routes };
+}
+function renderRouteTableFile(manifest) {
+  const lines = [
+    "// Auto-generated by @vertz/compiler — do not edit",
+    "import type { HttpMethod } from '@vertz/compiler';",
+    "",
+    "export interface RouteTableEntry {",
+    "  method: HttpMethod;",
+    "  path: string;",
+    "  operationId: string;",
+    "  moduleName: string;",
+    "  routerName: string;",
+    "  middleware: string[];",
+    "  schemas: {",
+    "    params?: string;",
+    "    query?: string;",
+    "    body?: string;",
+    "    headers?: string;",
+    "    response?: string;",
+    "  };",
+    "}",
+    "",
+    "export const routeTable: RouteTableEntry[] = ["
+  ];
+  for (const route of manifest.routes) {
+    lines.push("  {");
+    lines.push(`    method: '${route.method}',`);
+    lines.push(`    path: '${route.path}',`);
+    lines.push(`    operationId: '${route.operationId}',`);
+    lines.push(`    moduleName: '${route.moduleName}',`);
+    lines.push(`    routerName: '${route.routerName}',`);
+    lines.push(`    middleware: [${route.middleware.map((m) => `'${m}'`).join(", ")}],`);
+    lines.push("    schemas: {");
+    for (const [key, value] of Object.entries(route.schemas)) {
+      if (value !== undefined) {
+        lines.push(`      ${key}: '${value}',`);
+      }
+    }
+    lines.push("    },");
+    lines.push("  },");
+  }
+  lines.push("];");
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+class RouteTableGenerator extends BaseGenerator {
+  name = "route-table";
+  async generate(ir, outputDir) {
+    const manifest = buildRouteTable(ir);
+    const content = renderRouteTableFile(manifest);
+    const outputPath = this.resolveOutputPath(outputDir, "routes.ts");
+    await writeFile4(outputPath, content);
+  }
+}
+
+// src/generators/schema-registry-generator.ts
+import { writeFile as writeFile5 } from "node:fs/promises";
+function buildSchemaRegistry(ir) {
+  const schemas = ir.schemas.filter((s) => s.isNamed).map((s) => ({
+    name: s.name,
+    ...s.id && { id: s.id },
+    importPath: s.sourceFile,
+    variableName: s.name,
+    ...s.jsonSchema && { jsonSchema: s.jsonSchema }
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  return { schemas };
+}
+function indentJson(value, indent) {
+  return JSON.stringify(value, null, 2).split(`
+`).map((line, i) => i === 0 ? line : `${indent}${line}`).join(`
+`);
+}
+function renderSchemaRegistryFile(manifest, outputDir) {
+  const lines = ["// Auto-generated by @vertz/compiler — do not edit", ""];
+  const importsByFile = new Map;
+  for (const schema of manifest.schemas) {
+    const resolvedPath = resolveImportPath(outputDir, schema.importPath);
+    const existing = importsByFile.get(resolvedPath) ?? [];
+    existing.push(schema.variableName);
+    importsByFile.set(resolvedPath, existing);
+  }
+  for (const [path, names] of importsByFile) {
+    lines.push(`import { ${names.join(", ")} } from '${path}';`);
+  }
+  if (manifest.schemas.length > 0) {
+    lines.push("");
+  }
+  lines.push("export const schemaRegistry = {");
+  for (const schema of manifest.schemas) {
+    lines.push(`  ${schema.variableName},`);
+  }
+  lines.push("} as const;");
+  lines.push("");
+  lines.push("export const jsonSchemas = {");
+  for (const schema of manifest.schemas) {
+    if (schema.jsonSchema) {
+      lines.push(`  ${schema.name}: ${indentJson(schema.jsonSchema, "  ")},`);
+    }
+  }
+  lines.push("} as const;");
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+class SchemaRegistryGenerator extends BaseGenerator {
+  name = "schema-registry";
+  async generate(ir, outputDir) {
+    const manifest = buildSchemaRegistry(ir);
+    const content = renderSchemaRegistryFile(manifest, outputDir);
+    const outputPath = this.resolveOutputPath(outputDir, "schemas.ts");
+    await writeFile5(outputPath, content);
+  }
+}
+
+// src/ir/builder.ts
+function createEmptyDependencyGraph() {
+  return {
+    nodes: [],
+    edges: [],
+    initializationOrder: [],
+    circularDependencies: []
+  };
+}
+function createEmptyAppIR() {
+  return {
+    app: {
+      basePath: "",
+      globalMiddleware: [],
+      moduleRegistrations: [],
+      sourceFile: "",
+      sourceLine: 0,
+      sourceColumn: 0
+    },
+    modules: [],
+    middleware: [],
+    schemas: [],
+    dependencyGraph: createEmptyDependencyGraph(),
+    diagnostics: []
+  };
+}
+function addDiagnosticsToIR(ir, diagnostics) {
+  return {
+    ...ir,
+    diagnostics: [...ir.diagnostics, ...diagnostics]
+  };
+}
+
+// src/validators/completeness-validator.ts
+var METHODS_WITHOUT_RESPONSE = new Set(["DELETE", "HEAD", "OPTIONS"]);
+var RESERVED_CTX_KEYS = new Set([
+  "params",
+  "body",
+  "query",
+  "headers",
+  "raw",
+  "state",
+  "options",
+  "env"
+]);
+
+class CompletenessValidator {
+  async validate(ir) {
+    const diagnostics = [];
+    this.checkResponseSchemas(ir, diagnostics);
+    this.checkUnusedServices(ir, diagnostics);
+    this.checkUnreferencedSchemas(ir, diagnostics);
+    this.checkDIWiring(ir, diagnostics);
+    this.checkMiddlewareChains(ir, diagnostics);
+    this.checkCtxKeyCollisions(ir, diagnostics);
+    this.checkDuplicateRoutes(ir, diagnostics);
+    this.checkPathParamMatch(ir, diagnostics);
+    this.checkModuleOptions(ir, diagnostics);
+    this.checkRoutePathFormat(ir, diagnostics);
+    return diagnostics;
+  }
+  checkResponseSchemas(ir, diagnostics) {
+    for (const route of allRoutes(ir)) {
+      if (!route.response && !METHODS_WITHOUT_RESPONSE.has(route.method)) {
+        diagnostics.push(createDiagnosticFromLocation(route, {
+          severity: "error",
+          code: "VERTZ_ROUTE_MISSING_RESPONSE",
+          message: `Route ${route.method} ${route.fullPath} has no response schema.`,
+          suggestion: "Add a 'response' property to the route config."
+        }));
+      }
+    }
+  }
+  checkUnusedServices(ir, diagnostics) {
+    const referenced = collectAllInjectedTokens(ir);
+    for (const mod of ir.modules) {
+      for (const exp of mod.exports) {
+        referenced.add(exp);
+      }
+      for (const svc of mod.services) {
+        if (!referenced.has(svc.name)) {
+          diagnostics.push(createDiagnosticFromLocation(svc, {
+            severity: "warning",
+            code: "VERTZ_DEAD_CODE",
+            message: `Service '${svc.name}' in module '${mod.name}' is never injected or exported.`
+          }));
+        }
+      }
+    }
+  }
+  checkUnreferencedSchemas(ir, diagnostics) {
+    const referenced = new Set;
+    function addRef(ref) {
+      if (ref?.kind === "named")
+        referenced.add(ref.schemaName);
+    }
+    for (const mod of ir.modules) {
+      addRef(mod.options);
+      for (const route of allModuleRoutes(mod.routers)) {
+        addRef(route.params);
+        addRef(route.query);
+        addRef(route.body);
+        addRef(route.headers);
+        addRef(route.response);
+      }
+    }
+    for (const mw of ir.middleware) {
+      addRef(mw.headers);
+      addRef(mw.params);
+      addRef(mw.query);
+      addRef(mw.body);
+      addRef(mw.requires);
+      addRef(mw.provides);
+    }
+    for (const schema of ir.schemas) {
+      if (!schema.isNamed)
+        continue;
+      if (referenced.has(schema.name))
+        continue;
+      diagnostics.push(createDiagnosticFromLocation(schema, {
+        severity: "warning",
+        code: "VERTZ_DEAD_CODE",
+        message: `Schema '${schema.name}' is not referenced by any route or middleware.`
+      }));
+    }
+  }
+  checkDIWiring(ir, diagnostics) {
+    const moduleExports = new Map;
+    for (const mod of ir.modules) {
+      moduleExports.set(mod.name, new Set(mod.exports));
+    }
+    for (const mod of ir.modules) {
+      const available = new Set(mod.services.map((s) => s.name));
+      for (const imp of mod.imports) {
+        if (imp.isEnvImport || !imp.sourceModule)
+          continue;
+        const exports = moduleExports.get(imp.sourceModule);
+        if (exports) {
+          for (const exp of exports) {
+            available.add(exp);
+          }
+        }
+      }
+      for (const svc of mod.services) {
+        this.checkInjectTokens(svc.name, "Service", svc.inject, available, svc, diagnostics);
+      }
+      for (const router of mod.routers) {
+        this.checkInjectTokens(router.name, "Router", router.inject, available, router, diagnostics);
+      }
+    }
+  }
+  checkInjectTokens(ownerName, ownerKind, inject, available, location, diagnostics) {
+    for (const inj of inject) {
+      if (available.has(inj.resolvedToken))
+        continue;
+      diagnostics.push(createDiagnosticFromLocation(location, {
+        severity: "error",
+        code: "VERTZ_SERVICE_INJECT_MISSING",
+        message: `${ownerKind} '${ownerName}' injects '${inj.resolvedToken}' which cannot be resolved.`
+      }));
+    }
+  }
+  checkMiddlewareChains(ir, diagnostics) {
+    const mwMap = new Map;
+    for (const mw of ir.middleware) {
+      mwMap.set(mw.name, mw);
+    }
+    const providedKeys = new Set;
+    for (const mwRef of ir.app.globalMiddleware) {
+      const mw = mwMap.get(mwRef.name);
+      if (!mw)
+        continue;
+      for (const key of extractSchemaPropertyKeys(mw.requires)) {
+        if (!providedKeys.has(key)) {
+          diagnostics.push(createDiagnosticFromLocation(mw, {
+            severity: "error",
+            code: "VERTZ_MW_REQUIRES_UNSATISFIED",
+            message: `Middleware '${mw.name}' requires '${key}' but no preceding middleware provides it.`
+          }));
+        }
+      }
+      for (const key of extractSchemaPropertyKeys(mw.provides)) {
+        providedKeys.add(key);
+      }
+    }
+  }
+  checkModuleOptions(ir, diagnostics) {
+    const moduleMap = new Map(ir.modules.map((m) => [m.name, m]));
+    for (const reg of ir.app.moduleRegistrations) {
+      const mod = moduleMap.get(reg.moduleName);
+      if (!mod)
+        continue;
+      if (reg.options && !mod.options) {
+        diagnostics.push(createDiagnostic({
+          severity: "warning",
+          code: "VERTZ_MODULE_OPTIONS_INVALID",
+          message: `Module '${reg.moduleName}' received options but does not define an options schema.`
+        }));
+      }
+      if (!reg.options && mod.options) {
+        diagnostics.push(createDiagnostic({
+          severity: "error",
+          code: "VERTZ_MODULE_OPTIONS_INVALID",
+          message: `Module '${reg.moduleName}' requires options but none were provided in .register().`
+        }));
+      }
+    }
+  }
+  checkRoutePathFormat(ir, diagnostics) {
+    for (const route of allRoutes(ir)) {
+      if (!route.path.startsWith("/")) {
+        diagnostics.push(createDiagnosticFromLocation(route, {
+          severity: "error",
+          code: "VERTZ_RT_INVALID_PATH",
+          message: `Route path '${route.path}' must start with '/'.`,
+          suggestion: `Change the path to '/${route.path}'.`
+        }));
+      }
+    }
+  }
+  checkPathParamMatch(ir, diagnostics) {
+    for (const route of allRoutes(ir)) {
+      if (!route.params)
+        continue;
+      const pathParams = new Set(extractPathParams(route.fullPath));
+      const schemaParams = new Set(extractSchemaPropertyKeys(route.params));
+      for (const param of pathParams) {
+        if (!schemaParams.has(param)) {
+          diagnostics.push(createDiagnosticFromLocation(route, {
+            severity: "error",
+            code: "VERTZ_ROUTE_PARAM_MISMATCH",
+            message: `Route ${route.method} ${route.fullPath} has path parameter ':${param}' not defined in params schema.`
+          }));
+        }
+      }
+      for (const param of schemaParams) {
+        if (!pathParams.has(param)) {
+          diagnostics.push(createDiagnosticFromLocation(route, {
+            severity: "warning",
+            code: "VERTZ_ROUTE_PARAM_MISMATCH",
+            message: `Route ${route.method} ${route.fullPath} params schema defines '${param}' which is not a path parameter.`
+          }));
+        }
+      }
+    }
+  }
+  checkDuplicateRoutes(ir, diagnostics) {
+    const seen = new Map;
+    for (const mod of ir.modules) {
+      for (const router of mod.routers) {
+        for (const route of router.routes) {
+          const key = `${route.method} ${route.fullPath}`;
+          const existing = seen.get(key);
+          if (existing) {
+            diagnostics.push(createDiagnosticFromLocation(route, {
+              severity: "error",
+              code: "VERTZ_ROUTE_DUPLICATE",
+              message: `Duplicate route: ${key} defined in ${existing} and ${router.name}.`
+            }));
+          } else {
+            seen.set(key, router.name);
+          }
+        }
+      }
+    }
+  }
+  checkCtxKeyCollisions(ir, diagnostics) {
+    const keyProviders = new Map;
+    for (const mw of ir.middleware) {
+      const providedKeys = extractSchemaPropertyKeys(mw.provides);
+      for (const key of providedKeys) {
+        if (RESERVED_CTX_KEYS.has(key)) {
+          diagnostics.push(createDiagnosticFromLocation(mw, {
+            severity: "error",
+            code: "VERTZ_CTX_COLLISION",
+            message: `Context key '${key}' provided by middleware '${mw.name}' is a reserved ctx property.`
+          }));
+          continue;
+        }
+        const existing = keyProviders.get(key);
+        if (existing) {
+          diagnostics.push(createDiagnosticFromLocation(mw, {
+            severity: "error",
+            code: "VERTZ_CTX_COLLISION",
+            message: `Context key '${key}' is provided by both '${existing}' and '${mw.name}'.`
+          }));
+        } else {
+          keyProviders.set(key, mw.name);
+        }
+      }
+    }
+    const injectedNames = new Set;
+    for (const mod of ir.modules) {
+      for (const router of mod.routers) {
+        for (const inj of router.inject) {
+          injectedNames.add(inj.resolvedToken);
+        }
+      }
+    }
+    for (const mw of ir.middleware) {
+      for (const key of extractSchemaPropertyKeys(mw.provides)) {
+        if (injectedNames.has(key)) {
+          diagnostics.push(createDiagnosticFromLocation(mw, {
+            severity: "error",
+            code: "VERTZ_CTX_COLLISION",
+            message: `Context key '${key}' provided by middleware '${mw.name}' collides with injected service name.`
+          }));
+        }
+      }
+    }
+  }
+}
+function extractSchemaPropertyKeys(ref) {
+  if (!ref)
+    return [];
+  const props = ref.jsonSchema?.properties;
+  if (!props || typeof props !== "object")
+    return [];
+  return Object.keys(props);
+}
+function extractPathParams(path) {
+  return path.split("/").filter((s) => s.startsWith(":")).map((s) => s.slice(1));
+}
+function* allModuleRoutes(routers) {
+  for (const router of routers) {
+    yield* router.routes;
+  }
+}
+function* allRoutes(ir) {
+  for (const mod of ir.modules) {
+    yield* allModuleRoutes(mod.routers);
+  }
+}
+function collectAllInjectedTokens(ir) {
+  const tokens = new Set;
+  for (const mod of ir.modules) {
+    for (const router of mod.routers) {
+      for (const inj of router.inject) {
+        tokens.add(inj.resolvedToken);
+      }
+    }
+    for (const svc of mod.services) {
+      for (const inj of svc.inject) {
+        tokens.add(inj.resolvedToken);
+      }
+    }
+  }
+  for (const mw of ir.middleware) {
+    for (const inj of mw.inject) {
+      tokens.add(inj.resolvedToken);
+    }
+  }
+  return tokens;
+}
+
+// src/validators/module-validator.ts
+class ModuleValidator {
+  async validate(ir) {
+    const diagnostics = [];
+    for (const mod of ir.modules) {
+      this.checkExports(mod, diagnostics);
+      this.checkOwnership(mod, diagnostics);
+    }
+    this.checkCircularDependencies(ir, diagnostics);
+    return diagnostics;
+  }
+  checkExports(mod, diagnostics) {
+    const serviceNames = new Set(mod.services.map((s) => s.name));
+    for (const exp of mod.exports) {
+      if (!serviceNames.has(exp)) {
+        diagnostics.push(createDiagnostic({
+          severity: "error",
+          code: "VERTZ_MODULE_EXPORT_INVALID",
+          message: `Module '${mod.name}' exports '${exp}' which is not one of its services.`,
+          suggestion: `Either add '${exp}' as a service or remove it from exports.`
+        }));
+      }
+    }
+  }
+  checkOwnership(mod, diagnostics) {
+    for (const svc of mod.services) {
+      if (svc.moduleName !== mod.name) {
+        diagnostics.push(createDiagnostic({
+          severity: "error",
+          code: "VERTZ_MODULE_WRONG_OWNERSHIP",
+          message: `Service '${svc.name}' declares module '${svc.moduleName}' but is listed under module '${mod.name}'.`
+        }));
+      }
+    }
+  }
+  checkCircularDependencies(ir, diagnostics) {
+    for (const cycle of ir.dependencyGraph.circularDependencies) {
+      const path = [...cycle, cycle.at(0)].join(" -> ");
+      diagnostics.push(createDiagnostic({
+        severity: "error",
+        code: "VERTZ_MODULE_CIRCULAR",
+        message: `Circular dependency detected: ${path}.`,
+        suggestion: "Break the cycle by extracting shared code into a separate module that both can import."
+      }));
+    }
+  }
+}
+
+// src/validators/naming-validator.ts
+var VALID_OPERATIONS2 = ["create", "read", "update", "list", "delete"];
+var VALID_PARTS2 = ["Body", "Response", "Query", "Params", "Headers"];
+var NULL_PARSED = { operation: null, entity: null, part: null };
+function isUpperCase(char) {
+  return char >= "A" && char <= "Z";
+}
+function isFullyParsed(parsed) {
+  return parsed.operation !== null && parsed.entity !== null && parsed.part !== null;
+}
+
+class NamingValidator {
+  async validate(ir) {
+    const diagnostics = [];
+    for (const schema of ir.schemas) {
+      if (!schema.isNamed)
+        continue;
+      if (isFullyParsed(this.parseSchemaName(schema.name)))
+        continue;
+      diagnostics.push(createDiagnosticFromLocation(schema, {
+        severity: "warning",
+        code: "VERTZ_SCHEMA_NAMING",
+        message: `Schema '${schema.name}' does not follow the {operation}{Entity}{Part} naming convention.`,
+        suggestion: this.suggestFix(schema.name)
+      }));
+    }
+    return diagnostics;
+  }
+  parseSchemaName(name) {
+    if (!name)
+      return NULL_PARSED;
+    for (const op of VALID_OPERATIONS2) {
+      if (!name.startsWith(op))
+        continue;
+      const rest = name.slice(op.length);
+      if (!rest || !isUpperCase(rest[0]))
+        continue;
+      for (const part of VALID_PARTS2) {
+        if (!rest.endsWith(part))
+          continue;
+        const entity = rest.slice(0, -part.length);
+        if (!entity)
+          continue;
+        return { operation: op, entity, part };
+      }
+      return { operation: op, entity: null, part: null };
+    }
+    return NULL_PARSED;
+  }
+  suggestFix(name) {
+    const lowerName = name[0].toLowerCase() + name.slice(1);
+    if (isFullyParsed(this.parseSchemaName(lowerName))) {
+      return `Use lowercase operation: '${lowerName}'`;
+    }
+    for (const op of VALID_OPERATIONS2) {
+      if (!name.startsWith(op))
+        continue;
+      const rest = name.slice(op.length);
+      if (!rest)
+        continue;
+      const fixed = op + rest[0].toUpperCase() + rest.slice(1);
+      if (isFullyParsed(this.parseSchemaName(fixed))) {
+        return `Use PascalCase entity: '${fixed}'`;
+      }
+    }
+    return;
+  }
+}
+
+// src/validators/placement-validator.ts
+class PlacementValidator {
+  async validate(ir) {
+    const diagnostics = [];
+    for (const schema of ir.schemas) {
+      this.checkFileLocation(schema, diagnostics);
+    }
+    this.checkMixedExports(ir.schemas, diagnostics);
+    return diagnostics;
+  }
+  checkFileLocation(schema, diagnostics) {
+    const file = schema.sourceFile;
+    const inSchemasDir = file.includes("/schemas/") || file.includes("\\schemas\\");
+    if (!inSchemasDir) {
+      diagnostics.push(createDiagnosticFromLocation(schema, {
+        severity: "warning",
+        code: "VERTZ_SCHEMA_PLACEMENT",
+        message: `Schema '${schema.name}' is not in a schemas/ directory.`,
+        suggestion: `Move schema file to a 'schemas/' directory.`
+      }));
+      return;
+    }
+    if (!file.endsWith(".schema.ts")) {
+      diagnostics.push(createDiagnosticFromLocation(schema, {
+        severity: "warning",
+        code: "VERTZ_SCHEMA_PLACEMENT",
+        message: `Schema file '${file}' does not use the .schema.ts suffix.`,
+        suggestion: `Rename file to use '.schema.ts' suffix.`
+      }));
+    }
+  }
+  checkMixedExports(schemas, diagnostics) {
+    const byFile = groupBy(schemas, (s) => s.sourceFile);
+    for (const [file, fileSchemas] of byFile) {
+      const withConvention = fileSchemas.filter((s) => s.namingConvention.operation && s.namingConvention.entity);
+      if (withConvention.length < 2)
+        continue;
+      const operations = new Set(withConvention.map((s) => s.namingConvention.operation));
+      if (operations.size > 1) {
+        diagnostics.push(createDiagnostic({
+          severity: "warning",
+          code: "VERTZ_SCHEMA_PLACEMENT",
+          message: `Schema file '${file}' exports schemas with mixed operations: ${[...operations].join(", ")}.`,
+          file
+        }));
+      }
+      const entities = new Set(withConvention.map((s) => s.namingConvention.entity));
+      if (entities.size > 1) {
+        diagnostics.push(createDiagnostic({
+          severity: "warning",
+          code: "VERTZ_SCHEMA_PLACEMENT",
+          message: `Schema file '${file}' exports schemas with mixed entities: ${[...entities].join(", ")}.`,
+          file
+        }));
+      }
+    }
+  }
+}
+function groupBy(items, keyFn) {
+  const map = new Map;
+  for (const item of items) {
+    const key = keyFn(item);
+    const group = map.get(key);
+    if (group) {
+      group.push(item);
+    } else {
+      map.set(key, [item]);
+    }
+  }
+  return map;
+}
+
+// src/compiler.ts
+class Compiler {
+  config;
+  deps;
+  constructor(config, dependencies) {
+    this.config = config;
+    this.deps = dependencies;
+  }
+  getConfig() {
+    return this.config;
+  }
+  async analyze() {
+    const ir = createEmptyAppIR();
+    const { analyzers } = this.deps;
+    const envResult = await analyzers.env.analyze();
+    const schemaResult = await analyzers.schema.analyze();
+    const moduleResult = await analyzers.module.analyze();
+    const middlewareResult = await analyzers.middleware.analyze();
+    const appResult = await analyzers.app.analyze();
+    const depGraphResult = await analyzers.dependencyGraph.analyze();
+    ir.env = envResult.env;
+    ir.schemas = schemaResult.schemas;
+    ir.modules = moduleResult.modules;
+    ir.middleware = middlewareResult.middleware;
+    ir.app = appResult.app;
+    ir.dependencyGraph = depGraphResult.graph;
+    return ir;
+  }
+  async validate(ir) {
+    const allDiagnostics = [];
+    for (const validator of this.deps.validators) {
+      const diagnostics = await validator.validate(ir);
+      allDiagnostics.push(...diagnostics);
+    }
+    return allDiagnostics;
+  }
+  async generate(ir) {
+    const outputDir = this.config.compiler.outputDir;
+    await Promise.all(this.deps.generators.map((g) => g.generate(ir, outputDir)));
+  }
+  async compile() {
+    const ir = await this.analyze();
+    const diagnostics = await this.validate(ir);
+    const hasErrorDiags = hasErrors(diagnostics);
+    if (!hasErrorDiags || this.config.forceGenerate) {
+      await this.generate(ir);
+    }
+    return {
+      success: !hasErrorDiags,
+      ir: { ...ir, diagnostics },
+      diagnostics
+    };
+  }
+}
+function createCompiler(config) {
+  const resolved = resolveConfig(config);
+  const project = new Project({ tsConfigFilePath: "tsconfig.json" });
+  const deps = {
+    analyzers: {
+      env: new EnvAnalyzer(project, resolved),
+      schema: new SchemaAnalyzer(project, resolved),
+      middleware: new MiddlewareAnalyzer(project, resolved),
+      module: new ModuleAnalyzer(project, resolved),
+      app: new AppAnalyzer(project, resolved),
+      dependencyGraph: new DependencyGraphAnalyzer(project, resolved)
+    },
+    validators: [
+      new CompletenessValidator,
+      new ModuleValidator,
+      new NamingValidator,
+      new PlacementValidator
+    ],
+    generators: [
+      new BootGenerator(resolved),
+      new RouteTableGenerator(resolved),
+      new SchemaRegistryGenerator(resolved),
+      new ManifestGenerator(resolved),
+      new OpenAPIGenerator(resolved)
+    ]
+  };
+  return new Compiler(resolved, deps);
+}
+// src/incremental.ts
+import { basename, dirname } from "node:path";
+
+// src/ir/merge.ts
+function mergeByName(base, partial) {
+  if (!partial)
+    return base;
+  const partialNames = new Set(partial.map((item) => item.name));
+  const preserved = base.filter((item) => !partialNames.has(item.name));
+  return [...preserved, ...partial];
+}
+function mergeIR(base, partial) {
+  return {
+    ...base,
+    modules: mergeByName(base.modules, partial.modules),
+    schemas: mergeByName(base.schemas, partial.schemas),
+    middleware: mergeByName(base.middleware, partial.middleware),
+    dependencyGraph: partial.dependencyGraph ?? base.dependencyGraph,
+    diagnostics: []
+  };
+}
+
+// src/incremental.ts
+function categorize(path, options) {
+  const file = basename(path);
+  if (file.endsWith(".schema.ts"))
+    return "schema";
+  if (file.endsWith(".router.ts"))
+    return "router";
+  if (file.endsWith(".service.ts"))
+    return "service";
+  if (file.endsWith(".module.ts"))
+    return "module";
+  if (path.includes("middleware/"))
+    return "middleware";
+  if (options.entryFile && path === options.entryFile)
+    return "app-entry";
+  if (file.startsWith(".env"))
+    return "env";
+  if (file === "vertz.config.ts")
+    return "config";
+  return null;
+}
+function categorizeChanges(changes, options = {}) {
+  const result = {
+    schema: [],
+    router: [],
+    service: [],
+    module: [],
+    middleware: [],
+    requiresFullRecompile: false,
+    requiresReboot: false
+  };
+  for (const change of changes) {
+    const category = categorize(change.path, options);
+    switch (category) {
+      case "schema":
+        result.schema.push(change);
+        break;
+      case "router":
+        result.router.push(change);
+        break;
+      case "service":
+        result.service.push(change);
+        break;
+      case "module":
+        result.module.push(change);
+        break;
+      case "middleware":
+        result.middleware.push(change);
+        break;
+      case "app-entry":
+        result.requiresFullRecompile = true;
+        break;
+      case "env":
+        result.requiresReboot = true;
+        result.rebootReason = "env";
+        break;
+      case "config":
+        result.requiresReboot = true;
+        result.rebootReason = "config";
+        break;
+    }
+  }
+  return result;
+}
+function findAffectedModules(categorized, ir) {
+  const affected = new Set;
+  for (const change of categorized.module) {
+    const mod = ir.modules.find((m) => m.sourceFile === change.path);
+    if (mod)
+      affected.add(mod.name);
+  }
+  for (const change of categorized.service) {
+    for (const mod of ir.modules) {
+      if (mod.services.some((s) => s.sourceFile === change.path)) {
+        affected.add(mod.name);
+      }
+    }
+  }
+  for (const change of categorized.router) {
+    for (const mod of ir.modules) {
+      if (mod.routers.some((r) => r.sourceFile === change.path)) {
+        affected.add(mod.name);
+      }
+    }
+  }
+  for (const change of categorized.schema) {
+    for (const mod of ir.modules) {
+      const moduleDir = dirname(mod.sourceFile);
+      if (change.path.startsWith(moduleDir)) {
+        affected.add(mod.name);
+      }
+    }
+  }
+  return [...affected];
+}
+
+class IncrementalCompiler {
+  currentIR;
+  compiler;
+  constructor(compiler) {
+    this.compiler = compiler;
+    this.currentIR = createEmptyAppIR();
+  }
+  async initialCompile() {
+    const result = await this.compiler.compile();
+    this.currentIR = result.ir;
+    return result;
+  }
+  async handleChanges(changes) {
+    const categorized = categorizeChanges(changes, {
+      entryFile: this.compiler.getConfig().compiler.entryFile
+    });
+    if (categorized.requiresReboot) {
+      return { kind: "reboot", reason: categorized.rebootReason ?? "unknown" };
+    }
+    if (categorized.requiresFullRecompile) {
+      const result = await this.compiler.compile();
+      this.currentIR = result.ir;
+      return { kind: "full-recompile" };
+    }
+    const partialIR = await this.compiler.analyze();
+    this.currentIR = mergeIR(this.currentIR, partialIR);
+    const diagnostics = await this.compiler.validate(this.currentIR);
+    if (!hasErrors(diagnostics)) {
+      await this.compiler.generate(this.currentIR);
+    }
+    const affectedModules = findAffectedModules(categorized, this.currentIR);
+    return {
+      kind: "incremental",
+      affectedModules,
+      diagnostics
+    };
+  }
+  getCurrentIR() {
+    return this.currentIR;
+  }
+}
+// src/typecheck.ts
+import { execFile, spawn } from "node:child_process";
+function parseTscOutput(output) {
+  const diagnostics = [];
+  const pattern = /^(.+)\((\d+),(\d+)\): error TS(\d+): (.+)$/gm;
+  let match = pattern.exec(output);
+  while (match !== null) {
+    diagnostics.push({
+      file: match[1],
+      line: Number.parseInt(match[2], 10),
+      column: Number.parseInt(match[3], 10),
+      code: Number.parseInt(match[4], 10),
+      message: match[5]
+    });
+    match = pattern.exec(output);
+  }
+  return diagnostics;
+}
+function parseWatchBlock(block) {
+  const diagnostics = parseTscOutput(block);
+  const foundMatch = /Found (\d+) error/.exec(block);
+  const errorCount = foundMatch ? Number.parseInt(foundMatch[1], 10) : diagnostics.length;
+  return {
+    success: errorCount === 0,
+    diagnostics
+  };
+}
+async function* typecheckWatch(options = {}) {
+  const proc = options.spawner?.() ?? spawn("tsc", ["--noEmit", "--watch", ...options.tsconfigPath ? ["--project", options.tsconfigPath] : []], {
+    cwd: process.cwd()
+  });
+  const completionMarker = /Found \d+ error/;
+  let buffer = "";
+  const results = [];
+  let resolve = null;
+  let done = false;
+  const onData = (chunk) => {
+    buffer += chunk.toString();
+    if (completionMarker.test(buffer)) {
+      const result = parseWatchBlock(buffer);
+      buffer = "";
+      results.push(result);
+      resolve?.();
+    }
+  };
+  proc.stdout?.on("data", onData);
+  proc.stderr?.on("data", onData);
+  proc.on("close", () => {
+    done = true;
+    resolve?.();
+  });
+  try {
+    while (!done || results.length > 0) {
+      const next = results.shift();
+      if (next) {
+        yield next;
+      } else if (!done) {
+        await new Promise((r) => {
+          resolve = r;
+        });
+      }
+    }
+  } finally {
+    proc.kill();
+  }
+}
+async function typecheck(options = {}) {
+  const args = ["--noEmit"];
+  if (options.tsconfigPath) {
+    args.push("--project", options.tsconfigPath);
+  }
+  return new Promise((resolve) => {
+    execFile("tsc", args, { cwd: process.cwd() }, (error, stdout, stderr) => {
+      const output = stdout + stderr;
+      const diagnostics = parseTscOutput(output);
+      resolve({
+        success: !error,
+        diagnostics
+      });
+    });
+  });
+}
+// src/utils/schema-executor.ts
+function createSchemaExecutor(_rootDir) {
+  const diagnostics = [];
+  function addError(message, file) {
+    diagnostics.push(createDiagnostic({
+      severity: "error",
+      code: "VERTZ_SCHEMA_EXECUTION",
+      message,
+      file
+    }));
+    return null;
+  }
+  return {
+    async execute(schemaName, sourceFile) {
+      try {
+        const mod = await import(sourceFile);
+        const schema = mod[schemaName];
+        if (!schema) {
+          return addError(`Export '${schemaName}' not found in '${sourceFile}'`, sourceFile);
+        }
+        if (typeof schema.toJSONSchema !== "function") {
+          return addError(`Export '${schemaName}' in '${sourceFile}' does not have a toJSONSchema() method`, sourceFile);
+        }
+        return { jsonSchema: schema.toJSONSchema() };
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return addError(`Failed to execute schema '${schemaName}' from '${sourceFile}': ${detail}`, sourceFile);
+      }
+    },
+    getDiagnostics() {
+      return [...diagnostics];
+    }
+  };
+}
+export {
+  typecheckWatch,
+  typecheck,
+  resolveImportPath,
+  resolveIdentifier,
+  resolveExport,
+  resolveConfig,
+  renderSchemaRegistryFile,
+  renderRouteTableFile,
+  renderBootFile,
+  parseWatchBlock,
+  parseTscOutput,
+  parseSchemaName,
+  parseInjectRefs,
+  parseImports,
+  mergeIR,
+  mergeDiagnostics,
+  isSchemaFile,
+  isSchemaExpression,
+  isFromImport,
+  hasErrors,
+  getVariableNameForCall,
+  getStringValue,
+  getSourceLocation,
+  getPropertyValue,
+  getProperties,
+  getNumberValue,
+  getBooleanValue,
+  getArrayElements,
+  findMethodCallsOnVariable,
+  findCallExpressions,
+  findAffectedModules,
+  filterBySeverity,
+  extractSchemaId,
+  extractObjectLiteral,
+  extractMethodSignatures,
+  extractIdentifierNames,
+  defineConfig,
+  createSchemaExecutor,
+  createNamedSchemaRef,
+  createInlineSchemaRef,
+  createEmptyDependencyGraph,
+  createEmptyAppIR,
+  createDiagnosticFromLocation,
+  createDiagnostic,
+  createCompiler,
+  categorizeChanges,
+  buildSchemaRegistry,
+  buildRouteTable,
+  buildManifest,
+  buildBootManifest,
+  addDiagnosticsToIR,
+  ServiceAnalyzer,
+  SchemaRegistryGenerator,
+  SchemaAnalyzer,
+  RouteTableGenerator,
+  RouteAnalyzer,
+  PlacementValidator,
+  OpenAPIGenerator,
+  NamingValidator,
+  ModuleValidator,
+  ModuleAnalyzer,
+  MiddlewareAnalyzer,
+  ManifestGenerator,
+  IncrementalCompiler,
+  EnvAnalyzer,
+  DependencyGraphAnalyzer,
+  CompletenessValidator,
+  Compiler,
+  BootGenerator,
+  BaseGenerator,
+  BaseAnalyzer,
+  AppAnalyzer
+};