@vertz/compiler 0.1.0 → 0.2.3

package/README.md

@@ -0,0 +1,20 @@
+# @vertz/compiler
+
+> **Internal package** — You don't use this directly. It powers `vertz build`, `vertz dev`, and `vertz codegen` behind the scenes.
+
+Static analysis and code generation for Vertz applications. Analyzes TypeScript source code to extract application structure (routes, schemas, modules, middleware), validates conventions, and generates runtime artifacts like boot files, route tables, and OpenAPI specs.
+
+## Who uses this
+
+- **`@vertz/cli`** — All CLI commands (`vertz build`, `vertz dev`, `vertz check`) invoke the compiler.
+- **`@vertz/codegen`** — Consumes the compiler's intermediate representation (IR) to generate SDKs and CLIs.
+- **Framework contributors** — See [INTERNALS.md](./INTERNALS.md) for architecture, pipeline stages, and extension points.
+
+## Related Packages
+
+- [`@vertz/cli`](../cli) — The CLI that invokes the compiler
+- [`@vertz/codegen`](../codegen) — Code generation from compiler IR
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 type DiagnosticSeverity = "error" | "warning" | "info";
-type DiagnosticCode = "VERTZ_SCHEMA_NAMING" | "VERTZ_SCHEMA_PLACEMENT" | "VERTZ_SCHEMA_EXECUTION" | "VERTZ_SCHEMA_MISSING_ID" | "VERTZ_SCHEMA_DYNAMIC_NAME" | "VERTZ_MODULE_CIRCULAR" | "VERTZ_MODULE_EXPORT_INVALID" | "VERTZ_MODULE_IMPORT_MISSING" | "VERTZ_MODULE_DUPLICATE_NAME" | "VERTZ_MODULE_DYNAMIC_NAME" | "VERTZ_MODULE_OPTIONS_INVALID" | "VERTZ_MODULE_WRONG_OWNERSHIP" | "VERTZ_SERVICE_INJECT_MISSING" | "VERTZ_SERVICE_UNUSED" | "VERTZ_SERVICE_DYNAMIC_NAME" | "VERTZ_ENV_MISSING_DEFAULT" | "VERTZ_ENV_DUPLICATE" | "VERTZ_ENV_DYNAMIC_CONFIG" | "VERTZ_MW_MISSING_NAME" | "VERTZ_MW_MISSING_HANDLER" | "VERTZ_MW_DYNAMIC_NAME" | "VERTZ_MW_NON_OBJECT_CONFIG" | "VERTZ_MW_REQUIRES_UNSATISFIED" | "VERTZ_MW_PROVIDES_COLLISION" | "VERTZ_MW_ORDER_INVALID" | "VERTZ_RT_UNKNOWN_MODULE_DEF" | "VERTZ_RT_DYNAMIC_PATH" | "VERTZ_RT_MISSING_HANDLER" | "VERTZ_RT_MISSING_PREFIX" | "VERTZ_RT_DYNAMIC_CONFIG" | "VERTZ_RT_INVALID_PATH" | "VERTZ_ROUTE_DUPLICATE" | "VERTZ_ROUTE_PARAM_MISMATCH" | "VERTZ_ROUTE_MISSING_RESPONSE" | "VERTZ_APP_MISSING" | "VERTZ_APP_NOT_FOUND" | "VERTZ_APP_DUPLICATE" | "VERTZ_APP_BASEPATH_FORMAT" | "VERTZ_APP_INLINE_MODULE" | "VERTZ_DEP_CYCLE" | "VERTZ_DEP_CIRCULAR" | "VERTZ_DEP_UNRESOLVED_INJECT" | "VERTZ_DEP_INIT_ORDER" | "VERTZ_CTX_COLLISION" | "VERTZ_DEAD_CODE";
+type DiagnosticCode = "VERTZ_SCHEMA_NAMING" | "VERTZ_SCHEMA_PLACEMENT" | "VERTZ_SCHEMA_EXECUTION" | "VERTZ_SCHEMA_MISSING_ID" | "VERTZ_SCHEMA_DYNAMIC_NAME" | "VERTZ_MODULE_CIRCULAR" | "VERTZ_MODULE_EXPORT_INVALID" | "VERTZ_MODULE_IMPORT_MISSING" | "VERTZ_MODULE_DUPLICATE_NAME" | "VERTZ_MODULE_DYNAMIC_NAME" | "VERTZ_MODULE_OPTIONS_INVALID" | "VERTZ_MODULE_WRONG_OWNERSHIP" | "VERTZ_SERVICE_INJECT_MISSING" | "VERTZ_SERVICE_UNUSED" | "VERTZ_SERVICE_DYNAMIC_NAME" | "VERTZ_ENV_MISSING_DEFAULT" | "VERTZ_ENV_DUPLICATE" | "VERTZ_ENV_DYNAMIC_CONFIG" | "VERTZ_MW_MISSING_NAME" | "VERTZ_MW_MISSING_HANDLER" | "VERTZ_MW_DYNAMIC_NAME" | "VERTZ_MW_NON_OBJECT_CONFIG" | "VERTZ_MW_REQUIRES_UNSATISFIED" | "VERTZ_MW_PROVIDES_COLLISION" | "VERTZ_MW_ORDER_INVALID" | "VERTZ_RT_UNKNOWN_MODULE_DEF" | "VERTZ_RT_DYNAMIC_PATH" | "VERTZ_RT_MISSING_HANDLER" | "VERTZ_RT_MISSING_PREFIX" | "VERTZ_RT_DYNAMIC_CONFIG" | "VERTZ_RT_INVALID_PATH" | "VERTZ_ROUTE_DUPLICATE" | "VERTZ_ROUTE_PARAM_MISMATCH" | "VERTZ_ROUTE_MISSING_RESPONSE" | "VERTZ_APP_MISSING" | "VERTZ_APP_NOT_FOUND" | "VERTZ_APP_DUPLICATE" | "VERTZ_APP_BASEPATH_FORMAT" | "VERTZ_APP_INLINE_MODULE" | "VERTZ_DEP_CYCLE" | "VERTZ_DEP_CIRCULAR" | "VERTZ_DEP_UNRESOLVED_INJECT" | "VERTZ_DEP_INIT_ORDER" | "VERTZ_CTX_COLLISION" | "VERTZ_DEAD_CODE" | "ENTITY_MISSING_ARGS" | "ENTITY_NON_LITERAL_NAME" | "ENTITY_INVALID_NAME" | "ENTITY_DUPLICATE_NAME" | "ENTITY_CONFIG_NOT_OBJECT" | "ENTITY_MISSING_MODEL" | "ENTITY_MODEL_UNRESOLVABLE" | "ENTITY_ACTION_NAME_COLLISION" | "ENTITY_ACTION_MISSING_SCHEMA" | "ENTITY_ACTION_INVALID_METHOD" | "ENTITY_UNKNOWN_ACCESS_OP" | "ENTITY_UNRESOLVED_IMPORT" | "ENTITY_ROUTE_COLLISION" | "ENTITY_NO_ROUTES";
 interface SourceContext {
 	lines: {
 		number: number;
@@ -37,6 +37,7 @@ interface AppIR {
 	modules: ModuleIR[];
 	middleware: MiddlewareIR[];
 	schemas: SchemaIR[];
+	entities: EntityIR[];
 	dependencyGraph: DependencyGraphIR;
 	diagnostics: Diagnostic[];
 }
@@ -133,6 +134,7 @@ interface MiddlewareRef {
 interface SchemaIR extends SourceLocation {
 	name: string;
 	id?: string;
+	moduleName: string;
 	namingConvention: SchemaNameParts;
 	jsonSchema?: Record<string, unknown>;
 	isNamed: boolean;
@@ -153,6 +155,60 @@ interface InlineSchemaRef {
 	kind: "inline";
 	sourceFile: string;
 	jsonSchema?: Record<string, unknown>;
+	resolvedFields?: ResolvedField[];
+}
+/** Structured field info extracted from resolved TypeScript types. */
+interface ResolvedField {
+	name: string;
+	tsType: "string" | "number" | "boolean" | "date" | "unknown";
+	optional: boolean;
+}
+interface EntityIR extends SourceLocation {
+	name: string;
+	modelRef: EntityModelRef;
+	access: EntityAccessIR;
+	hooks: EntityHooksIR;
+	actions: EntityActionIR[];
+	relations: EntityRelationIR[];
+}
+interface EntityModelRef {
+	variableName: string;
+	importSource?: string;
+	tableName?: string;
+	schemaRefs: EntityModelSchemaRefs;
+}
+interface EntityModelSchemaRefs {
+	response?: SchemaRef;
+	createInput?: SchemaRef;
+	updateInput?: SchemaRef;
+	resolved: boolean;
+}
+interface EntityAccessIR {
+	list: EntityAccessRuleKind;
+	get: EntityAccessRuleKind;
+	create: EntityAccessRuleKind;
+	update: EntityAccessRuleKind;
+	delete: EntityAccessRuleKind;
+	custom: Record<string, EntityAccessRuleKind>;
+}
+type EntityAccessRuleKind = "none" | "false" | "function";
+interface EntityHooksIR {
+	before: ("create" | "update")[];
+	after: ("create" | "update" | "delete")[];
+}
+interface EntityActionIR extends SourceLocation {
+	name: string;
+	method: HttpMethod;
+	path?: string;
+	params?: SchemaRef;
+	query?: SchemaRef;
+	headers?: SchemaRef;
+	body?: SchemaRef;
+	response?: SchemaRef;
+}
+interface EntityRelationIR {
+	name: string;
+	selection: "all" | string[];
 }
 interface ModuleDefContext {
 	moduleDefVariables: Map<string, string>;
@@ -215,6 +271,7 @@ declare function defineConfig(config: VertzConfig): VertzConfig;
 declare function resolveConfig(config?: VertzConfig): ResolvedConfig;
 interface Analyzer<T> {
 	analyze(): Promise<T>;
+	getDiagnostics(): Diagnostic[];
 }
 declare abstract class BaseAnalyzer<T> implements Analyzer<T> {
 	protected readonly project: Project;
@@ -292,6 +349,49 @@ declare class RouteAnalyzer extends BaseAnalyzer<RouteAnalyzerResult> {
 	private extractMiddlewareRefs;
 	private generateOperationId;
 }
+interface EntityAnalyzerResult {
+	entities: EntityIR[];
+}
+declare class EntityAnalyzer extends BaseAnalyzer<EntityAnalyzerResult> {
+	private debug;
+	analyze(): Promise<EntityAnalyzerResult>;
+	private findEntityCalls;
+	private extractEntity;
+	private extractModelRef;
+	private findImportForIdentifier;
+	private resolveModelSchemas;
+	private extractSchemaType;
+	/**
+	* Build JSON Schema from resolved fields.
+	* Maps tsType ('string' | 'number' | 'boolean' | 'date' | 'unknown') to JSON Schema types.
+	*/
+	private buildJsonSchema;
+	/**
+	* Map tsType to JSON Schema type.
+	* Handles column types like text → string, boolean → boolean, uuid → string with format,
+	* timestamp with time zone → string with date-time format, integer → integer, real/float → number.
+	*/
+	private tsTypeToJsonSchema;
+	/**
+	* Navigate through SchemaLike<T> to extract T's field info.
+	* SchemaLike<T>.parse() returns { ok: true; data: T } | { ok: false; error: Error }.
+	* We unwrap the Result union to get T from the success branch's `data` property.
+	*/
+	private resolveFieldsFromSchemaType;
+	/**
+	* Unwrap a Result type to extract T from the success branch.
+	* Handles: { ok: true; data: T } | { ok: false; error: Error } → T
+	* Falls back to the type itself if it's not a Result union (backward compat).
+	*/
+	private unwrapResultType;
+	private mapTsType;
+	private extractAccess;
+	private classifyAccessRule;
+	private extractHooks;
+	private extractActions;
+	private resolveSchemaFromExpression;
+	private extractRelations;
+}
 import { Expression as Expression2, SourceFile } from "ts-morph";
 interface SchemaAnalyzerResult {
 	schemas: SchemaIR[];
@@ -338,6 +438,7 @@ interface CompilerDependencies {
 		middleware: Analyzer<MiddlewareAnalyzerResult>;
 		module: Analyzer<ModuleAnalyzerResult>;
 		app: Analyzer<AppAnalyzerResult>;
+		entity: Analyzer<EntityAnalyzerResult>;
 		dependencyGraph: Analyzer<DependencyGraphResult>;
 	};
 	validators: Validator[];
@@ -629,6 +730,8 @@ declare class IncrementalCompiler {
 declare function createEmptyDependencyGraph(): DependencyGraphIR;
 declare function createEmptyAppIR(): AppIR;
 declare function addDiagnosticsToIR(ir: AppIR, diagnostics: readonly Diagnostic[]): AppIR;
+declare function injectEntityRoutes(ir: AppIR): void;
+declare function detectRouteCollisions(ir: AppIR): Diagnostic[];
 declare function mergeIR(base: AppIR, partial: Partial<AppIR>): AppIR;
 import { ChildProcess } from "node:child_process";
 interface TypecheckDiagnostic {
@@ -721,4 +824,4 @@ declare class PlacementValidator implements Validator {
 	private checkFileLocation;
 	private checkMixedExports;
 }
-export { typecheckWatch, typecheck, resolveImportPath, resolveIdentifier, resolveExport, resolveConfig, renderSchemaRegistryFile, renderRouteTableFile, renderBootFile, parseWatchBlock, parseTscOutput, parseSchemaName2 as 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, VertzConfig, Validator, ValidationConfig, ValidPart, ValidOperation, TypecheckWatchOptions, TypecheckResult, TypecheckOptions, TypecheckDiagnostic, SourceLocation, SourceContext, ServiceMethodParam, ServiceMethodIR, ServiceIR, ServiceAnalyzerResult, ServiceAnalyzer, SchemaRegistryManifest, SchemaRegistryGenerator, SchemaRegistryEntry, SchemaRef, SchemaNameParts, SchemaIR, SchemaExecutor, SchemaExecutionResult, SchemaConfig, SchemaAnalyzerResult, SchemaAnalyzer, RouterIR, RouteTableSchemas, RouteTableManifest, RouteTableGenerator, RouteTableEntry, RouteIR, RouteAnalyzerResult, RouteAnalyzer, ResolvedImport, ResolvedConfig, PlacementValidator, ParsedSchemaName, OpenAPITag, OpenAPIServer, OpenAPIResponse, OpenAPIRequestBody, OpenAPIPathItem, OpenAPIParameter, OpenAPIOperation, OpenAPIInfo, OpenAPIGenerator, OpenAPIDocument, OpenAPIConfig, NamingValidator, NamedSchemaRef, ModuleValidator, ModuleRegistration, ModuleIR, ModuleDefContext, ModuleAnalyzerResult, ModuleAnalyzer, MiddlewareRef, MiddlewareIR, MiddlewareAnalyzerResult, MiddlewareAnalyzer, ManifestRoute, ManifestModule, ManifestMiddleware, ManifestGenerator, ManifestDiagnostic, ManifestDependencyEdge, JSONSchemaObject, InlineSchemaRef, InjectRef, IncrementalResult, IncrementalCompiler, ImportRef, HttpMethod, Generator, FileChange, FileCategory, EnvVariableIR, EnvIR, EnvAnalyzerResult, EnvAnalyzer, DiagnosticSeverity, DiagnosticCode, Diagnostic, DependencyNodeKind, DependencyNode, DependencyGraphResult, DependencyGraphInput, DependencyGraphIR, DependencyGraphAnalyzer, DependencyEdgeKind, DependencyEdge, CreateDiagnosticOptions, CompletenessValidator, CompilerDependencies, CompilerConfig, Compiler, CompileResult, CategorizedChanges, CategorizeOptions, BootModuleEntry, BootMiddlewareEntry, BootManifest, BootGenerator, BaseGenerator, BaseAnalyzer, AppManifest, AppIR, AppDefinition, AppAnalyzerResult, AppAnalyzer, Analyzer };
+export { typecheckWatch, typecheck, resolveImportPath, resolveIdentifier, resolveExport, resolveConfig, renderSchemaRegistryFile, renderRouteTableFile, renderBootFile, parseWatchBlock, parseTscOutput, parseSchemaName2 as parseSchemaName, parseInjectRefs, parseImports, mergeIR, mergeDiagnostics, isSchemaFile, isSchemaExpression, isFromImport, injectEntityRoutes, hasErrors, getVariableNameForCall, getStringValue, getSourceLocation, getPropertyValue, getProperties, getNumberValue, getBooleanValue, getArrayElements, findMethodCallsOnVariable, findCallExpressions, findAffectedModules, filterBySeverity, extractSchemaId, extractObjectLiteral, extractMethodSignatures, extractIdentifierNames, detectRouteCollisions, defineConfig, createSchemaExecutor, createNamedSchemaRef, createInlineSchemaRef, createEmptyDependencyGraph, createEmptyAppIR, createDiagnosticFromLocation, createDiagnostic, createCompiler, categorizeChanges, buildSchemaRegistry, buildRouteTable, buildManifest, buildBootManifest, addDiagnosticsToIR, VertzConfig, Validator, ValidationConfig, ValidPart, ValidOperation, TypecheckWatchOptions, TypecheckResult, TypecheckOptions, TypecheckDiagnostic, SourceLocation, SourceContext, ServiceMethodParam, ServiceMethodIR, ServiceIR, ServiceAnalyzerResult, ServiceAnalyzer, SchemaRegistryManifest, SchemaRegistryGenerator, SchemaRegistryEntry, SchemaRef, SchemaNameParts, SchemaIR, SchemaExecutor, SchemaExecutionResult, SchemaConfig, SchemaAnalyzerResult, SchemaAnalyzer, RouterIR, RouteTableSchemas, RouteTableManifest, RouteTableGenerator, RouteTableEntry, RouteIR, RouteAnalyzerResult, RouteAnalyzer, ResolvedImport, ResolvedConfig, PlacementValidator, ParsedSchemaName, OpenAPITag, OpenAPIServer, OpenAPIResponse, OpenAPIRequestBody, OpenAPIPathItem, OpenAPIParameter, OpenAPIOperation, OpenAPIInfo, OpenAPIGenerator, OpenAPIDocument, OpenAPIConfig, NamingValidator, NamedSchemaRef, ModuleValidator, ModuleRegistration, ModuleIR, ModuleDefContext, ModuleAnalyzerResult, ModuleAnalyzer, MiddlewareRef, MiddlewareIR, MiddlewareAnalyzerResult, MiddlewareAnalyzer, ManifestRoute, ManifestModule, ManifestMiddleware, ManifestGenerator, ManifestDiagnostic, ManifestDependencyEdge, JSONSchemaObject, InlineSchemaRef, InjectRef, IncrementalResult, IncrementalCompiler, ImportRef, HttpMethod, Generator, FileChange, FileCategory, EnvVariableIR, EnvIR, EnvAnalyzerResult, EnvAnalyzer, EntityRelationIR, EntityModelSchemaRefs, EntityModelRef, EntityIR, EntityHooksIR, EntityAnalyzerResult, EntityAnalyzer, EntityActionIR, EntityAccessRuleKind, EntityAccessIR, DiagnosticSeverity, DiagnosticCode, Diagnostic, DependencyNodeKind, DependencyNode, DependencyGraphResult, DependencyGraphInput, DependencyGraphIR, DependencyGraphAnalyzer, DependencyEdgeKind, DependencyEdge, CreateDiagnosticOptions, CompletenessValidator, CompilerDependencies, CompilerConfig, Compiler, CompileResult, CategorizedChanges, CategorizeOptions, BootModuleEntry, BootMiddlewareEntry, BootManifest, BootGenerator, BaseGenerator, BaseAnalyzer, AppManifest, AppIR, AppDefinition, AppAnalyzerResult, AppAnalyzer, Analyzer };

package/dist/index.js

@@ -211,7 +211,10 @@ class AppAnalyzer extends BaseAnalyzer {
   async analyze() {
     const allAppCalls = [];
     for (const file2 of this.project.getSourceFiles()) {
-      const appCalls = findCallExpressions(file2, "vertz", "app");
+      const appCalls = [
+        ...findCallExpressions(file2, "vertz", "app"),
+        ...findCallExpressions(file2, "vertz", "server")
+      ];
       for (const call2 of appCalls) {
         allAppCalls.push({ call: call2, file: file2 });
       }
@@ -628,6 +631,7 @@ class SchemaAnalyzer extends BaseAnalyzer {
             name,
             ...loc,
             id: id ?? undefined,
+            moduleName: "",
             namingConvention: parseSchemaName(name),
             isNamed: id !== null
           });
@@ -1268,7 +1272,483 @@ function joinPaths(prefix, path) {
 function sanitizePath(path) {
   return path.replace(/^\//, "").replace(/[/:.]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "") || "root";
 }
+// src/analyzers/entity-analyzer.ts
+import { SyntaxKind as SyntaxKind9 } from "ts-morph";
+var ENTITY_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+var CRUD_OPS = ["list", "get", "create", "update", "delete"];
+
+class EntityAnalyzer extends BaseAnalyzer {
+  debug(msg) {
+    if (process.env["VERTZ_DEBUG"]?.includes("entities")) {
+      console.log(`[entity-analyzer] ${msg}`);
+    }
+  }
+  async analyze() {
+    const entities = [];
+    const seenNames = new Map;
+    const files = this.project.getSourceFiles();
+    this.debug(`Scanning ${files.length} source files...`);
+    for (const file of files) {
+      const calls = this.findEntityCalls(file);
+      for (const call of calls) {
+        const entity = this.extractEntity(file, call);
+        if (!entity)
+          continue;
+        const existing = seenNames.get(entity.name);
+        if (existing) {
+          this.addDiagnostic({
+            code: "ENTITY_DUPLICATE_NAME",
+            severity: "error",
+            message: `Entity "${entity.name}" is already defined at ${existing.sourceFile}:${existing.sourceLine}`,
+            ...getSourceLocation(call)
+          });
+          continue;
+        }
+        seenNames.set(entity.name, entity);
+        entities.push(entity);
+        this.debug(`Detected entity: "${entity.name}" at ${entity.sourceFile}:${entity.sourceLine}`);
+        this.debug(`  model: ${entity.modelRef.variableName} (resolved: ${entity.modelRef.schemaRefs.resolved ? "✅" : "❌"})`);
+        const accessStatus = CRUD_OPS.map((op) => {
+          const kind = entity.access[op];
+          return `${op} ${kind === "false" ? "✗" : "✓"}`;
+        }).join(", ");
+        this.debug(`  access: ${accessStatus}`);
+        if (entity.hooks.before.length > 0 || entity.hooks.after.length > 0) {
+          this.debug(`  hooks: before[${entity.hooks.before.join(",")}], after[${entity.hooks.after.join(",")}]`);
+        }
+        if (entity.actions.length > 0) {
+          this.debug(`  actions: ${entity.actions.map((a) => a.name).join(", ")}`);
+        }
+      }
+    }
+    return { entities };
+  }
+  findEntityCalls(file) {
+    const validCalls = [];
+    for (const call of file.getDescendantsOfKind(SyntaxKind9.CallExpression)) {
+      const expr = call.getExpression();
+      if (expr.isKind(SyntaxKind9.Identifier)) {
+        const isValid = isFromImport(expr, "@vertz/server");
+        if (!isValid && expr.getText() === "entity") {
+          this.addDiagnostic({
+            code: "ENTITY_UNRESOLVED_IMPORT",
+            severity: "error",
+            message: "entity() call does not resolve to @vertz/server",
+            ...getSourceLocation(call)
+          });
+          continue;
+        }
+        if (isValid) {
+          validCalls.push(call);
+        }
+        continue;
+      }
+      if (expr.isKind(SyntaxKind9.PropertyAccessExpression)) {
+        const propName = expr.getName();
+        if (propName !== "entity")
+          continue;
+        const obj = expr.getExpression();
+        if (!obj.isKind(SyntaxKind9.Identifier))
+          continue;
+        const sourceFile = obj.getSourceFile();
+        const importDecl = sourceFile.getImportDeclarations().find((d) => d.getModuleSpecifierValue() === "@vertz/server" && d.getNamespaceImport()?.getText() === obj.getText());
+        if (importDecl) {
+          validCalls.push(call);
+        }
+      }
+    }
+    return validCalls;
+  }
+  extractEntity(_file, call) {
+    const args = call.getArguments();
+    const loc = getSourceLocation(call);
+    if (args.length < 2) {
+      this.addDiagnostic({
+        code: "ENTITY_MISSING_ARGS",
+        severity: "error",
+        message: "entity() requires two arguments: name and config",
+        ...loc
+      });
+      return null;
+    }
+    const name = getStringValue(args[0]);
+    if (name === null) {
+      this.addDiagnostic({
+        code: "ENTITY_NON_LITERAL_NAME",
+        severity: "error",
+        message: "entity() name must be a string literal",
+        ...loc
+      });
+      return null;
+    }
+    if (!ENTITY_NAME_PATTERN.test(name)) {
+      this.addDiagnostic({
+        code: "ENTITY_INVALID_NAME",
+        severity: "error",
+        message: `Entity name must match /^[a-z][a-z0-9-]*$/. Got: "${name}"`,
+        ...loc
+      });
+      return null;
+    }
+    const configObj = extractObjectLiteral(call, 1);
+    if (!configObj) {
+      this.addDiagnostic({
+        code: "ENTITY_CONFIG_NOT_OBJECT",
+        severity: "warning",
+        message: "entity() config must be an object literal for static analysis",
+        ...loc
+      });
+      return null;
+    }
+    const modelRef = this.extractModelRef(configObj, loc);
+    if (!modelRef)
+      return null;
+    const access = this.extractAccess(configObj);
+    const hooks = this.extractHooks(configObj);
+    const actions = this.extractActions(configObj);
+    const relations = this.extractRelations(configObj);
+    for (const action of actions) {
+      if (CRUD_OPS.includes(action.name)) {
+        this.addDiagnostic({
+          code: "ENTITY_ACTION_NAME_COLLISION",
+          severity: "error",
+          message: `Custom action "${action.name}" collides with built-in CRUD operation`,
+          ...action
+        });
+      }
+    }
+    for (const customOp of Object.keys(access.custom)) {
+      if (!actions.some((a) => a.name === customOp)) {
+        this.addDiagnostic({
+          code: "ENTITY_UNKNOWN_ACCESS_OP",
+          severity: "warning",
+          message: `Unknown access operation "${customOp}" — not a CRUD op or custom action`,
+          ...loc
+        });
+      }
+    }
+    return { name, modelRef, access, hooks, actions, relations, ...loc };
+  }
+  extractModelRef(configObj, loc) {
+    const modelExpr = getPropertyValue(configObj, "model");
+    if (!modelExpr) {
+      this.addDiagnostic({
+        code: "ENTITY_MISSING_MODEL",
+        severity: "error",
+        message: "entity() requires a model property",
+        ...loc
+      });
+      return null;
+    }
+    const variableName = modelExpr.isKind(SyntaxKind9.Identifier) ? modelExpr.getText() : modelExpr.getText();
+    let importSource;
+    if (modelExpr.isKind(SyntaxKind9.Identifier)) {
+      const importInfo = this.findImportForIdentifier(modelExpr);
+      if (importInfo) {
+        importSource = importInfo.importDecl.getModuleSpecifierValue();
+      }
+    }
+    const schemaRefs = this.resolveModelSchemas(modelExpr);
+    return { variableName, importSource, schemaRefs };
+  }
+  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;
+  }
+  resolveModelSchemas(modelExpr) {
+    try {
+      const modelType = modelExpr.getType();
+      const schemasProp = modelType.getProperty("schemas");
+      if (!schemasProp)
+        return { resolved: false };
+      const schemasType = schemasProp.getTypeAtLocation(modelExpr);
+      const response = this.extractSchemaType(schemasType, "response", modelExpr);
+      const createInput = this.extractSchemaType(schemasType, "createInput", modelExpr);
+      const updateInput = this.extractSchemaType(schemasType, "updateInput", modelExpr);
+      return {
+        response,
+        createInput,
+        updateInput,
+        resolved: response !== undefined || createInput !== undefined || updateInput !== undefined
+      };
+    } catch {
+      return { resolved: false };
+    }
+  }
+  extractSchemaType(parentType, propertyName, location) {
+    const prop = parentType.getProperty(propertyName);
+    if (!prop)
+      return;
+    const propType = prop.getTypeAtLocation(location);
+    const resolvedFields = this.resolveFieldsFromSchemaType(propType, location);
+    const jsonSchema = this.buildJsonSchema(resolvedFields);
+    return {
+      kind: "inline",
+      sourceFile: location.getSourceFile().getFilePath(),
+      jsonSchema,
+      resolvedFields
+    };
+  }
+  buildJsonSchema(resolvedFields) {
+    if (!resolvedFields || resolvedFields.length === 0) {
+      return {};
+    }
+    const properties = {};
+    const required = [];
+    for (const field of resolvedFields) {
+      const fieldSchema = this.tsTypeToJsonSchema(field.tsType);
+      properties[field.name] = fieldSchema;
+      if (!field.optional) {
+        required.push(field.name);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    };
+  }
+  tsTypeToJsonSchema(tsType) {
+    switch (tsType) {
+      case "string":
+        return { type: "string" };
+      case "number":
+        return { type: "number" };
+      case "boolean":
+        return { type: "boolean" };
+      case "date":
+        return { type: "string", format: "date-time" };
+      case "unknown":
+      default:
+        return {};
+    }
+  }
+  resolveFieldsFromSchemaType(schemaType, location) {
+    try {
+      const parseProp = schemaType.getProperty("parse");
+      if (!parseProp)
+        return;
+      const parseType = parseProp.getTypeAtLocation(location);
+      const callSignatures = parseType.getCallSignatures();
+      if (callSignatures.length === 0)
+        return;
+      const returnType = callSignatures[0]?.getReturnType();
+      if (!returnType)
+        return;
+      const dataType = this.unwrapResultType(returnType, location);
+      if (!dataType)
+        return;
+      const properties = dataType.getProperties();
+      if (properties.length === 0)
+        return;
+      const fields = [];
+      for (const fieldProp of properties) {
+        const name = fieldProp.getName();
+        const fieldType = fieldProp.getTypeAtLocation(location);
+        const optional = fieldProp.isOptional();
+        const tsType = this.mapTsType(fieldType);
+        fields.push({ name, tsType, optional });
+      }
+      return fields;
+    } catch {
+      return;
+    }
+  }
+  unwrapResultType(type, location) {
+    if (type.isUnion()) {
+      for (const member of type.getUnionTypes()) {
+        const dataProp2 = member.getProperty("data");
+        if (dataProp2) {
+          return dataProp2.getTypeAtLocation(location);
+        }
+      }
+      return;
+    }
+    const dataProp = type.getProperty("data");
+    if (dataProp) {
+      return dataProp.getTypeAtLocation(location);
+    }
+    return type;
+  }
+  mapTsType(type) {
+    const typeText = type.getText();
+    if (type.isUnion()) {
+      const nonUndefined = type.getUnionTypes().filter((t) => !t.isUndefined());
+      if (nonUndefined.length === 1 && nonUndefined[0]) {
+        return this.mapTsType(nonUndefined[0]);
+      }
+    }
+    if (type.isString() || type.isStringLiteral())
+      return "string";
+    if (type.isNumber() || type.isNumberLiteral())
+      return "number";
+    if (type.isBoolean() || type.isBooleanLiteral())
+      return "boolean";
+    if (typeText === "Date")
+      return "date";
+    return "unknown";
+  }
+  extractAccess(configObj) {
+    const defaults = {
+      list: "none",
+      get: "none",
+      create: "none",
+      update: "none",
+      delete: "none",
+      custom: {}
+    };
+    const accessExpr = getPropertyValue(configObj, "access");
+    if (!accessExpr || !accessExpr.isKind(SyntaxKind9.ObjectLiteralExpression))
+      return defaults;
+    const result = { ...defaults };
+    const knownOps = new Set([...CRUD_OPS]);
+    for (const { name, value } of getProperties(accessExpr)) {
+      const kind = this.classifyAccessRule(value);
+      if (knownOps.has(name)) {
+        result[name] = kind;
+      } else {
+        result.custom[name] = kind;
+      }
+    }
+    return result;
+  }
+  classifyAccessRule(expr) {
+    const boolVal = getBooleanValue(expr);
+    if (boolVal === false)
+      return "false";
+    if (boolVal === true)
+      return "none";
+    return "function";
+  }
+  extractHooks(configObj) {
+    const hooks = { before: [], after: [] };
+    const beforeExpr = getPropertyValue(configObj, "before");
+    if (beforeExpr?.isKind(SyntaxKind9.ObjectLiteralExpression)) {
+      for (const { name } of getProperties(beforeExpr)) {
+        if (name === "create" || name === "update")
+          hooks.before.push(name);
+      }
+    }
+    const afterExpr = getPropertyValue(configObj, "after");
+    if (afterExpr?.isKind(SyntaxKind9.ObjectLiteralExpression)) {
+      for (const { name } of getProperties(afterExpr)) {
+        if (name === "create" || name === "update" || name === "delete")
+          hooks.after.push(name);
+      }
+    }
+    return hooks;
+  }
+  extractActions(configObj) {
+    const actionsExpr = getPropertyValue(configObj, "actions");
+    if (!actionsExpr?.isKind(SyntaxKind9.ObjectLiteralExpression))
+      return [];
+    return getProperties(actionsExpr).map(({ name, value }) => {
+      const actionObj = value.isKind(SyntaxKind9.ObjectLiteralExpression) ? value : null;
+      const loc = getSourceLocation(value);
+      const bodyExpr = actionObj ? getPropertyValue(actionObj, "body") : null;
+      const responseExpr = actionObj ? getPropertyValue(actionObj, "response") : null;
+      if (!bodyExpr && !responseExpr) {
+        this.addDiagnostic({
+          code: "ENTITY_ACTION_MISSING_SCHEMA",
+          severity: "warning",
+          message: `Custom action "${name}" is missing body and response schema`,
+          ...loc
+        });
+      }
+      const body = bodyExpr ? this.resolveSchemaFromExpression(bodyExpr, loc) : undefined;
+      const response = responseExpr ? this.resolveSchemaFromExpression(responseExpr, loc) : undefined;
+      const methodExpr = actionObj ? getPropertyValue(actionObj, "method") : null;
+      let method = "POST";
+      if (methodExpr) {
+        const methodStr = getStringValue(methodExpr);
+        const validMethods = [
+          "GET",
+          "POST",
+          "PUT",
+          "DELETE",
+          "PATCH",
+          "HEAD",
+          "OPTIONS"
+        ];
+        if (methodStr && validMethods.includes(methodStr)) {
+          method = methodStr;
+        } else {
+          this.addDiagnostic({
+            code: "ENTITY_ACTION_INVALID_METHOD",
+            severity: "error",
+            message: `Custom action "${name}" has invalid method "${methodStr ?? "(non-string)"}" — must be one of GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS`,
+            ...loc
+          });
+        }
+      }
+      const pathExpr = actionObj ? getPropertyValue(actionObj, "path") : null;
+      const path = pathExpr ? getStringValue(pathExpr) ?? undefined : undefined;
+      const queryExpr = actionObj ? getPropertyValue(actionObj, "query") : null;
+      const queryRef = queryExpr ? this.resolveSchemaFromExpression(queryExpr, loc) : undefined;
+      const paramsExpr = actionObj ? getPropertyValue(actionObj, "params") : null;
+      const paramsRef = paramsExpr ? this.resolveSchemaFromExpression(paramsExpr, loc) : undefined;
+      const headersExpr = actionObj ? getPropertyValue(actionObj, "headers") : null;
+      const headersRef = headersExpr ? this.resolveSchemaFromExpression(headersExpr, loc) : undefined;
+      return {
+        name,
+        method,
+        path,
+        params: paramsRef,
+        query: queryRef,
+        headers: headersRef,
+        body,
+        response,
+        ...loc
+      };
+    });
+  }
+  resolveSchemaFromExpression(expr, loc) {
+    if (expr.isKind(SyntaxKind9.Identifier)) {
+      const varName = expr.getText();
+      return { kind: "named", schemaName: varName, sourceFile: loc.sourceFile };
+    }
+    try {
+      const typeText = expr.getType().getText();
+      return { kind: "inline", sourceFile: loc.sourceFile, jsonSchema: { __typeText: typeText } };
+    } catch {
+      return { kind: "inline", sourceFile: loc.sourceFile };
+    }
+  }
+  extractRelations(configObj) {
+    const relExpr = getPropertyValue(configObj, "relations");
+    if (!relExpr?.isKind(SyntaxKind9.ObjectLiteralExpression))
+      return [];
+    return getProperties(relExpr).filter(({ value }) => {
+      const boolVal = getBooleanValue(value);
+      return boolVal !== false;
+    }).map(({ name, value }) => {
+      const boolVal = getBooleanValue(value);
+      if (boolVal === true)
+        return { name, selection: "all" };
+      if (value.isKind(SyntaxKind9.ObjectLiteralExpression)) {
+        const fields = getProperties(value).map((p) => p.name);
+        return { name, selection: fields };
+      }
+      return { name, selection: "all" };
+    });
+  }
+}
 // src/compiler.ts
+import { mkdir } from "node:fs/promises";
+import { resolve } from "node:path";
 import { Project } from "ts-morph";
 
 // src/config.ts
@@ -1859,10 +2339,31 @@ function createEmptyAppIR() {
     modules: [],
     middleware: [],
     schemas: [],
+    entities: [],
     dependencyGraph: createEmptyDependencyGraph(),
     diagnostics: []
   };
 }
+function enrichSchemasWithModuleNames(ir) {
+  const schemaToModule = new Map;
+  for (const mod of ir.modules) {
+    for (const router of mod.routers) {
+      for (const route of router.routes) {
+        const refs = [route.body, route.query, route.params, route.headers, route.response];
+        for (const ref of refs) {
+          if (ref?.kind === "named") {
+            schemaToModule.set(ref.schemaName, mod.name);
+          }
+        }
+      }
+    }
+  }
+  const schemas = ir.schemas.map((s) => ({
+    ...s,
+    moduleName: schemaToModule.get(s.name) ?? s.moduleName
+  }));
+  return { ...ir, schemas };
+}
 function addDiagnosticsToIR(ir, diagnostics) {
   return {
     ...ir,
@@ -1870,6 +2371,162 @@ function addDiagnosticsToIR(ir, diagnostics) {
   };
 }
 
+// src/ir/entity-route-injector.ts
+var SYNTHETIC_MODULE = "__entities";
+function toPascalCase(s) {
+  return s.split("-").map((w) => w[0]?.toUpperCase() + w.slice(1)).join("");
+}
+function injectEntityRoutes(ir) {
+  if (!ir.entities.length)
+    return;
+  const routes = [];
+  for (const entity of ir.entities) {
+    routes.push(...generateCrudRoutes(entity));
+    routes.push(...generateActionRoutes(entity));
+  }
+  if (!routes.length)
+    return;
+  const router = {
+    name: `${SYNTHETIC_MODULE}_router`,
+    moduleName: SYNTHETIC_MODULE,
+    prefix: "",
+    inject: [],
+    routes,
+    sourceFile: "",
+    sourceLine: 0,
+    sourceColumn: 0
+  };
+  const module = {
+    name: SYNTHETIC_MODULE,
+    imports: [],
+    services: [],
+    routers: [router],
+    exports: [],
+    sourceFile: "",
+    sourceLine: 0,
+    sourceColumn: 0
+  };
+  ir.modules.push(module);
+}
+function generateCrudRoutes(entity) {
+  const entityPascal = toPascalCase(entity.name);
+  const basePath = `/${entity.name}`;
+  const routes = [];
+  const ops = [
+    { op: "list", method: "GET", path: basePath, idParam: false },
+    { op: "get", method: "GET", path: `${basePath}/:id`, idParam: true },
+    { op: "create", method: "POST", path: basePath, idParam: false },
+    { op: "update", method: "PATCH", path: `${basePath}/:id`, idParam: true },
+    { op: "delete", method: "DELETE", path: `${basePath}/:id`, idParam: true }
+  ];
+  for (const { op, method, path } of ops) {
+    const accessKind = entity.access[op];
+    if (accessKind === "false")
+      continue;
+    const route = {
+      method,
+      path,
+      fullPath: path,
+      operationId: `${op}${entityPascal}`,
+      middleware: [],
+      tags: [entity.name],
+      description: `${op} ${entity.name}`,
+      ...entity
+    };
+    if (entity.modelRef.schemaRefs.resolved) {
+      if (op === "create") {
+        route.body = entity.modelRef.schemaRefs.createInput;
+        route.response = entity.modelRef.schemaRefs.response;
+      } else if (op === "update") {
+        route.body = entity.modelRef.schemaRefs.updateInput;
+        route.response = entity.modelRef.schemaRefs.response;
+      } else if (op === "list") {
+        route.response = wrapInPaginatedEnvelope(entity.modelRef.schemaRefs.response);
+      } else {
+        route.response = entity.modelRef.schemaRefs.response;
+      }
+    }
+    routes.push(route);
+  }
+  return routes;
+}
+function wrapInPaginatedEnvelope(itemSchema) {
+  if (!itemSchema)
+    return;
+  const itemJsonSchema = itemSchema.kind === "named" ? { $ref: `#/components/schemas/${itemSchema.schemaName}` } : itemSchema.jsonSchema ?? {};
+  return {
+    kind: "inline",
+    sourceFile: itemSchema.sourceFile,
+    jsonSchema: {
+      type: "object",
+      properties: {
+        items: { type: "array", items: itemJsonSchema },
+        total: { type: "number" },
+        limit: { type: "number" },
+        nextCursor: { type: ["string", "null"] },
+        hasNextPage: { type: "boolean" }
+      },
+      required: ["items", "total", "limit", "nextCursor", "hasNextPage"]
+    }
+  };
+}
+function generateActionRoutes(entity) {
+  const entityPascal = toPascalCase(entity.name);
+  return entity.actions.filter((action) => entity.access.custom[action.name] !== "false").map((action) => {
+    const method = action.method;
+    const path = action.path ? `/${entity.name}/${action.path}` : `/${entity.name}/:id/${action.name}`;
+    const fullPath = path;
+    return {
+      method,
+      path,
+      fullPath,
+      operationId: `${action.name}${entityPascal}`,
+      params: action.params,
+      query: action.query,
+      headers: action.headers,
+      body: action.body,
+      response: action.response,
+      middleware: [],
+      tags: [entity.name],
+      description: `${action.name} on ${entity.name}`,
+      sourceFile: action.sourceFile,
+      sourceLine: action.sourceLine,
+      sourceColumn: action.sourceColumn
+    };
+  });
+}
+function detectRouteCollisions(ir) {
+  const diagnostics = [];
+  const seen = new Map;
+  for (const mod of ir.modules) {
+    if (mod.name === SYNTHETIC_MODULE)
+      continue;
+    for (const router of mod.routers) {
+      for (const route of router.routes) {
+        seen.set(route.operationId, route);
+      }
+    }
+  }
+  const entityModule = ir.modules.find((m) => m.name === SYNTHETIC_MODULE);
+  if (entityModule) {
+    for (const router of entityModule.routers) {
+      for (const route of router.routes) {
+        const existing = seen.get(route.operationId);
+        if (existing) {
+          diagnostics.push({
+            code: "ENTITY_ROUTE_COLLISION",
+            severity: "error",
+            message: `Entity-generated operationId "${route.operationId}" collides with existing route at ${existing.sourceFile}:${existing.sourceLine}`,
+            ...route
+          });
+        }
+        seen.set(route.operationId, route);
+      }
+    }
+  }
+  return diagnostics;
+}
+
 // src/validators/completeness-validator.ts
 var METHODS_WITHOUT_RESPONSE = new Set(["DELETE", "HEAD", "OPTIONS"]);
 var RESERVED_CTX_KEYS = new Set([
@@ -2400,14 +3057,20 @@ class Compiler {
     const moduleResult = await analyzers.module.analyze();
     const middlewareResult = await analyzers.middleware.analyze();
     const appResult = await analyzers.app.analyze();
+    const entityResult = await analyzers.entity.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.entities = entityResult.entities;
     ir.dependencyGraph = depGraphResult.graph;
-    return ir;
+    ir.diagnostics.push(...analyzers.env.getDiagnostics(), ...analyzers.schema.getDiagnostics(), ...analyzers.middleware.getDiagnostics(), ...analyzers.module.getDiagnostics(), ...analyzers.app.getDiagnostics(), ...analyzers.entity.getDiagnostics(), ...analyzers.dependencyGraph.getDiagnostics());
+    injectEntityRoutes(ir);
+    const collisionDiags = detectRouteCollisions(ir);
+    ir.diagnostics.push(...collisionDiags);
+    return enrichSchemasWithModuleNames(ir);
   }
   async validate(ir) {
     const allDiagnostics = [];
@@ -2419,6 +3082,7 @@ class Compiler {
   }
   async generate(ir) {
     const outputDir = this.config.compiler.outputDir;
+    await mkdir(resolve(outputDir), { recursive: true });
     await Promise.all(this.deps.generators.map((g) => g.generate(ir, outputDir)));
   }
   async compile() {
@@ -2445,6 +3109,7 @@ function createCompiler(config) {
       middleware: new MiddlewareAnalyzer(project, resolved),
       module: new ModuleAnalyzer(project, resolved),
       app: new AppAnalyzer(project, resolved),
+      entity: new EntityAnalyzer(project, resolved),
       dependencyGraph: new DependencyGraphAnalyzer(project, resolved)
     },
     validators: [
@@ -2656,7 +3321,7 @@ async function* typecheckWatch(options = {}) {
   const completionMarker = /Found \d+ error/;
   let buffer = "";
   const results = [];
-  let resolve = null;
+  let resolve2 = null;
   let done = false;
   const onData = (chunk) => {
     buffer += chunk.toString();
@@ -2664,14 +3329,14 @@ async function* typecheckWatch(options = {}) {
       const result = parseWatchBlock(buffer);
       buffer = "";
       results.push(result);
-      resolve?.();
+      resolve2?.();
     }
   };
   proc.stdout?.on("data", onData);
   proc.stderr?.on("data", onData);
   proc.on("close", () => {
     done = true;
-    resolve?.();
+    resolve2?.();
   });
   try {
     while (!done || results.length > 0) {
@@ -2680,7 +3345,7 @@ async function* typecheckWatch(options = {}) {
         yield next;
       } else if (!done) {
         await new Promise((r) => {
-          resolve = r;
+          resolve2 = r;
         });
       }
     }
@@ -2693,11 +3358,11 @@ async function typecheck(options = {}) {
   if (options.tsconfigPath) {
     args.push("--project", options.tsconfigPath);
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     execFile("tsc", args, { cwd: process.cwd() }, (error, stdout, stderr) => {
       const output = stdout + stderr;
       const diagnostics = parseTscOutput(output);
-      resolve({
+      resolve2({
         success: !error,
         diagnostics
       });
@@ -2758,6 +3423,7 @@ export {
   isSchemaFile,
   isSchemaExpression,
   isFromImport,
+  injectEntityRoutes,
   hasErrors,
   getVariableNameForCall,
   getStringValue,
@@ -2775,6 +3441,7 @@ export {
   extractObjectLiteral,
   extractMethodSignatures,
   extractIdentifierNames,
+  detectRouteCollisions,
   defineConfig,
   createSchemaExecutor,
   createNamedSchemaRef,
@@ -2804,6 +3471,7 @@ export {
   ManifestGenerator,
   IncrementalCompiler,
   EnvAnalyzer,
+  EntityAnalyzer,
   DependencyGraphAnalyzer,
   CompletenessValidator,
   Compiler,

package/package.json

@@ -1,17 +1,14 @@
 {
   "name": "@vertz/compiler",
-  "version": "0.1.0",
+  "version": "0.2.3",
   "type": "module",
   "license": "MIT",
+  "description": "Vertz compiler — internal, no stability guarantee",
   "repository": {
     "type": "git",
     "url": "https://github.com/vertz-dev/vertz.git",
     "directory": "packages/compiler"
   },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -25,20 +22,26 @@
   ],
   "scripts": {
     "build": "bunup",
-    "test": "vitest run",
+    "test": "bun test",
+    "test:type": "vitest typecheck",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit -p tsconfig.typecheck.json"
   },
   "dependencies": {
-    "ts-morph": "^25.0.0"
+    "ts-morph": "^27.0.2"
   },
   "devDependencies": {
-    "@types/node": "^25.2.1",
-    "bunup": "latest",
+    "@types/node": "^25.3.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "bunup": "^0.16.31",
     "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
+    "vitest": "^4.0.18"
   },
   "engines": {
     "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
   }
 }