@vertz/codegen 0.2.0 → 0.2.3

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/config.ts
-var VALID_GENERATORS = new Set(["typescript", "cli"]);
+var VALID_GENERATORS = new Set(["typescript"]);
 function defineCodegenConfig(config) {
   return config;
 }
@@ -9,8 +9,7 @@ function resolveCodegenConfig(config) {
     outputDir: config?.outputDir ?? ".vertz/generated",
     format: config?.format,
     incremental: config?.incremental,
-    typescript: config?.typescript,
-    cli: config?.cli
+    typescript: config?.typescript
   };
 }
 function validateCodegenConfig(config) {
@@ -32,18 +31,6 @@ function validateCodegenConfig(config) {
       errors.push("codegen.typescript.publishable.outputDir is required");
     }
   }
-  if (config.cli?.publishable) {
-    const pub = config.cli.publishable;
-    if (!pub.name) {
-      errors.push("codegen.cli.publishable.name is required");
-    }
-    if (!pub.outputDir) {
-      errors.push("codegen.cli.publishable.outputDir is required");
-    }
-    if (!pub.binName) {
-      errors.push("codegen.cli.publishable.binName is required");
-    }
-  }
   return errors;
 }
 // src/format.ts
@@ -128,8 +115,11 @@ async function formatWithBiome(files) {
   }
 }
 // src/generate.ts
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname3, join as join3 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, join as join3, resolve as resolve3 } from "node:path";
+
+// src/generators/client-generator.ts
+import { posix } from "node:path";
 
 // src/utils/naming.ts
 function splitWords(input) {
@@ -149,890 +139,472 @@ function toSnakeCase(input) {
   return splitWords(input).map((w) => w.toLowerCase()).join("_");
 }
 
-// src/generators/typescript/emit-cli.ts
+// src/generators/client-generator.ts
 var FILE_HEADER = `// Generated by @vertz/codegen — do not edit
-`;
-function mapJsonSchemaTypeToCLI(type) {
-  if (type === "number" || type === "integer")
-    return "number";
-  if (type === "boolean")
-    return "boolean";
-  return "string";
-}
-function emitFieldDefinitions(schema, indent) {
-  const properties = schema.properties;
-  if (!properties)
-    return [];
-  const required = schema.required ?? [];
-  const lines = [];
-  for (const [key, propSchema] of Object.entries(properties)) {
-    const cliType = mapJsonSchemaTypeToCLI(propSchema.type);
-    const isRequired = required.includes(key);
-    const parts = [];
-    parts.push(`type: '${cliType}'`);
-    if (propSchema.description) {
-      parts.push(`description: '${propSchema.description}'`);
-    }
-    parts.push(`required: ${isRequired}`);
-    if (propSchema.enum) {
-      const enumValues = propSchema.enum.map((v) => `'${v}'`).join(", ");
-      parts.push(`enum: [${enumValues}]`);
-    }
-    lines.push(`${indent}  ${key}: { ${parts.join(", ")} },`);
-  }
-  return lines;
-}
-function emitCommandDefinition(op) {
-  const lines = [];
-  lines.push("{");
-  lines.push(`  method: '${op.method}',`);
-  lines.push(`  path: '${op.path}',`);
-  lines.push(`  description: '${op.description ?? op.operationId}',`);
-  if (op.params) {
-    const fields = emitFieldDefinitions(op.params, "  ");
-    if (fields.length > 0) {
-      lines.push("  params: {");
-      lines.push(...fields);
-      lines.push("  },");
-    }
-  }
-  if (op.query) {
-    const fields = emitFieldDefinitions(op.query, "  ");
-    if (fields.length > 0) {
-      lines.push("  query: {");
-      lines.push(...fields);
-      lines.push("  },");
-    }
-  }
-  if (op.body) {
-    const fields = emitFieldDefinitions(op.body, "  ");
-    if (fields.length > 0) {
-      lines.push("  body: {");
-      lines.push(...fields);
-      lines.push("  },");
-    }
-  }
-  lines.push("}");
-  return lines.join(`
-`);
-}
-function emitModuleCommands(module) {
-  if (module.operations.length === 0) {
-    return "{}";
-  }
-  const entries = [];
-  for (const op of module.operations) {
-    const commandName = toKebabCase(op.operationId);
-    const def = emitCommandDefinition(op);
-    const indented = def.split(`
-`).map((line, i) => i === 0 ? line : `  ${line}`).join(`
-`);
-    entries.push(`  '${commandName}': ${indented},`);
-  }
-  return `{
-${entries.join(`
-`)}
-}`;
-}
-function emitManifestFile(ir) {
-  const sections = [FILE_HEADER];
-  sections.push("import type { CommandManifest } from '@vertz/cli-runtime';");
-  sections.push("");
-  if (ir.modules.length === 0) {
-    sections.push("export const commands: CommandManifest = {};");
-  } else {
-    const namespaceEntries = [];
-    for (const mod of ir.modules) {
-      const cmds = emitModuleCommands(mod);
-      const indented = cmds.split(`
-`).map((line, i) => i === 0 ? line : `    ${line}`).join(`
-`);
-      namespaceEntries.push(`  ${mod.name}: ${indented},`);
-    }
-    sections.push(`export const commands: CommandManifest = {
-${namespaceEntries.join(`
-`)}
-};`);
-  }
-  return {
-    path: "cli/manifest.ts",
-    content: sections.join(`
-`)
-  };
-}
-function emitBinEntryPoint(options) {
-  const lines = [];
-  lines.push("#!/usr/bin/env node");
-  lines.push(FILE_HEADER);
-  lines.push("import { createCLI } from '@vertz/cli-runtime';");
-  lines.push("import { commands } from './manifest';");
-  lines.push("");
-  lines.push("const cli = createCLI({");
-  lines.push(`  name: '${options.cliName}',`);
-  lines.push(`  version: '${options.cliVersion}',`);
-  lines.push("  commands,");
-  lines.push("});");
-  lines.push("");
-  lines.push("cli.run(process.argv.slice(2));");
-  return {
-    path: "cli/bin.ts",
-    content: lines.join(`
-`)
-  };
-}
-function scaffoldCLIPackageJson(options) {
-  const pkg = {
-    name: options.packageName,
-    version: options.packageVersion ?? "0.0.0",
-    description: `CLI for ${options.cliName} — generated by @vertz/codegen`,
-    private: true,
-    bin: {
-      [options.cliName]: "./cli/bin.ts"
-    },
-    dependencies: {
-      "@vertz/cli-runtime": "*",
-      "@vertz/fetch": "*"
-    }
-  };
-  return {
-    path: "package.json",
-    content: JSON.stringify(pkg, null, 2)
-  };
-}
-function scaffoldCLIRootIndex() {
-  const lines = [FILE_HEADER];
-  lines.push("export { commands } from './cli/manifest';");
-  return {
-    path: "index.ts",
-    content: lines.join(`
-`)
-  };
-}
-
-// src/utils/imports.ts
-function mergeImports(imports) {
-  const seen = new Map;
-  for (const imp of imports) {
-    const key = `${imp.from}::${imp.name}::${imp.isType}::${imp.alias ?? ""}`;
-    if (!seen.has(key)) {
-      seen.set(key, imp);
-    }
-  }
-  return [...seen.values()].sort((a, b) => {
-    const fromCmp = a.from.localeCompare(b.from);
-    if (fromCmp !== 0)
-      return fromCmp;
-    return a.name.localeCompare(b.name);
-  });
-}
-function renderImports(imports) {
-  const grouped = new Map;
-  for (const imp of imports) {
-    let group = grouped.get(imp.from);
-    if (!group) {
-      group = { types: [], values: [] };
-      grouped.set(imp.from, group);
-    }
-    const nameStr = imp.alias ? `${imp.name} as ${imp.alias}` : imp.name;
-    if (imp.isType) {
-      group.types.push(nameStr);
-    } else {
-      group.values.push(nameStr);
-    }
-  }
-  const lines = [];
-  for (const [from, group] of grouped) {
-    if (group.types.length > 0) {
-      lines.push(`import type { ${group.types.join(", ")} } from '${from}';`);
-    }
-    if (group.values.length > 0) {
-      lines.push(`import { ${group.values.join(", ")} } from '${from}';`);
-    }
-  }
-  return lines.join(`
-`);
-}
 
-// src/generators/typescript/emit-client.ts
-var FILE_HEADER2 = `// Generated by @vertz/codegen — do not edit
 `;
-function emitSDKConfig(auth) {
-  const imports = [{ from: "@vertz/fetch", name: "FetchClientConfig", isType: true }];
-  const fields = [];
-  for (const scheme of auth.schemes) {
-    if (scheme.type === "bearer") {
-      fields.push(`  /** Bearer token or function returning a token. */
-  token?: string | (() => string | Promise<string>);`);
-    } else if (scheme.type === "apiKey") {
-      fields.push(`  /** API key or function returning a key. */
-  apiKey?: string | (() => string | Promise<string>);`);
-    }
-  }
-  if (fields.length === 0) {
-    return {
-      content: "export interface SDKConfig extends FetchClientConfig {}",
-      imports
-    };
-  }
-  const content = `export interface SDKConfig extends FetchClientConfig {
-${fields.join(`
-`)}
-}`;
-  return { content, imports };
-}
-function emitAuthStrategyBuilder(auth) {
-  const imports = [{ from: "@vertz/fetch", name: "AuthStrategy", isType: true }];
-  const lines = [];
-  lines.push("const authStrategies: AuthStrategy[] = [...(config.authStrategies ?? [])];");
-  for (const scheme of auth.schemes) {
-    if (scheme.type === "bearer") {
-      lines.push(`if (config.token) {
-  authStrategies.push({ type: 'bearer', token: config.token });
-}`);
-    } else if (scheme.type === "apiKey") {
-      lines.push(`if (config.apiKey) {
-  authStrategies.push({ type: 'apiKey', key: config.apiKey, location: '${scheme.in}', name: '${scheme.paramName}' });
-}`);
-    }
-  }
-  return { content: lines.join(`
-`), imports };
-}
-function buildPathExpression(path) {
-  if (!path.includes(":")) {
-    return `'${path}'`;
-  }
-  const interpolated = path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "${input.params.$1}");
-  return `\`${interpolated}\``;
-}
-function buildRequestOptions(op) {
-  const opts = [];
-  if (op.query) {
-    opts.push("query: input?.query");
-  }
-  if (op.body) {
-    opts.push("body: input.body");
-  }
-  if (op.headers) {
-    opts.push("headers: input?.headers");
-  }
-  if (opts.length === 0) {
-    return "";
-  }
-  return `, { ${opts.join(", ")} }`;
-}
-function hasOperationInput(op) {
-  return !!(op.params || op.query || op.body || op.headers);
-}
-function isInputOptional(op) {
-  return !op.params && !op.body;
-}
-function emitOperationMethod(op) {
-  const imports = [];
-  const methodName = toCamelCase(op.operationId);
-  const inputTypeName = `${toPascalCase(op.operationId)}Input`;
-  const responseTypeName = `${toPascalCase(op.operationId)}Response`;
-  const hasInput = hasOperationInput(op);
-  if (hasInput) {
-    const optional = isInputOptional(op);
-    const inputParam = optional ? `input?: ${inputTypeName}` : `input: ${inputTypeName}`;
-    imports.push({ from: "../types", name: inputTypeName, isType: true });
-    imports.push({ from: "../types", name: responseTypeName, isType: true });
-    const pathExpr2 = buildPathExpression(op.path);
-    const reqOpts = buildRequestOptions(op);
-    const content2 = `${methodName}(${inputParam}): Promise<SDKResult<${responseTypeName}>> {
-  return client.request('${op.method}', ${pathExpr2}${reqOpts});
-}`;
-    return { content: content2, imports };
-  }
-  imports.push({ from: "../types", name: responseTypeName, isType: true });
-  const pathExpr = buildPathExpression(op.path);
-  const content = `${methodName}(): Promise<SDKResult<${responseTypeName}>> {
-  return client.request('${op.method}', ${pathExpr});
-}`;
-  return { content, imports };
-}
-function emitStreamingMethod(op) {
-  const imports = [];
-  const methodName = toCamelCase(op.operationId);
-  const inputTypeName = `${toPascalCase(op.operationId)}Input`;
-  const eventTypeName = `${toPascalCase(op.operationId)}Event`;
-  const format = op.streaming?.format ?? "sse";
-  imports.push({ from: "../types", name: eventTypeName, isType: true });
-  const hasInput = hasOperationInput(op);
-  const pathExpr = buildPathExpression(op.path);
-  const streamOpts = [];
-  streamOpts.push(`method: '${op.method}'`);
-  streamOpts.push(`path: ${pathExpr}`);
-  if (op.query) {
-    streamOpts.push("query: input?.query");
-  }
-  streamOpts.push(`format: '${format}'`);
-  const optsStr = streamOpts.join(`,
-    `);
-  if (hasInput) {
-    const optional = isInputOptional(op);
-    const inputParam = optional ? `input?: ${inputTypeName}` : `input: ${inputTypeName}`;
-    imports.push({ from: "../types", name: inputTypeName, isType: true });
-    const content2 = `async *${methodName}(${inputParam}): AsyncGenerator<${eventTypeName}> {
-  yield* client.requestStream<${eventTypeName}>({
-    ${optsStr},
-  });
-}`;
-    return { content: content2, imports };
-  }
-  const content = `async *${methodName}(): AsyncGenerator<${eventTypeName}> {
-  yield* client.requestStream<${eventTypeName}>({
-    ${optsStr},
-  });
-}`;
-  return { content, imports };
-}
-function emitModuleFile(module) {
-  const fragments = [];
-  for (const op of module.operations) {
-    if (op.streaming) {
-      fragments.push(emitStreamingMethod(op));
-    } else {
-      fragments.push(emitOperationMethod(op));
-    }
-  }
-  const allImports = mergeImports(fragments.flatMap((f) => f.imports));
-  const importBlock = renderImports(allImports);
-  const factoryName = `create${toPascalCase(module.name)}Module`;
-  const methods = fragments.map((f) => `    ${f.content}`).join(`,
-`);
-  const sections = [FILE_HEADER2];
-  if (importBlock) {
-    sections.push(importBlock);
-    sections.push("");
-  }
-  sections.push(`export function ${factoryName}(client: FetchClient) {
-  return {
-${methods},
-  };
-}`);
-  const fetchClientImport = "import { FetchClient } from '@vertz/fetch';";
-  const content = sections.join(`
-`);
-  const withFetchImport = content.replace(FILE_HEADER2, `${FILE_HEADER2}
-${fetchClientImport}
-`);
-  return {
-    path: `modules/${module.name}.ts`,
-    content: withFetchImport
-  };
-}
-function emitClientFile(ir) {
-  const sections = [FILE_HEADER2];
-  const imports = [];
-  imports.push({ from: "@vertz/fetch", name: "FetchClient", isType: false });
-  const configFragment = emitSDKConfig(ir.auth);
-  imports.push(...configFragment.imports);
-  const authFragment = emitAuthStrategyBuilder(ir.auth);
-  imports.push(...authFragment.imports);
-  for (const mod of ir.modules) {
-    const factoryName = `create${toPascalCase(mod.name)}Module`;
-    imports.push({ from: `./modules/${mod.name}`, name: factoryName, isType: false });
-  }
-  const allImports = mergeImports(imports);
-  const importBlock = renderImports(allImports);
-  if (importBlock) {
-    sections.push(importBlock);
-    sections.push("");
-  }
-  sections.push(`export interface SDKResult<T> {
-  data: T;
-  status: number;
-  headers: Headers;
-}`);
-  sections.push("");
-  sections.push(configFragment.content);
-  sections.push("");
-  const moduleEntries = ir.modules.map((mod) => `    ${toCamelCase(mod.name)}: create${toPascalCase(mod.name)}Module(client)`).join(`,
-`);
-  const createClientBody = [
-    "export function createClient(config: SDKConfig) {",
-    `  ${authFragment.content.split(`
-`).join(`
-  `)}`,
-    "",
-    "  const client = new FetchClient({",
-    "    ...config,",
-    "    authStrategies,",
-    "  });",
-    "",
-    "  return {",
-    moduleEntries,
-    "  };",
-    "}"
-  ].join(`
-`);
-  sections.push(createClientBody);
-  return {
-    path: "client.ts",
-    content: sections.join(`
-`)
-  };
-}
 
