@vertz/codegen 0.2.0

package/dist/index.js

@@ -0,0 +1,1343 @@
+// src/config.ts
+var VALID_GENERATORS = new Set(["typescript", "cli"]);
+function defineCodegenConfig(config) {
+  return config;
+}
+function resolveCodegenConfig(config) {
+  return {
+    generators: config?.generators ?? ["typescript"],
+    outputDir: config?.outputDir ?? ".vertz/generated",
+    format: config?.format,
+    incremental: config?.incremental,
+    typescript: config?.typescript,
+    cli: config?.cli
+  };
+}
+function validateCodegenConfig(config) {
+  const errors = [];
+  if (config.generators.length === 0) {
+    errors.push("codegen.generators must contain at least one generator");
+  }
+  for (const gen of config.generators) {
+    if (!VALID_GENERATORS.has(gen)) {
+      errors.push(`codegen.generators contains unknown generator: "${gen}"`);
+    }
+  }
+  if (config.typescript?.publishable) {
+    const pub = config.typescript.publishable;
+    if (!pub.name) {
+      errors.push("codegen.typescript.publishable.name is required");
+    }
+    if (!pub.outputDir) {
+      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
+import { execFile } from "node:child_process";
+import { accessSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = dirname(__filename2);
+var BIOME_CONFIG = JSON.stringify({
+  $schema: "https://biomejs.dev/schemas/2.0.0/schema.json",
+  formatter: {
+    enabled: true,
+    indentStyle: "space",
+    indentWidth: 2,
+    lineWidth: 100
+  },
+  javascript: {
+    formatter: {
+      quoteStyle: "single",
+      semicolons: "always",
+      trailingCommas: "all"
+    }
+  },
+  linter: {
+    enabled: false
+  },
+  vcs: {
+    enabled: false
+  }
+});
+function findBiomeBin() {
+  const candidates = [
+    resolve(__dirname2, "..", "..", "..", "node_modules", ".bin", "biome"),
+    resolve(__dirname2, "..", "node_modules", ".bin", "biome"),
+    resolve(process.cwd(), "node_modules", ".bin", "biome")
+  ];
+  for (const candidate of candidates) {
+    try {
+      accessSync(candidate);
+      return candidate;
+    } catch {}
+  }
+  return "biome";
+}
+function spawnAsync(cmd, args) {
+  return new Promise((resolve2) => {
+    execFile(cmd, args, { maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      resolve2({ stdout, stderr, exitCode: error ? 1 : 0 });
+    });
+  });
+}
+async function formatWithBiome(files) {
+  if (files.length === 0) {
+    return [];
+  }
+  const tempDir = join(tmpdir(), `vertz-codegen-format-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  try {
+    await mkdir(tempDir, { recursive: true });
+    await writeFile(join(tempDir, "biome.json"), BIOME_CONFIG, "utf-8");
+    for (const file of files) {
+      const filePath = join(tempDir, file.path);
+      const dir = dirname(filePath);
+      await mkdir(dir, { recursive: true });
+      await writeFile(filePath, file.content, "utf-8");
+    }
+    const biomeBin = findBiomeBin();
+    try {
+      await spawnAsync(biomeBin, ["format", "--write", `--config-path=${tempDir}`, tempDir]);
+    } catch {}
+    const formatted = [];
+    for (const file of files) {
+      const filePath = join(tempDir, file.path);
+      const content = await readFile(filePath, "utf-8");
+      formatted.push({ path: file.path, content });
+    }
+    return formatted;
+  } finally {
+    await rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+}
+// src/generate.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, join as join3 } from "node:path";
+
+// src/utils/naming.ts
+function splitWords(input) {
+  return input.replace(/([a-z])([A-Z])/g, "$1 $2").split(/[-_\s]+/).filter(Boolean);
+}
+function toPascalCase(input) {
+  return splitWords(input).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(input) {
+  const pascal = toPascalCase(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toKebabCase(input) {
+  return splitWords(input).map((w) => w.toLowerCase()).join("-");
+}
+function toSnakeCase(input) {
+  return splitWords(input).map((w) => w.toLowerCase()).join("_");
+}
+
+// src/generators/typescript/emit-cli.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)})`;
+    }
+    return "s.array(s.unknown())";
+  }
+  if (type === "object") {
+    const properties = schema.properties;
+    if (!properties || Object.keys(properties).length === 0) {
+      return "s.object({})";
+    }
+    const required = schema.required ?? [];
+    const fields = Object.entries(properties).map(([key, propSchema]) => {
+      const call = jsonSchemaToSchemaCall(propSchema);
+      if (required.includes(key)) {
+        return `  ${key}: ${call}`;
+      }
+      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"] = "*";
+  }
+  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);
+      }
+    }
+  }
+  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/generators/typescript/emit-types.ts
+var FILE_HEADER4 = `// 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: [] };
+}
+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}`);
+    }
+  }
+  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);
+    }
+  }
+  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);
+    }
+    const streamingFragment = emitStreamingEventType(op);
+    if (streamingFragment.content) {
+      sections.push(streamingFragment.content);
+    }
+  }
+  return {
+    path: `types/${module.name}.ts`,
+    content: sections.join(`
+
+`)
+  };
+}
+function emitSharedTypesFile(schemas) {
+  const sections = [FILE_HEADER4];
+  for (const schema of schemas) {
+    const fragment = emitInterfaceFromSchema(schema);
+    if (fragment.content) {
+      sections.push(fragment.content);
+    }
+  }
+  return {
+    path: "types/shared.ts",
+    content: sections.join(`
+
+`)
+  };
+}
+
+// src/generators/typescript/emit-routes.ts
+var FILE_HEADER5 = `// 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 bodyToTS(op) {
+  if (!op.body) {
+    return "never";
+  }
+  const ref = op.schemaRefs.body;
+  if (ref) {
+    return ref;
+  }
+  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;
+  }
+  const result = jsonSchemaToTS(op.headers);
+  return result.type;
+}
+function responseToTS(op) {
+  if (!op.response) {
+    return "void";
+  }
+  const ref = op.schemaRefs.response;
+  if (ref) {
+    return ref;
+  }
+  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(`
+`));
+  }
+  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";
+
+// src/hasher.ts
+import { createHash } from "node:crypto";
+function hashContent(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+
+// src/incremental.ts
+async function collectFiles(dir, baseDir) {
+  const results = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...await collectFiles(fullPath, baseDir));
+    } else if (entry.isFile()) {
+      results.push(relative(baseDir, fullPath));
+    }
+  }
+  return results;
+}
+async function writeIncremental(files, outputDir, options) {
+  const written = [];
+  const skipped = [];
+  const removed = [];
+  await mkdir2(outputDir, { recursive: true });
+  const generatedPaths = new Set(files.map((f) => f.path));
+  for (const file of files) {
+    const filePath = join2(outputDir, file.path);
+    const dir = dirname2(filePath);
+    await mkdir2(dir, { recursive: true });
+    let existingContent;
+    try {
+      existingContent = await readFile2(filePath, "utf-8");
+    } catch {}
+    if (existingContent !== undefined && hashContent(existingContent) === hashContent(file.content)) {
+      skipped.push(file.path);
+    } else {
+      await writeFile2(filePath, file.content, "utf-8");
+      written.push(file.path);
+    }
+  }
+  if (options?.clean) {
+    const existingFiles = await collectFiles(outputDir, outputDir);
+    for (const existing of existingFiles) {
+      if (!generatedPaths.has(existing)) {
+        await rm2(join2(outputDir, existing), { force: true });
+        removed.push(existing);
+      }
+    }
+  }
+  return { written, skipped, removed };
+}
+
+// src/ir-adapter.ts
+function adaptIR(appIR) {
+  const rawSchemas = appIR.schemas.filter((s) => s.isNamed && s.jsonSchema);
+  const nameCount = new Map;
+  for (const s of rawSchemas) {
+    nameCount.set(s.name, (nameCount.get(s.name) ?? 0) + 1);
+  }
+  const renameMap = new Map;
+  const schemas = rawSchemas.map((s) => {
+    const isCollision = (nameCount.get(s.name) ?? 0) > 1;
+    const resolvedName = isCollision ? `${toPascalCase(s.moduleName)}${s.name}` : s.name;
+    renameMap.set(`${s.moduleName}:${s.name}`, resolvedName);
+    return {
+      name: resolvedName,
+      jsonSchema: s.jsonSchema,
+      annotations: {
+        namingParts: {
+          operation: s.namingConvention.operation,
+          entity: s.namingConvention.entity,
+          part: s.namingConvention.part
+        }
+      }
+    };
+  });
+  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, ...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));
+  return {
+    basePath: appIR.app.basePath,
+    version: appIR.app.version,
+    modules: sortedModules,
+    schemas: allSchemas,
+    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) {
+  const files = [];
+  files.push(emitManifestFile(ir));
+  return files;
+}
+function generateSync(ir, config) {
+  const files = [];
+  const generators = [];
+  for (const gen of config.generators) {
+    if (gen === "typescript") {
+      generators.push("typescript");
+      files.push(...runTypescriptGenerator(ir, config));
+    } else if (gen === "cli") {
+      generators.push("cli");
+      files.push(...runCLIGenerator(ir));
+    }
+  }
+  return {
+    files,
+    ir,
+    fileCount: files.length,
+    generators
+  };
+}
+async function generate(appIR, config) {
+  const ir = adaptIR(appIR);
+  const result = generateSync(ir, config);
+  let { files } = result;
+  const shouldFormat = config.format !== false;
+  if (shouldFormat) {
+    files = await formatWithBiome(files);
+  }
+  const useIncremental = config.incremental !== false;
+  let incrementalResult;
+  if (useIncremental) {
+    incrementalResult = await writeIncremental(files, config.outputDir);
+  } else {
+    await mkdir3(config.outputDir, { recursive: true });
+    for (const file of files) {
+      const filePath = join3(config.outputDir, file.path);
+      const dir = dirname3(filePath);
+      await mkdir3(dir, { recursive: true });
+      await writeFile3(filePath, file.content, "utf-8");
+    }
+  }
+  return {
+    files,
+    ir,
+    fileCount: files.length,
+    generators: result.generators,
+    incremental: incrementalResult
+  };
+}
+// src/pipeline.ts
+function createCodegenPipeline() {
+  return {
+    validate(config) {
+      return validateCodegenConfig(config);
+    },
+    generate(ir, config) {
+      const resolved = resolveCodegenConfig(config);
+      return generateSync(ir, resolved);
+    },
+    resolveOutputDir(config) {
+      const resolved = resolveCodegenConfig(config);
+      return resolved.outputDir;
+    },
+    resolveConfig(config) {
+      return resolveCodegenConfig(config);
+    }
+  };
+}
+export {
+  writeIncremental,
+  validateCodegenConfig,
+  toSnakeCase,
+  toPascalCase,
+  toKebabCase,
+  toCamelCase,
+  scaffoldCLIRootIndex,
+  scaffoldCLIPackageJson,
+  resolveCodegenConfig,
+  renderImports,
+  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
+};