-// src/generators/typescript/emit-sdk.ts
-var FILE_HEADER3 = `// Generated by @vertz/codegen — do not edit
-`;
-function jsonSchemaToSchemaCall(schema) {
-  const type = schema.type;
-  if (type === "string")
-    return "s.string()";
-  if (type === "number")
-    return "s.number()";
-  if (type === "integer")
-    return "s.int()";
-  if (type === "boolean")
-    return "s.boolean()";
-  if (type === "array") {
-    const items = schema.items;
-    if (items) {
-      return `s.array(${jsonSchemaToSchemaCall(items)})`;
+class ClientGenerator {
+  name = "client";
+  generate(ir, config) {
+    return [
+      this.generateClient(ir),
+      this.generatePackageJson(config.outputDir),
+      this.generateReadme(ir)
+    ];
+  }
+  generateClient(ir) {
+    const entities = ir.entities ?? [];
+    const lines = [FILE_HEADER];
+    if (entities.length > 0) {
+      lines.push("import { FetchClient } from '@vertz/fetch';");
+      for (const entity of entities) {
+        const pascal = toPascalCase(entity.entityName);
+        lines.push(`import { create${pascal}Sdk } from './entities/${entity.entityName}';`);
+      }
+      lines.push("");
     }
-    return "s.array(s.unknown())";
-  }
-  if (type === "object") {
-    const properties = schema.properties;
-    if (!properties || Object.keys(properties).length === 0) {
-      return "s.object({})";
+    lines.push("export interface ClientOptions {");
+    lines.push("  baseURL?: string;");
+    lines.push("  headers?: Record<string, string>;");
+    lines.push("  timeoutMs?: number;");
+    lines.push("}");
+    lines.push("");
+    lines.push("export function createClient(options: ClientOptions = {}) {");
+    if (entities.length > 0) {
+      lines.push(`  const client = new FetchClient({ baseURL: options.baseURL ?? '/api', headers: options.headers, timeoutMs: options.timeoutMs });`);
+      lines.push("  return {");
+      for (const entity of entities) {
+        const pascal = toPascalCase(entity.entityName);
+        const camel = toCamelCase(entity.entityName);
+        lines.push(`    ${camel}: create${pascal}Sdk(client),`);
+      }
+      lines.push("  };");
+    } else {
+      lines.push("  return {};");
     }
-    const required = schema.required ?? [];
-    const fields = Object.entries(properties).map(([key, propSchema]) => {
-      const call = jsonSchemaToSchemaCall(propSchema);
-      if (required.includes(key)) {
-        return `  ${key}: ${call}`;
+    lines.push("}");
+    lines.push("");
+    lines.push("export type Client = ReturnType<typeof createClient>;");
+    return { path: "client.ts", content: lines.join(`
+`) };
+  }
+  generatePackageJson(outputDir) {
+    const dir = `./${posix.normalize(outputDir.replace(/\\/g, "/"))}`;
+    const pkg = {
+      imports: {
+        "#generated": `${dir}/client.ts`,
+        "#generated/types": `${dir}/types/index.ts`
       }
-      return `  ${key}: ${call}.optional()`;
-    });
-    return `s.object({
-${fields.join(`,
-`)},
-})`;
-  }
-  return "s.unknown()";
-}
-function emitSchemaReExports(schemas) {
-  const sections = [FILE_HEADER3];
-  if (schemas.length > 0) {
-    sections.push("import { s } from '@vertz/schema';");
-    sections.push("");
-  }
-  for (const schema of schemas) {
-    const validatorName = `${schema.name}Schema`;
-    const schemaCall = jsonSchemaToSchemaCall(schema.jsonSchema);
-    sections.push(`export const ${validatorName} = ${schemaCall};`);
-  }
-  return {
-    path: "schemas.ts",
-    content: sections.join(`
-`)
-  };
-}
-function emitBarrelIndex(ir) {
-  const lines = [FILE_HEADER3];
-  lines.push("export { createClient } from './client';");
-  lines.push("export type { SDKConfig, SDKResult } from './client';");
-  for (const mod of ir.modules) {
-    lines.push(`export * from './types/${mod.name}';`);
-  }
-  if (ir.schemas.length > 0) {
-    lines.push("export * from './types/shared';");
-  }
-  if (ir.schemas.length > 0) {
-    lines.push("export * from './schemas';");
-  }
-  return {
-    path: "index.ts",
-    content: lines.join(`
-`)
-  };
-}
-function emitPackageJson(ir, options) {
-  const dependencies = {
-    "@vertz/fetch": "*"
-  };
-  if (ir.schemas.length > 0) {
-    dependencies["@vertz/schema"] = "*";
+    };
+    return { path: "package.json", content: `${JSON.stringify(pkg, null, 2)}
+` };
   }
-  const pkg = {
-    name: options.packageName,
-    version: options.packageVersion ?? "0.0.0",
-    description: "Generated by @vertz/codegen",
-    private: true,
-    main: "index.ts",
-    types: "index.ts",
-    dependencies
-  };
-  return {
-    path: "package.json",
-    content: JSON.stringify(pkg, null, 2)
-  };
-}
-
-// src/json-schema-converter.ts
-var PRIMITIVE_MAP = {
-  string: "string",
-  number: "number",
-  integer: "number",
-  boolean: "boolean",
-  null: "null"
-};
-function jsonSchemaToTS(schema, ctx) {
-  const context = ctx ?? {
-    namedTypes: new Map,
-    resolving: new Set
-  };
-  const type = convert(schema, context);
-  return { type, extractedTypes: context.namedTypes };
-}
-function convert(schema, _ctx) {
-  if (schema.$defs && typeof schema.$defs === "object") {
-    const defs = schema.$defs;
-    for (const [name, defSchema] of Object.entries(defs)) {
-      if (!_ctx.namedTypes.has(name)) {
-        _ctx.resolving.add(name);
-        const typeStr = convert(defSchema, _ctx);
-        _ctx.resolving.delete(name);
-        _ctx.namedTypes.set(name, typeStr);
+  generateReadme(ir) {
+    const entities = ir.entities ?? [];
+    const lines = [];
+    lines.push("# Generated Client");
+    lines.push("");
+    lines.push("Auto-generated by `@vertz/codegen`. Do not edit manually.");
+    lines.push("");
+    lines.push("## Usage");
+    lines.push("");
+    lines.push("```typescript");
+    lines.push("import { createClient } from '#generated';");
+    lines.push("");
+    lines.push("const api = createClient();");
+    lines.push("```");
+    lines.push("");
+    lines.push("## Type Imports");
+    lines.push("");
+    lines.push("```typescript");
+    lines.push("import type { ... } from '#generated/types';");
+    lines.push("```");
+    if (entities.length > 0) {
+      lines.push("");
+      lines.push("## Available Resources");
+      lines.push("");
+      for (const entity of entities) {
+        const camel = toCamelCase(entity.entityName);
+        const methods = this.getEntityMethods(entity);
+        lines.push(`- \`client.${camel}\` — ${methods}`);
       }
     }
+    lines.push("");
+    return { path: "README.md", content: lines.join(`
+`) };
   }
-  if (typeof schema.$ref === "string") {
-    if (!schema.$ref.startsWith("#")) {
-      throw new Error(`External $ref is not supported: ${schema.$ref}`);
+  getEntityMethods(entity) {
+    const methods = [];
+    for (const op of entity.operations) {
+      methods.push(op.kind);
     }
-    return refToName(schema.$ref);
-  }
-  if (schema.const !== undefined) {
-    return toLiteral(schema.const);
-  }
-  if (Array.isArray(schema.enum)) {
-    return schema.enum.map((v) => toLiteral(v)).join(" | ");
-  }
-  if (Array.isArray(schema.oneOf)) {
-    return schema.oneOf.map((s) => convert(s, _ctx)).join(" | ");
-  }
-  if (Array.isArray(schema.anyOf)) {
-    return schema.anyOf.map((s) => convert(s, _ctx)).join(" | ");
-  }
-  if (Array.isArray(schema.allOf)) {
-    return schema.allOf.map((s) => convert(s, _ctx)).join(" & ");
-  }
-  if (Array.isArray(schema.type)) {
-    return schema.type.map((t) => PRIMITIVE_MAP[t] ?? t).join(" | ");
-  }
-  if (typeof schema.type === "string") {
-    const type = schema.type;
-    if (type === "array") {
-      if (Array.isArray(schema.prefixItems)) {
-        const items = schema.prefixItems.map((s) => convert(s, _ctx));
-        return `[${items.join(", ")}]`;
-      }
-      if (schema.items && typeof schema.items === "object") {
-        const itemType = convert(schema.items, _ctx);
-        return itemType.includes(" | ") ? `(${itemType})[]` : `${itemType}[]`;
-      }
-      return "unknown[]";
-    }
-    if (type === "object") {
-      if (schema.additionalProperties && typeof schema.additionalProperties === "object" && !schema.properties) {
-        const valueType = convert(schema.additionalProperties, _ctx);
-        return `Record<string, ${valueType}>`;
-      }
-      if (schema.properties && typeof schema.properties === "object") {
-        const props = schema.properties;
-        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
-        const parts = [];
-        for (const [key, propSchema] of Object.entries(props)) {
-          const propType = convert(propSchema, _ctx);
-          const optional = required.has(key) ? "" : "?";
-          parts.push(`${key}${optional}: ${propType}`);
-        }
-        return `{ ${parts.join("; ")} }`;
-      }
-      return "Record<string, unknown>";
+    for (const action of entity.actions) {
+      methods.push(action.name);
     }
-    return PRIMITIVE_MAP[type] ?? "unknown";
+    return methods.length > 0 ? methods.join(", ") : "no operations";
   }
-  return "unknown";
-}
-function refToName(ref) {
-  const segments = ref.split("/");
-  return segments[segments.length - 1] ?? "unknown";
-}
-function toLiteral(value) {
-  if (typeof value === "string")
-    return `'${value}'`;
-  if (typeof value === "number" || typeof value === "boolean")
-    return String(value);
-  if (value === null)
-    return "null";
-  return "unknown";
 }
 
-// src/generators/typescript/emit-types.ts
-var FILE_HEADER4 = `// Generated by @vertz/codegen — do not edit
+// src/generators/entity-schema-generator.ts
+var FILE_HEADER2 = `// Generated by @vertz/codegen — do not edit
+
 `;
-function emitTypeDeclaration(name, tsType) {
-  if (tsType.startsWith("{")) {
-    return `export interface ${name} ${tsType}`;
-  }
-  return `export type ${name} = ${tsType};`;
-}
-function emitInterfaceFromSchema(schema) {
-  const result = jsonSchemaToTS(schema.jsonSchema);
-  const lines = [];
-  for (const [name, tsType] of result.extractedTypes) {
-    lines.push(emitTypeDeclaration(name, tsType));
-    lines.push("");
-  }
-  const jsdocParts = [];
-  if (schema.annotations.description) {
-    jsdocParts.push(schema.annotations.description);
-  }
-  if (schema.annotations.deprecated) {
-    jsdocParts.push("@deprecated");
-  }
-  if (jsdocParts.length > 0) {
-    lines.push(`/** ${jsdocParts.join(`
- * `)} */`);
-  }
-  lines.push(emitTypeDeclaration(schema.name, result.type));
-  return { content: lines.join(`
-`), imports: [] };
+var TYPE_MAP = {
+  string: "s.string()",
+  number: "s.number()",
+  boolean: "s.boolean()",
+  date: "s.string()",
+  unknown: "s.unknown()"
+};
+function toLowerFirst(s) {
+  return s.charAt(0).toLowerCase() + s.slice(1);
 }
-function emitOperationInputType(op) {
-  const typeName = `${toPascalCase(op.operationId)}Input`;
-  const imports = [];
-  const slots = [];
-  if (op.params) {
-    const ref = op.schemaRefs.params;
-    if (ref) {
-      slots.push(`params: ${ref}`);
-      imports.push({ from: "", name: ref, isType: true });
-    } else {
-      const result = jsonSchemaToTS(op.params);
-      slots.push(`params: ${result.type}`);
-    }
-  }
-  if (op.query) {
-    const ref = op.schemaRefs.query;
-    if (ref) {
-      slots.push(`query?: ${ref}`);
-      imports.push({ from: "", name: ref, isType: true });
-    } else {
-      const result = jsonSchemaToTS(op.query);
-      slots.push(`query?: ${result.type}`);
-    }
-  }
-  if (op.body) {
-    const ref = op.schemaRefs.body;
-    if (ref) {
-      slots.push(`body: ${ref}`);
-      imports.push({ from: "", name: ref, isType: true });
-    } else {
-      const result = jsonSchemaToTS(op.body);
-      slots.push(`body: ${result.type}`);
-    }
-  }
-  if (op.headers) {
-    const ref = op.schemaRefs.headers;
-    if (ref) {
-      slots.push(`headers?: ${ref}`);
-      imports.push({ from: "", name: ref, isType: true });
-    } else {
-      const result = jsonSchemaToTS(op.headers);
-      slots.push(`headers?: ${result.type}`);
+
+class EntitySchemaGenerator {
+  name = "entity-schema";
+  generate(ir, _config) {
+    if (!ir.entities?.length)
+      return [];
+    const files = [];
+    const entitiesWithSchemas = [];
+    for (const entity of ir.entities) {
+      const schemaOps = entity.operations.filter((op) => (op.kind === "create" || op.kind === "update") && op.resolvedFields && op.resolvedFields.length > 0);
+      const schemaActions = entity.actions.filter((a) => a.resolvedInputFields && a.resolvedInputFields.length > 0);
+      if (schemaOps.length === 0 && schemaActions.length === 0)
+        continue;
+      entitiesWithSchemas.push(entity);
+      files.push(this.generateEntitySchema(entity, schemaOps, schemaActions));
     }
-  }
-  if (slots.length === 0) {
-    return { content: "", imports: [] };
-  }
-  const lines = [];
-  lines.push(`/** Input for ${op.operationId} */`);
-  lines.push(`export interface ${typeName} { ${slots.join("; ")} }`);
-  return { content: lines.join(`
-`), imports };
-}
-function emitOperationResponseType(op) {
-  const typeName = `${toPascalCase(op.operationId)}Response`;
-  const imports = [];
-  if (!op.response) {
-    return {
-      content: `export type ${typeName} = void;`,
-      imports: []
-    };
-  }
-  const ref = op.schemaRefs.response;
-  if (ref) {
-    imports.push({ from: "", name: ref, isType: true });
-    return {
-      content: `export type ${typeName} = ${ref};`,
-      imports
-    };
-  }
-  const result = jsonSchemaToTS(op.response);
-  return {
-    content: emitTypeDeclaration(typeName, result.type),
-    imports: []
-  };
-}
-function emitStreamingEventType(op) {
-  if (!op.streaming) {
-    return { content: "", imports: [] };
-  }
-  const typeName = `${toPascalCase(op.operationId)}Event`;
-  if (!op.streaming.eventSchema) {
-    return {
-      content: `export type ${typeName} = unknown;`,
-      imports: []
-    };
-  }
-  const result = jsonSchemaToTS(op.streaming.eventSchema);
-  return {
-    content: emitTypeDeclaration(typeName, result.type),
-    imports: []
-  };
-}
-function emitModuleTypesFile(module, schemas) {
-  const sections = [FILE_HEADER4];
-  for (const schema of schemas) {
-    const fragment = emitInterfaceFromSchema(schema);
-    if (fragment.content) {
-      sections.push(fragment.content);
+    if (entitiesWithSchemas.length > 0) {
+      files.push(this.generateIndex(entitiesWithSchemas));
     }
+    return files;
   }
-  for (const op of module.operations) {
-    const inputFragment = emitOperationInputType(op);
-    if (inputFragment.content) {
-      sections.push(inputFragment.content);
-    }
-    const responseFragment = emitOperationResponseType(op);
-    if (responseFragment.content) {
-      sections.push(responseFragment.content);
+  generateEntitySchema(entity, schemaOps, schemaActions) {
+    const lines = [FILE_HEADER2];
+    lines.push("import { s } from '@vertz/schema';");
+    lines.push("");
+    for (const op of schemaOps) {
+      if (!op.resolvedFields)
+        continue;
+      const varName = `${toLowerFirst(op.inputSchema ?? `${op.kind}Input`)}Schema`;
+      const fields = op.resolvedFields.map((f) => {
+        const baseCall = TYPE_MAP[f.tsType] ?? "s.unknown()";
+        const call = f.optional ? `${baseCall}.optional()` : baseCall;
+        return `  ${f.name}: ${call}`;
+      }).join(`,
+`);
+      lines.push(`export const ${varName} = s.object({`);
+      lines.push(`${fields},`);
+      lines.push("});");
+      lines.push("");
     }
-    const streamingFragment = emitStreamingEventType(op);
-    if (streamingFragment.content) {
-      sections.push(streamingFragment.content);
+    for (const action of schemaActions) {
+      if (!action.resolvedInputFields)
+        continue;
+      const varName = `${toLowerFirst(action.inputSchema ?? `${action.name}Input`)}Schema`;
+      const fields = action.resolvedInputFields.map((f) => {
+        const baseCall = TYPE_MAP[f.tsType] ?? "s.unknown()";
+        const call = f.optional ? `${baseCall}.optional()` : baseCall;
+        return `  ${f.name}: ${call}`;
+      }).join(`,
+`);
+      lines.push(`export const ${varName} = s.object({`);
+      lines.push(`${fields},`);
+      lines.push("});");
+      lines.push("");
     }
-  }
-  return {
-    path: `types/${module.name}.ts`,
-    content: sections.join(`
-
+    return {
+      path: `schemas/${entity.entityName}.ts`,
+      content: lines.join(`
 `)
-  };
-}
-function emitSharedTypesFile(schemas) {
-  const sections = [FILE_HEADER4];
-  for (const schema of schemas) {
-    const fragment = emitInterfaceFromSchema(schema);
-    if (fragment.content) {
-      sections.push(fragment.content);
+    };
+  }
+  generateIndex(entities) {
+    const lines = [FILE_HEADER2];
+    for (const entity of entities) {
+      const exports = [];
+      const schemaOps = entity.operations.filter((op) => (op.kind === "create" || op.kind === "update") && op.resolvedFields && op.resolvedFields.length > 0);
+      for (const op of schemaOps) {
+        const varName = `${toLowerFirst(op.inputSchema ?? `${op.kind}Input`)}Schema`;
+        exports.push(varName);
+      }
+      const schemaActions = entity.actions.filter((a) => a.resolvedInputFields && a.resolvedInputFields.length > 0);
+      for (const action of schemaActions) {
+        const varName = `${toLowerFirst(action.inputSchema ?? `${action.name}Input`)}Schema`;
+        exports.push(varName);
+      }
+      if (exports.length > 0) {
+        lines.push(`export { ${exports.join(", ")} } from './${entity.entityName}';`);
+      }
     }
+    return { path: "schemas/index.ts", content: lines.join(`
+`) };
   }
-  return {
-    path: "types/shared.ts",
-    content: sections.join(`
-
-`)
-  };
 }
 
-// src/generators/typescript/emit-routes.ts
-var FILE_HEADER5 = `// Generated by @vertz/codegen — do not edit
+// src/generators/entity-sdk-generator.ts
+var FILE_HEADER3 = `// Generated by @vertz/codegen — do not edit
+
 `;
-function paramsToTS(op) {
-  if (!op.params) {
-    return "Record<string, never>";
-  }
-  const ref = op.schemaRefs.params;
-  if (ref) {
-    return ref;
-  }
-  const result = jsonSchemaToTS(op.params);
-  return result.type;
-}
-function queryToTS(op) {
-  if (!op.query) {
-    return "Record<string, never>";
-  }
-  const ref = op.schemaRefs.query;
-  if (ref) {
-    return ref;
-  }
-  const result = jsonSchemaToTS(op.query);
-  return result.type;
+function toPascalCase2(s) {
+  return s.split("-").map((w) => w[0]?.toUpperCase() + w.slice(1)).join("");
 }
-function bodyToTS(op) {
-  if (!op.body) {
-    return "never";
+
+class EntitySdkGenerator {
+  name = "entity-sdk";
+  generate(ir, _config) {
+    if (!ir.entities?.length)
+      return [];
+    const files = [];
+    for (const entity of ir.entities) {
+      files.push(this.generateEntitySdk(entity, ir.basePath));
+    }
+    files.push(this.generateIndex(ir.entities));
+    return files;
+  }
+  generateEntitySdk(entity, _basePath) {
+    const pascal = toPascalCase2(entity.entityName);
+    const lines = [FILE_HEADER3];
+    const createOpsWithMeta = entity.operations.filter((op) => op.kind === "create" && op.resolvedFields && op.resolvedFields.length > 0);
+    const hasSchemaImports = createOpsWithMeta.length > 0;
+    if (hasSchemaImports) {
+      const schemaImports = [];
+      for (const op of createOpsWithMeta) {
+        const schemaVarName = `${(op.inputSchema ?? "createInput").charAt(0).toLowerCase()}${(op.inputSchema ?? "createInput").slice(1)}Schema`;
+        schemaImports.push(schemaVarName);
+      }
+      lines.push(`import { ${schemaImports.join(", ")} } from '../schemas/${entity.entityName}';`);
+    }
+    const hasTypes = entity.operations.some((op) => op.outputSchema || op.inputSchema);
+    const hasListOp = entity.operations.some((op) => op.kind === "list");
+    if (hasTypes) {
+      const typeImports = new Set;
+      for (const op of entity.operations) {
+        if (op.outputSchema)
+          typeImports.add(op.outputSchema);
+        if (op.inputSchema)
+          typeImports.add(op.inputSchema);
+      }
+      for (const action of entity.actions) {
+        if (action.inputSchema)
+          typeImports.add(action.inputSchema);
+        if (action.outputSchema)
+          typeImports.add(action.outputSchema);
+      }
+      lines.push(`import type { ${[...typeImports].join(", ")} } from '../types/${entity.entityName}';`);
+      const fetchImports = hasListOp ? "type FetchClient, type ListResponse, createDescriptor" : "type FetchClient, createDescriptor";
+      lines.push(`import { ${fetchImports} } from '@vertz/fetch';`);
+      lines.push("");
+    }
+    lines.push(`export function create${pascal}Sdk(client: FetchClient) {`);
+    lines.push("  return {");
+    for (const op of entity.operations) {
+      const inputType = op.inputSchema ?? "unknown";
+      const outputType = op.outputSchema ?? "unknown";
+      const listOutput = op.kind === "list" ? `ListResponse<${outputType}>` : outputType;
+      switch (op.kind) {
+        case "list":
+          lines.push(`    list: Object.assign(`);
+          lines.push(`      (query?: Record<string, unknown>) => createDescriptor('GET', '${op.path}', () => client.get<${listOutput}>('${op.path}', { query }), query),`);
+          lines.push(`      { url: '${op.path}', method: 'GET' as const },`);
+          lines.push(`    ),`);
+          break;
+        case "get":
+          lines.push(`    get: Object.assign(`);
+          lines.push(`      (id: string) => createDescriptor('GET', \`${op.path.replace(":id", "${id}")}\`, () => client.get<${outputType}>(\`${op.path.replace(":id", "${id}")}\`)),`);
+          lines.push(`      { url: '${op.path}', method: 'GET' as const },`);
+          lines.push(`    ),`);
+          break;
+        case "create":
+          if (op.resolvedFields && op.resolvedFields.length > 0) {
+            const schemaVarName = `${(op.inputSchema ?? "createInput").charAt(0).toLowerCase()}${(op.inputSchema ?? "createInput").slice(1)}Schema`;
+            lines.push(`    create: Object.assign(`);
+            lines.push(`      (body: ${inputType}) => createDescriptor('POST', '${op.path}', () => client.post<${outputType}>('${op.path}', body)),`);
+            lines.push(`      {`);
+            lines.push(`        url: '${op.path}',`);
+            lines.push(`        method: 'POST' as const,`);
+            lines.push(`        meta: { bodySchema: ${schemaVarName} },`);
+            lines.push(`      },`);
+            lines.push(`    ),`);
+          } else {
+            lines.push(`    create: Object.assign(`);
+            lines.push(`      (body: ${inputType}) => createDescriptor('POST', '${op.path}', () => client.post<${outputType}>('${op.path}', body)),`);
+            lines.push(`      { url: '${op.path}', method: 'POST' as const },`);
+            lines.push(`    ),`);
+          }
+          break;
+        case "update":
+          lines.push(`    update: Object.assign(`);
+          lines.push(`      (id: string, body: ${inputType}) => createDescriptor('PATCH', \`${op.path.replace(":id", "${id}")}\`, () => client.patch<${outputType}>(\`${op.path.replace(":id", "${id}")}\`, body)),`);
+          lines.push(`      { url: '${op.path}', method: 'PATCH' as const },`);
+          lines.push(`    ),`);
+          break;
+        case "delete":
+          lines.push(`    delete: Object.assign(`);
+          lines.push(`      (id: string) => createDescriptor('DELETE', \`${op.path.replace(":id", "${id}")}\`, () => client.delete<${outputType}>(\`${op.path.replace(":id", "${id}")}\`)),`);
+          lines.push(`      { url: '${op.path}', method: 'DELETE' as const },`);
+          lines.push(`    ),`);
+          break;
+      }
+    }
+    for (const action of entity.actions) {
+      const inputType = action.inputSchema ?? "unknown";
+      const outputType = action.outputSchema ?? "unknown";
+      const method = action.method ?? "POST";
+      const methodLower = method.toLowerCase();
+      const hasId = action.hasId ?? action.path.includes(":id");
+      const pathExpr = hasId ? `\`${action.path.replace(":id", "${id}")}\`` : `'${action.path}'`;
+      const hasBody = method === "POST" || method === "PUT" || method === "PATCH";
+      const params = [];
+      if (hasId)
+        params.push("id: string");
+      if (hasBody)
+        params.push(`body: ${inputType}`);
+      const paramStr = params.join(", ");
+      const clientArgs = hasBody ? `${pathExpr}, body` : pathExpr;
+      const clientCall = `client.${methodLower}<${outputType}>(${clientArgs})`;
+      lines.push(`    ${action.name}: Object.assign(`);
+      lines.push(`      (${paramStr}) => createDescriptor('${method}', ${pathExpr}, () => ${clientCall}${hasBody ? ", body" : ""}),`);
+      lines.push(`      { url: '${action.path}', method: '${method}' as const },`);
+      lines.push("    ),");
+    }
+    lines.push("  };");
+    lines.push("}");
+    return {
+      path: `entities/${entity.entityName}.ts`,
+      content: lines.join(`
+`)
+    };
   }
-  const ref = op.schemaRefs.body;
-  if (ref) {
-    return ref;
+  generateIndex(entities) {
+    const lines = [FILE_HEADER3];
+    for (const entity of entities) {
+      const pascal = toPascalCase2(entity.entityName);
+      lines.push(`export { create${pascal}Sdk } from './${entity.entityName}';`);
+    }
+    return { path: "entities/index.ts", content: lines.join(`
+`) };
   }
-  const result = jsonSchemaToTS(op.body);
-  return result.type;
 }
-function headersToTS(op) {
-  if (!op.headers) {
-    return "Record<string, never>";
-  }
-  const ref = op.schemaRefs.headers;
-  if (ref) {
-    return ref;
+
+// src/generators/entity-types-generator.ts
+var FILE_HEADER4 = `// Generated by @vertz/codegen — do not edit
+
+`;
+var TS_TYPE_MAP = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+  date: "string",
+  unknown: "unknown"
+};
+
+class EntityTypesGenerator {
+  name = "entity-types";
+  generate(ir, _config) {
+    if (!ir.entities?.length)
+      return [];
+    const files = [];
+    const entitiesWithTypes = [];
+    for (const entity of ir.entities) {
+      const hasOpTypes = entity.operations.some((op) => op.inputSchema || op.outputSchema);
+      const hasActionTypes = entity.actions.some((a) => a.resolvedInputFields?.length || a.resolvedOutputFields?.length);
+      if (!hasOpTypes && !hasActionTypes)
+        continue;
+      entitiesWithTypes.push(entity);
+      files.push(this.generateEntityTypes(entity));
+    }
+    if (entitiesWithTypes.length > 0) {
+      files.push(this.generateIndex(entitiesWithTypes));
+    }
+    return files;
+  }
+  generateEntityTypes(entity) {
+    const lines = [FILE_HEADER4];
+    const emitted = new Set;
+    for (const op of entity.operations) {
+      if (op.inputSchema && !emitted.has(op.inputSchema)) {
+        const inputType = this.emitBodyType(op.inputSchema, op.resolvedFields);
+        if (inputType) {
+          lines.push(inputType);
+          lines.push("");
+          emitted.add(op.inputSchema);
+        }
+      }
+      if (op.outputSchema && !emitted.has(op.outputSchema)) {
+        const outputType = this.emitResponseType(op.outputSchema, op.responseFields);
+        if (outputType) {
+          lines.push(outputType);
+          lines.push("");
+          emitted.add(op.outputSchema);
+        }
+      }
+    }
+    for (const action of entity.actions) {
+      if (action.inputSchema && !emitted.has(action.inputSchema)) {
+        const inputType = this.emitBodyType(action.inputSchema, action.resolvedInputFields);
+        if (inputType) {
+          lines.push(inputType);
+          lines.push("");
+          emitted.add(action.inputSchema);
+        }
+      }
+      if (action.outputSchema && !emitted.has(action.outputSchema)) {
+        const outputType = this.emitResponseType(action.outputSchema, action.resolvedOutputFields);
+        if (outputType) {
+          lines.push(outputType);
+          lines.push("");
+          emitted.add(action.outputSchema);
+        }
+      }
+    }
+    return {
+      path: `types/${entity.entityName}.ts`,
+      content: lines.join(`
+`)
+    };
   }
-  const result = jsonSchemaToTS(op.headers);
-  return result.type;
-}
-function responseToTS(op) {
-  if (!op.response) {
-    return "void";
+  emitBodyType(typeName, fields) {
+    if (!fields || fields.length === 0)
+      return;
+    const props = fields.map((f) => {
+      const tsType = TS_TYPE_MAP[f.tsType] ?? "unknown";
+      const optional = f.optional ? "?" : "";
+      return `  ${f.name}${optional}: ${tsType}`;
+    }).join(`;
+`);
+    return `export interface ${typeName} {
+${props};
+}`;
   }
-  const ref = op.schemaRefs.response;
-  if (ref) {
-    return ref;
+  emitResponseType(typeName, fields) {
+    if (!fields || fields.length === 0)
+      return;
+    const props = fields.map((f) => {
+      const tsType = TS_TYPE_MAP[f.tsType] ?? "unknown";
+      const optional = f.optional ? "?" : "";
+      return `  ${f.name}${optional}: ${tsType}`;
+    }).join(`;
+`);
+    return `export interface ${typeName} {
+${props};
+}`;
   }
-  const result = jsonSchemaToTS(op.response);
-  return result.type;
-}
-function emitRouteEntry(op) {
-  const routeKey = `${op.method} ${op.path}`;
-  const params = paramsToTS(op);
-  const query = queryToTS(op);
-  const body = bodyToTS(op);
-  const headers = headersToTS(op);
-  const response = responseToTS(op);
-  return `  '${routeKey}': { params: ${params}; query: ${query}; body: ${body}; headers: ${headers}; response: ${response} };`;
-}
-function emitRouteMapType(ir) {
-  const sections = [FILE_HEADER5];
-  sections.push("export interface AppRouteMap {");
-  const operations = ir.modules.flatMap((mod) => mod.operations);
-  if (operations.length === 0) {
-    sections.push("  [key: string]: never;");
-  } else {
-    const entries = operations.map((op) => emitRouteEntry(op));
-    sections.push(entries.join(`
-`));
+  generateIndex(entities) {
+    const lines = [FILE_HEADER4];
+    for (const entity of entities) {
+      lines.push(`export * from './${entity.entityName}';`);
+    }
+    return { path: "types/index.ts", content: lines.join(`
+`) };
   }
-  sections.push("}");
-  return {
-    path: "types/routes.ts",
-    content: sections.join(`
-`)
-  };
 }
 
 // src/incremental.ts
 import { mkdir as mkdir2, readdir, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, join as join2, relative } from "node:path";
+import { dirname as dirname2, join as join2, relative, resolve as resolve2 } from "node:path";
 
 // src/hasher.ts
 import { createHash } from "node:crypto";
@@ -1067,6 +639,10 @@ async function writeIncremental(files, outputDir, options) {
   const generatedPaths = new Set(files.map((f) => f.path));
   for (const file of files) {
     const filePath = join2(outputDir, file.path);
+    const resolvedPath = resolve2(filePath);
+    if (!resolvedPath.startsWith(resolve2(outputDir))) {
+      throw new Error(`Generated file path "${file.path}" escapes output directory`);
+    }
     const dir = dirname2(filePath);
     await mkdir2(dir, { recursive: true });
     let existingContent;
@@ -1116,122 +692,107 @@ function adaptIR(appIR) {
       }
     };
   });
-  const modules = appIR.modules.map((mod) => ({
-    name: mod.name,
-    operations: mod.routers.flatMap((router) => router.routes.map((route) => {
-      const resolveRef = (ref) => {
-        if (!ref || ref.kind !== "named")
-          return;
-        return renameMap.get(`${mod.name}:${ref.schemaName}`) ?? ref.schemaName;
-      };
-      const schemaRefs = {
-        params: resolveRef(route.params),
-        query: resolveRef(route.query),
-        body: resolveRef(route.body),
-        headers: resolveRef(route.headers),
-        response: resolveRef(route.response)
-      };
-      return {
-        operationId: route.operationId,
-        method: route.method,
-        path: route.fullPath,
-        description: route.description,
-        tags: route.tags,
-        params: route.params?.jsonSchema,
-        query: route.query?.jsonSchema,
-        body: route.body?.jsonSchema,
-        headers: route.headers?.jsonSchema,
-        response: route.response?.jsonSchema,
-        schemaRefs
-      };
-    }))
-  }));
-  const slotNames = {
-    params: "Params",
-    query: "Query",
-    body: "Body",
-    headers: "Headers",
-    response: "Response"
-  };
-  const inlineSchemas = [];
-  for (const mod of appIR.modules) {
-    for (const router of mod.routers) {
-      for (const route of router.routes) {
-        for (const [slot, suffix] of Object.entries(slotNames)) {
-          const ref = route[slot];
-          if (ref && typeof ref === "object" && "kind" in ref && ref.kind === "inline" && ref.jsonSchema) {
-            const name = `${toPascalCase(route.operationId)}${suffix}`;
-            inlineSchemas.push({
-              name,
-              jsonSchema: ref.jsonSchema,
-              annotations: { namingParts: {} }
-            });
-          }
+  const allSchemas = [...schemas].sort((a, b) => a.name.localeCompare(b.name));
+  const entities = (appIR.entities ?? []).map((entity) => {
+    const entityPascal = toPascalCase(entity.name);
+    const operations = [];
+    const crudOps = [
+      { kind: "list", method: "GET", path: `/${entity.name}`, schema: "response" },
+      { kind: "get", method: "GET", path: `/${entity.name}/:id`, schema: "response" },
+      { kind: "create", method: "POST", path: `/${entity.name}`, schema: "createInput" },
+      { kind: "update", method: "PATCH", path: `/${entity.name}/:id`, schema: "updateInput" },
+      { kind: "delete", method: "DELETE", path: `/${entity.name}/:id`, schema: "response" }
+    ];
+    for (const op of crudOps) {
+      const accessKind = entity.access[op.kind];
+      if (accessKind === "false")
+        continue;
+      let resolvedFields;
+      if (op.kind === "create" || op.kind === "update") {
+        const schemaRef = entity.modelRef.schemaRefs[op.schema];
+        if (schemaRef?.kind === "inline") {
+          resolvedFields = schemaRef.resolvedFields?.map((f) => ({
+            name: f.name,
+            tsType: f.tsType,
+            optional: f.optional
+          }));
         }
       }
+      let responseFields;
+      const responseRef = entity.modelRef.schemaRefs.response;
+      if (responseRef?.kind === "inline") {
+        responseFields = responseRef.resolvedFields?.map((f) => ({
+          name: f.name,
+          tsType: f.tsType,
+          optional: f.optional
+        }));
+      }
+      operations.push({
+        kind: op.kind,
+        method: op.method,
+        path: op.path,
+        operationId: `${op.kind}${entityPascal}`,
+        outputSchema: entity.modelRef.schemaRefs.resolved ? `${entityPascal}Response` : undefined,
+        inputSchema: (op.kind === "create" || op.kind === "update") && entity.modelRef.schemaRefs.resolved ? `${op.kind === "create" ? "Create" : "Update"}${entityPascal}Input` : undefined,
+        resolvedFields,
+        responseFields
+      });
     }
-  }
-  const allSchemas = [...schemas, ...inlineSchemas].sort((a, b) => a.name.localeCompare(b.name));
-  const sortedModules = modules.map((m) => ({
-    ...m,
-    operations: [...m.operations].sort((a, b) => a.operationId.localeCompare(b.operationId))
-  })).sort((a, b) => a.name.localeCompare(b.name));
+    const actions = entity.actions.filter((a) => entity.access.custom[a.name] !== "false").map((a) => {
+      const actionPascal = toPascalCase(a.name);
+      const path = a.path ? `/${entity.name}/${a.path}` : `/${entity.name}/:id/${a.name}`;
+      let resolvedInputFields;
+      if (a.body?.kind === "inline") {
+        resolvedInputFields = a.body.resolvedFields?.map((f) => ({
+          name: f.name,
+          tsType: f.tsType,
+          optional: f.optional
+        }));
+      }
+      let resolvedOutputFields;
+      if (a.response?.kind === "inline") {
+        resolvedOutputFields = a.response.resolvedFields?.map((f) => ({
+          name: f.name,
+          tsType: f.tsType,
+          optional: f.optional
+        }));
+      }
+      return {
+        name: a.name,
+        method: a.method,
+        operationId: `${a.name}${entityPascal}`,
+        path,
+        hasId: path.includes(":id"),
+        inputSchema: a.body ? `${actionPascal}${entityPascal}Input` : undefined,
+        outputSchema: a.response ? `${actionPascal}${entityPascal}Output` : undefined,
+        resolvedInputFields,
+        resolvedOutputFields
+      };
+    });
+    return { entityName: entity.name, operations, actions };
+  });
   return {
     basePath: appIR.app.basePath,
     version: appIR.app.version,
-    modules: sortedModules,
+    modules: [],
     schemas: allSchemas,
+    entities,
     auth: { schemes: [] }
   };
 }
 
 // src/generate.ts
-function runTypescriptGenerator(ir, config) {
-  const files = [];
-  const moduleSchemaNames = new Set;
-  for (const mod of ir.modules) {
-    for (const op of mod.operations) {
-      for (const ref of Object.values(op.schemaRefs)) {
-        if (ref)
-          moduleSchemaNames.add(ref);
-      }
-    }
-  }
-  const sharedSchemas = ir.schemas.filter((s) => !moduleSchemaNames.has(s.name));
-  for (const mod of ir.modules) {
-    const moduleRefNames = new Set;
-    for (const op of mod.operations) {
-      for (const ref of Object.values(op.schemaRefs)) {
-        if (ref)
-          moduleRefNames.add(ref);
-      }
-    }
-    const moduleSchemas = ir.schemas.filter((s) => moduleRefNames.has(s.name));
-    files.push(emitModuleTypesFile(mod, moduleSchemas));
-  }
-  if (sharedSchemas.length > 0) {
-    files.push(emitSharedTypesFile(sharedSchemas));
-  }
-  files.push(emitRouteMapType(ir));
-  for (const mod of ir.modules) {
-    files.push(emitModuleFile(mod));
-  }
-  files.push(emitClientFile(ir));
-  if (ir.schemas.length > 0) {
-    files.push(emitSchemaReExports(ir.schemas));
-  }
-  files.push(emitBarrelIndex(ir));
-  if (config.typescript?.publishable) {
-    files.push(emitPackageJson(ir, {
-      packageName: config.typescript.publishable.name,
-      packageVersion: config.typescript.publishable.version
-    }));
-  }
-  return files;
-}
-function runCLIGenerator(ir) {
+function runTypescriptGenerator(ir, _config) {
   const files = [];
-  files.push(emitManifestFile(ir));
+  const generatorConfig = { outputDir: _config.outputDir, options: {} };
+  const entityTypesGen = new EntityTypesGenerator;
+  files.push(...entityTypesGen.generate(ir, generatorConfig));
+  const entitySchemaGen = new EntitySchemaGenerator;
+  files.push(...entitySchemaGen.generate(ir, generatorConfig));
+  const entitySdkGen = new EntitySdkGenerator;
+  files.push(...entitySdkGen.generate(ir, generatorConfig));
+  const clientGen = new ClientGenerator;
+  files.push(...clientGen.generate(ir, generatorConfig));
   return files;
 }
 function generateSync(ir, config) {
@@ -1241,9 +802,6 @@ function generateSync(ir, config) {
     if (gen === "typescript") {
       generators.push("typescript");
       files.push(...runTypescriptGenerator(ir, config));
-    } else if (gen === "cli") {
-      generators.push("cli");
-      files.push(...runCLIGenerator(ir));
     }
   }
   return {
@@ -1253,6 +811,42 @@ function generateSync(ir, config) {
     generators
   };
 }
+async function mergeImportsToPackageJson(files, outputDir) {
+  const generatedPkg = files.find((f) => f.path === "package.json");
+  if (!generatedPkg)
+    return false;
+  const generated = JSON.parse(generatedPkg.content);
+  const imports = generated.imports;
+  if (!imports || Object.keys(imports).length === 0)
+    return false;
+  const projectRoot = await findProjectRoot(resolve3(outputDir));
+  if (!projectRoot)
+    return false;
+  const pkgPath = join3(projectRoot, "package.json");
+  const raw = await readFile3(pkgPath, "utf-8");
+  const pkg = JSON.parse(raw);
+  const existing = pkg.imports;
+  if (existing && JSON.stringify(existing) === JSON.stringify(imports)) {
+    return false;
+  }
+  pkg.imports = imports;
+  await writeFile3(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+  return true;
+}
+async function findProjectRoot(startDir) {
+  let dir = startDir;
+  const root = dirname3(dir);
+  while (dir !== root) {
+    try {
+      await readFile3(join3(dir, "package.json"), "utf-8");
+      return dir;
+    } catch {
+      dir = dirname3(dir);
+    }
+  }
+  return null;
+}
 async function generate(appIR, config) {
   const ir = adaptIR(appIR);
   const result = generateSync(ir, config);
@@ -1269,11 +863,16 @@ async function generate(appIR, config) {
     await mkdir3(config.outputDir, { recursive: true });
     for (const file of files) {
       const filePath = join3(config.outputDir, file.path);
+      const resolvedPath = resolve3(filePath);
+      if (!resolvedPath.startsWith(resolve3(config.outputDir))) {
+        throw new Error(`Generated file path "${file.path}" escapes output directory`);
+      }
       const dir = dirname3(filePath);
       await mkdir3(dir, { recursive: true });
       await writeFile3(filePath, file.content, "utf-8");
     }
   }
+  await mergeImportsToPackageJson(files, config.outputDir);
   return {
     files,
     ir,
@@ -1282,6 +881,106 @@ async function generate(appIR, config) {
     incremental: incrementalResult
   };
 }
+// src/json-schema-converter.ts
+var PRIMITIVE_MAP = {
+  string: "string",
+  number: "number",
+  integer: "number",
+  boolean: "boolean",
+  null: "null"
+};
+function jsonSchemaToTS(schema, ctx) {
+  const context = ctx ?? {
+    namedTypes: new Map,
+    resolving: new Set
+  };
+  const type = convert(schema, context);
+  return { type, extractedTypes: context.namedTypes };
+}
+function convert(schema, _ctx) {
+  if (schema.$defs && typeof schema.$defs === "object") {
+    const defs = schema.$defs;
+    for (const [name, defSchema] of Object.entries(defs)) {
+      if (!_ctx.namedTypes.has(name)) {
+        _ctx.resolving.add(name);
+        const typeStr = convert(defSchema, _ctx);
+        _ctx.resolving.delete(name);
+        _ctx.namedTypes.set(name, typeStr);
+      }
+    }
+  }
+  if (typeof schema.$ref === "string") {
+    if (!schema.$ref.startsWith("#")) {
+      throw new Error(`External $ref is not supported: ${schema.$ref}`);
+    }
+    return refToName(schema.$ref);
+  }
+  if (schema.const !== undefined) {
+    return toLiteral(schema.const);
+  }
+  if (Array.isArray(schema.enum)) {
+    return schema.enum.map((v) => toLiteral(v)).join(" | ");
+  }
+  if (Array.isArray(schema.oneOf)) {
+    return schema.oneOf.map((s) => convert(s, _ctx)).join(" | ");
+  }
+  if (Array.isArray(schema.anyOf)) {
+    return schema.anyOf.map((s) => convert(s, _ctx)).join(" | ");
+  }
+  if (Array.isArray(schema.allOf)) {
+    return schema.allOf.map((s) => convert(s, _ctx)).join(" & ");
+  }
+  if (Array.isArray(schema.type)) {
+    return schema.type.map((t) => PRIMITIVE_MAP[t] ?? t).join(" | ");
+  }
+  if (typeof schema.type === "string") {
+    const type = schema.type;
+    if (type === "array") {
+      if (Array.isArray(schema.prefixItems)) {
+        const items = schema.prefixItems.map((s) => convert(s, _ctx));
+        return `[${items.join(", ")}]`;
+      }
+      if (schema.items && typeof schema.items === "object") {
+        const itemType = convert(schema.items, _ctx);
+        return itemType.includes(" | ") ? `(${itemType})[]` : `${itemType}[]`;
+      }
+      return "unknown[]";
+    }
+    if (type === "object") {
+      if (schema.additionalProperties && typeof schema.additionalProperties === "object" && !schema.properties) {
+        const valueType = convert(schema.additionalProperties, _ctx);
+        return `Record<string, ${valueType}>`;
+      }
+      if (schema.properties && typeof schema.properties === "object") {
+        const props = schema.properties;
+        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+        const parts = [];
+        for (const [key, propSchema] of Object.entries(props)) {
+          const propType = convert(propSchema, _ctx);
+          const optional = required.has(key) ? "" : "?";
+          parts.push(`${key}${optional}: ${propType}`);
+        }
+        return `{ ${parts.join("; ")} }`;
+      }
+      return "Record<string, unknown>";
+    }
+    return PRIMITIVE_MAP[type] ?? "unknown";
+  }
+  return "unknown";
+}
+function refToName(ref) {
+  const segments = ref.split("/");
+  return segments[segments.length - 1] ?? "unknown";
+}
+function toLiteral(value) {
+  if (typeof value === "string")
+    return `'${value}'`;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value === null)
+    return "null";
+  return "unknown";
+}
 // src/pipeline.ts
 function createCodegenPipeline() {
   return {
@@ -1301,6 +1000,49 @@ function createCodegenPipeline() {
     }
   };
 }
+// src/utils/imports.ts
+function mergeImports(imports) {
+  const seen = new Map;
+  for (const imp of imports) {
+    const key = `${imp.from}::${imp.name}::${imp.isType}::${imp.alias ?? ""}`;
+    if (!seen.has(key)) {
+      seen.set(key, imp);
+    }
+  }
+  return [...seen.values()].sort((a, b) => {
+    const fromCmp = a.from.localeCompare(b.from);
+    if (fromCmp !== 0)
+      return fromCmp;
+    return a.name.localeCompare(b.name);
+  });
+}
+function renderImports(imports) {
+  const grouped = new Map;
+  for (const imp of imports) {
+    let group = grouped.get(imp.from);
+    if (!group) {
+      group = { types: [], values: [] };
+      grouped.set(imp.from, group);
+    }
+    const nameStr = imp.alias ? `${imp.name} as ${imp.alias}` : imp.name;
+    if (imp.isType) {
+      group.types.push(nameStr);
+    } else {
+      group.values.push(nameStr);
+    }
+  }
+  const lines = [];
+  for (const [from, group] of grouped) {
+    if (group.types.length > 0) {
+      lines.push(`import type { ${group.types.join(", ")} } from '${from}';`);
+    }
+    if (group.values.length > 0) {
+      lines.push(`import { ${group.values.join(", ")} } from '${from}';`);
+    }
+  }
+  return lines.join(`
+`);
+}
 export {
   writeIncremental,
   validateCodegenConfig,
@@ -1308,36 +1050,19 @@ export {
   toPascalCase,
   toKebabCase,
   toCamelCase,
-  scaffoldCLIRootIndex,
-  scaffoldCLIPackageJson,
   resolveCodegenConfig,
   renderImports,
+  mergeImportsToPackageJson,
   mergeImports,
   jsonSchemaToTS,
   hashContent,
   generate,
   formatWithBiome,
-  emitStreamingMethod,
-  emitStreamingEventType,
-  emitSharedTypesFile,
-  emitSchemaReExports,
-  emitSDKConfig,
-  emitRouteMapType,
-  emitPackageJson,
-  emitOperationResponseType,
-  emitOperationMethod,
-  emitOperationInputType,
-  emitModuleTypesFile,
-  emitModuleFile,
-  emitModuleCommands,
-  emitManifestFile,
-  emitInterfaceFromSchema,
-  emitCommandDefinition,
-  emitClientFile,
-  emitBinEntryPoint,
-  emitBarrelIndex,
-  emitAuthStrategyBuilder,
   defineCodegenConfig,
   createCodegenPipeline,
-  adaptIR
+  adaptIR,
+  EntityTypesGenerator,
+  EntitySdkGenerator,
+  EntitySchemaGenerator,
+  ClientGenerator
 };