@drzl/cli 4.14.4 → 4.16.0

package/dist/cli.cjs

@@ -31,12 +31,525 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../generator-json-schema/dist/index.js
+// ../generator-trpc/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  BASE_MODULE: () => BASE_MODULE,
+  TRPCGenerator: () => TRPCGenerator,
+  TRPC_MAJOR: () => TRPC_MAJOR,
+  default: () => index_default
+});
+function isWide(column) {
+  if (column.enumValues && column.enumValues.length) return false;
+  if (column.shape?.kind === "tuple" || column.shape?.kind === "numberObject") return false;
+  return !["number", "string", "boolean", "Date"].includes(column.tsType);
+}
+function mapExpr(column, lib, mode) {
+  const d = LIBS[lib];
+  let base = (() => {
+    if (column.enumValues && column.enumValues.length) return d.enum(column.enumValues);
+    if (column.shape?.kind === "tuple" && d.tuple) return d.tuple(column.shape.length);
+    if (column.shape?.kind === "numberObject" && d.numberObject) {
+      return d.numberObject(column.shape.fields);
+    }
+    switch (column.tsType) {
+      case "number":
+        return d.number;
+      case "string":
+        return d.string;
+      case "boolean":
+        return d.boolean;
+      case "Date":
+        return d.date;
+      default:
+        return d.unknown;
+    }
+  })();
+  if (column.nullable) base = d.nullable(base);
+  if (mode !== "select") {
+    const optional = mode === "update" || column.nullable || column.hasDefault;
+    if (optional) base = d.optional(base);
+  }
+  return base;
+}
+function field(column, lib, mode) {
+  const d = LIBS[lib];
+  const expr = mapExpr(column, lib, mode);
+  return `${objectKey(column.name)}: ${d.fieldIsString ? JSON.stringify(expr) : expr}`;
+}
+function objectKey(name) {
+  return isIdent(name) ? name : JSON.stringify(name);
+}
+function renderSchema(table, lib, mode) {
+  const d = LIBS[lib];
+  const cols = table.columns.filter((c) => mode === "select" ? true : !c.isGenerated);
+  const body = cols.map((c) => `  ${field(c, lib, mode)},`).join("\n");
+  const schema = d.object(body);
+  return mode === "update" && d.partialUpdate ? d.partialUpdate(schema) : schema;
+}
+function toCase(s, c) {
+  if (!c) return s;
+  const parts = s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").split(/\s+/);
+  if (c === "camel") {
+    return parts.map(
+      (p, i) => i === 0 ? p.toLowerCase() : p.charAt(0).toUpperCase() + p.slice(1).toLowerCase()
+    ).join("");
+  }
+  if (c === "kebab") return parts.map((p) => p.toLowerCase()).join("-");
+  if (c === "snake") return parts.map((p) => p.toLowerCase()).join("_");
+  return s;
+}
+function keyColumns(table) {
+  const names = table.primaryKey?.columns ?? [];
+  if (!names.length) return null;
+  const cols = names.map((n) => table.columns.find((c) => c.name === n));
+  if (cols.some((c) => !c)) return null;
+  return cols;
+}
+function renderBase(opts) {
+  const injection = opts.databaseInjection?.enabled === true;
+  const dbType = opts.databaseInjection?.databaseType ?? "unknown";
+  const typeImport = opts.databaseInjection?.databaseTypeImport ? `import type { ${opts.databaseInjection.databaseTypeImport.name} } from '${opts.databaseInjection.databaseTypeImport.from}';
+` : "";
+  const trpcImport = injection ? `import { initTRPC, TRPCError } from '@trpc/server';` : `import { initTRPC } from '@trpc/server';`;
+  const context = injection ? `/**
+ * What your \`createContext\` hands every procedure.
+ *
+ * \`db\` is optional here and required by \`dbProcedure\` below. That split is what lets an adapter
+ * build a context without a handle, for a health check or a public route, while every generated
+ * procedure still sees one that is present.
+ */
+export interface Context {
+  db?: ${dbType};
+}` : `/**
+ * What your \`createContext\` hands every procedure. Nothing generated reads it, so it is left
+ * open; narrow it to the shape your own context really has.
+ */
+export type Context = Record<string, unknown>;`;
+  const middleware = injection ? `
+/**
+ * The builder every generated procedure is built from: it refuses to run without a database
+ * handle, and narrows \`ctx.db\` from optional to present for everything downstream.
+ */
+export const dbProcedure = t.procedure.use(async ({ ctx, next }) => {
+  if (!ctx.db) {
+    throw new TRPCError({
+      code: 'INTERNAL_SERVER_ERROR',
+      message: 'No database handle on the tRPC context. Provide one from createContext.',
+    });
+  }
+  return next({ ctx: { db: ctx.db } });
+});
+` : "";
+  return `// Generated by @drzl/generator-trpc
+// The shared tRPC base. Every generated router imports from here.
+${trpcImport}
+${typeImport}
+${context}
+
+const t = initTRPC.context<Context>().create();
+
+export const router = t.router;
+export const mergeRouters = t.mergeRouters;
+export const middleware = t.middleware;
+/** Needed to call this router in-process, from a test or from SSR. */
+export const createCallerFactory = t.createCallerFactory;
+export const publicProcedure = t.procedure;
+${middleware}`;
+}
+function renderRouter(table, opts, ctx) {
+  const lib = opts.validation?.library ?? "zod";
+  const d = LIBS[lib];
+  const service = opts.template === "service";
+  const injection = opts.databaseInjection?.enabled === true;
+  const builder = injection ? "dbProcedure" : "publicProcedure";
+  const insertName = `Insert${table.tsName}Schema`;
+  const updateName = `Update${table.tsName}Schema`;
+  const selectName = `Select${table.tsName}Schema`;
+  const writable = !table.readOnly;
+  const key = keyColumns(table);
+  const Service = `${cap(singularize(table.tsName))}Service`;
+  const serviceKeyable = !!key && key.length === 1 && key[0].tsType === "number";
+  const keyArg = key && key.length === 1 ? `input.${key[0].name}` : "";
+  const dbArg = injection ? "ctx.db, " : "";
+  const wiredParams = injection ? "{ ctx, input }" : "{ input }";
+  const procedures = [];
+  const notImplemented = (what) => `throw new Error('Not implemented: ${what} ${table.tsName}.');`;
+  procedures.push({
+    name: "list",
+    kind: "query",
+    output: d.arrayOf(selectName),
+    params: service && injection ? "{ ctx }" : "",
+    body: service ? [`return await ${Service}.getAll(${injection ? "ctx.db" : ""});`] : ["return [];"]
+  });
+  const keyInput = key ? d.objectInline(key.map((c) => field(c, lib, "select")).join(", ")) : void 0;
+  if (key && keyInput) {
+    const wired = service && serviceKeyable;
+    procedures.push({
+      name: "byId",
+      kind: "query",
+      input: keyInput,
+      output: d.nullableOf(selectName),
+      params: wired ? wiredParams : "{ input: _input }",
+      body: wired ? [`return await ${Service}.getById(${dbArg}${keyArg});`] : service ? [serviceKeyNote(table), notImplemented("byId")] : ["return null;"]
+    });
+    if (writable) {
+      const updateInput = d.objectInline(
+        [...key.map((c) => field(c, lib, "select")), `data: ${updateName}`].join(", ")
+      );
+      procedures.push({
+        name: "update",
+        kind: "mutation",
+        input: updateInput,
+        output: selectName,
+        params: wired ? wiredParams : "{ input: _input }",
+        body: wired ? [`return await ${Service}.update(${dbArg}${keyArg}, input.data);`] : service ? [serviceKeyNote(table), notImplemented("update")] : [notImplemented("update")]
+      });
+      procedures.push({
+        name: "delete",
+        kind: "mutation",
+        input: keyInput,
+        output: d.booleanSchema,
+        params: wired ? wiredParams : "{ input: _input }",
+        body: wired ? [`return await ${Service}.delete(${dbArg}${keyArg});`] : service ? [serviceKeyNote(table), notImplemented("delete")] : ["return true;"]
+      });
+    }
+  }
+  if (writable) {
+    procedures.push({
+      name: "create",
+      kind: "mutation",
+      input: insertName,
+      output: selectName,
+      params: service ? wiredParams : "{ input: _input }",
+      body: service ? [`return await ${Service}.create(${dbArg}input);`] : [notImplemented("create")]
+    });
+  }
+  if (opts.includeRelations) {
+    const taken = new Set(procedures.map((p) => p.name));
+    procedures.push(...relationProcedures(table, lib, selectName, taken, service));
+  }
+  const order = ["list", "byId", "create", "update", "delete"];
+  const rank = (n) => order.indexOf(n) === -1 ? order.length : order.indexOf(n);
+  procedures.sort((a, b) => rank(a.name) - rank(b.name));
+  const routerName = routerExportName(table, opts.naming);
+  const entries = procedures.map((p) => {
+    const rawKey = toCase(p.name, opts.naming?.procedureCase);
+    const propKey = isIdent(rawKey) ? rawKey : JSON.stringify(rawKey);
+    return [
+      `  ${propKey}: ${builder}`,
+      ...p.input ? [`    .input(${p.input})`] : [],
+      `    .output(${p.output})`,
+      `    .${p.kind}(async (${p.params}) => {`,
+      ...p.body.map((line) => `      ${line}`),
+      `    }),`
+    ].join("\n");
+  }).join("\n");
+  const body = `export const ${routerName} = router({
+${entries}
+});
+`;
+  const useShared = !!opts.validation?.useShared && !!opts.validation?.importPath;
+  const declared = [];
+  if (!useShared) {
+    if (writable) {
+      declared.push(`export const ${insertName} = ${renderSchema(table, lib, "insert")};`);
+      declared.push(`export const ${updateName} = ${renderSchema(table, lib, "update")};`);
+    }
+    declared.push(`export const ${selectName} = ${renderSchema(table, lib, "select")};`);
+  }
+  const decided = [...declared, body].join("\n\n");
+  const imports = [];
+  if (useShared) {
+    const sharedAffix = (0, import_validation_core2.resolveAffix)({
+      affix: opts.validation?.affix,
+      schemaSuffix: opts.validation?.schemaSuffix
+    });
+    const wanted = [
+      ["insert", insertName],
+      ["update", updateName],
+      ["select", selectName]
+    ].filter(([, local]) => decided.includes(local));
+    if (wanted.length) {
+      const spec = (0, import_validation_core2.resolveConfiguredImport)(
+        opts.validation.importPath,
+        ctx.out,
+        process.cwd(),
+        opts.importExtension
+      );
+      const names = wanted.map(([mode, local]) => {
+        const exported = (0, import_validation_core2.schemaName)(mode, table.tsName, sharedAffix);
+        return exported === local ? local : `${exported} as ${local}`;
+      }).join(", ");
+      imports.push(`import { ${names} } from '${spec}';`);
+    }
+  }
+  imports.push(
+    `import { ${[builder, "router"].sort().join(", ")} } from '${(0, import_validation_core2.importSpecifier)(
+      `./${BASE_MODULE}.ts`,
+      opts.importExtension
+    )}';`
+  );
+  if (service) {
+    imports.push(`import { ${Service} } from '${serviceImportSpecifier(table, ctx, opts)}';`);
+  }
+  if (LIB_USAGE[lib].test(decided)) imports.unshift(LIB_IMPORTS[lib]);
+  const wide = table.columns.filter(isWide).map((c) => c.name);
+  const wideNote = wide.length ? `// No validated type for ${wide.length === 1 ? "this column" : "these columns"}: ${wide.join(", ")}.
+// DRZL could not derive one from the schema, so the router accepts any value there.
+` : "";
+  return `// Generated by @drzl/generator-trpc
+// Router for table: ${table.name}
+${wideNote}${imports.join("\n")}
+
+${decided}`;
+}
+function relationProcedures(table, lib, selectSchemaName, taken, service) {
+  const d = LIBS[lib];
+  const out = [];
+  for (const fk of table.foreignKeys ?? []) {
+    if (fk.columns.length !== 1) continue;
+    const colName = fk.columns[0];
+    const column = table.columns.find((c) => c.name === colName);
+    if (!column) continue;
+    const name = `listBy${cap(colName)}`;
+    if (taken.has(name)) continue;
+    taken.add(name);
+    out.push({
+      name,
+      kind: "query",
+      input: d.objectInline(field(column, lib, "select")),
+      output: d.arrayOf(selectSchemaName),
+      params: "{ input: _input }",
+      body: [
+        `// Rows of ${table.name} whose ${JSON.stringify(colName)} matches _input.${colName}.`,
+        // In `service` mode every other procedure really does reach the database, so a lookup
+        // quietly answering with an empty array would read as "no matching rows". There is no
+        // generated service method for it, so it says so instead. In `standard` mode everything
+        // is a stub and `[]` is consistent with `list`.
+        service ? `throw new Error('Not implemented: ${name} ${table.tsName}.');` : "return [];"
+      ]
+    });
+  }
+  return out;
+}
+function renderBarrel(routers, ctx, path6, opts) {
+  const baseSpec = (0, import_validation_core2.importSpecifier)(`./${BASE_MODULE}.ts`, opts.importExtension);
+  const reExports = `export { createCallerFactory, publicProcedure, router } from '${baseSpec}';
+` + (opts.databaseInjection?.enabled === true ? `export { dbProcedure } from '${baseSpec}';
+` : "") + `export type { Context } from '${baseSpec}';
+`;
+  if (!routers.length) {
+    return `// Generated by @drzl/generator-trpc
+// No tables detected in analysis. Add tables to your schema and regenerate.
+import { router } from '${baseSpec}';
+
+export const appRouter = router({});
+
+/** The type a tRPC client is parameterised by: \`createTRPCClient<AppRouter>()\`. */
+export type AppRouter = typeof appRouter;
+
+${reExports}`;
+  }
+  const entries = routers.map(({ filePath, exportName, table }) => ({
+    rel: (0, import_validation_core2.importSpecifier)(
+      "./" + path6.relative(ctx.out, filePath).replace(/\\/g, "/"),
+      opts.importExtension
+    ),
+    exportName,
+    // The namespace a client reaches this table's procedures through: `trpc.userProfiles.list`.
+    // `tsName` verbatim, because it is already a valid identifier and it is the name the user
+    // wrote in their schema. The oRPC barrel lowercases this key, turning `userProfiles` into
+    // `userprofiles`: harmless in an object literal nobody reads, and not harmless when the key
+    // is the public API of a typed client.
+    key: table.tsName
+  }));
+  const importLines = entries.map(({ rel, exportName }) => `import { ${exportName} } from '${rel}';`).join("\n");
+  const bodyLines = entries.map(({ key, exportName }) => `  ${isIdent(key) ? key : JSON.stringify(key)}: ${exportName},`).join("\n");
+  return `// Generated by @drzl/generator-trpc
+import { router } from '${baseSpec}';
+${importLines}
+
+export const appRouter = router({
+${bodyLines}
+});
+
+/** The type a tRPC client is parameterised by: \`createTRPCClient<AppRouter>()\`. */
+export type AppRouter = typeof appRouter;
+
+${reExports}`;
+}
+function serviceKeyNote(table) {
+  const cols = table.primaryKey?.columns ?? [];
+  const shape = cols.length > 1 ? `has a composite primary key (${cols.join(", ")})` : `has a non-numeric primary key (${cols[0]})`;
+  return `// ${table.name} ${shape}, and @drzl/generator-service types its key parameter as one number.
+// Wire this to your own lookup.`;
+}
+function routerExportName(table, naming) {
+  const base = `${table.tsName}${naming?.routerSuffix ?? "Router"}`;
+  const c = naming?.procedureCase;
+  return toCase(base, c === "kebab" ? "camel" : c);
+}
+function serviceImportSpecifier(table, ctx, opts) {
+  const rel = relativePosix(ctx.out, ctx.services);
+  const dir = !rel ? "." : rel.startsWith(".") ? rel : `./${rel}`;
+  return (0, import_validation_core2.importSpecifier)(`${dir}/${singularize(table.tsName)}Service.ts`, opts.importExtension);
+}
+function relativePosix(from, to) {
+  const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
+  const a = norm(from).split("/");
+  const b = norm(to).split("/");
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return [...Array.from({ length: a.length - i }, () => ".."), ...b.slice(i)].join("/");
+}
+function buildHeader(h) {
+  if (h && h.enabled === false) return "";
+  const text = h?.text?.trim();
+  const lines = text ? text.split(/\r?\n/).map((l) => `// ${l}`) : [
+    "// Generated by DRZL (@drzl/*)",
+    "// Generated output is granted to you under your project's license.",
+    "// You may use, copy, modify, and distribute without attribution."
+  ];
+  return lines.join("\n") + "\n\n";
+}
+var import_validation_core2, TRPC_MAJOR, q, LIB_IMPORTS, LIB_USAGE, LIBS, cap, singularize, isIdent, BASE_MODULE, TRPCGenerator, index_default;
+var init_dist = __esm({
+  "../generator-trpc/dist/index.js"() {
+    "use strict";
+    import_validation_core2 = require("@drzl/validation-core");
+    TRPC_MAJOR = 11;
+    q = (v) => JSON.stringify(v);
+    LIB_IMPORTS = {
+      zod: "import { z } from 'zod';",
+      valibot: "import * as v from 'valibot';",
+      arktype: "import { type } from 'arktype';"
+    };
+    LIB_USAGE = {
+      zod: /\bz\./,
+      valibot: /\bv\./,
+      arktype: /\btype\(/
+    };
+    LIBS = {
+      zod: {
+        number: "z.number()",
+        string: "z.string()",
+        boolean: "z.boolean()",
+        date: "z.date()",
+        unknown: "z.unknown()",
+        tuple: (n) => `z.tuple([${Array.from({ length: n }, () => "z.number()").join(", ")}])`,
+        numberObject: (fields) => `z.object({ ${fields.map((f) => `${f}: z.number()`).join(", ")} })`,
+        enum: (vals) => `z.enum([${vals.map(q).join(", ")}] as const)`,
+        nullable: (b) => `${b}.nullable()`,
+        optional: (b) => `${b}.optional()`,
+        object: (body) => `z.object({
+${body}
+})`,
+        objectInline: (body) => `z.object({ ${body} })`,
+        partialUpdate: (s) => `${s}.partial()`,
+        arrayOf: (s) => `z.array(${s})`,
+        nullableOf: (s) => `${s}.nullable()`,
+        booleanSchema: "z.boolean()"
+      },
+      valibot: {
+        number: "v.number()",
+        string: "v.string()",
+        boolean: "v.boolean()",
+        date: "v.date()",
+        unknown: "v.unknown()",
+        tuple: (n) => `v.tuple([${Array.from({ length: n }, () => "v.number()").join(", ")}])`,
+        numberObject: (fields) => `v.object({ ${fields.map((f) => `${f}: v.number()`).join(", ")} })`,
+        enum: (vals) => `v.picklist([${vals.map(q).join(", ")}] as const)`,
+        nullable: (b) => `v.nullable(${b})`,
+        optional: (b) => `v.optional(${b})`,
+        object: (body) => `v.object({
+${body}
+})`,
+        objectInline: (body) => `v.object({ ${body} })`,
+        arrayOf: (s) => `v.array(${s})`,
+        nullableOf: (s) => `v.nullable(${s})`,
+        booleanSchema: "v.boolean()"
+      },
+      arktype: {
+        number: "number",
+        string: "string",
+        boolean: "boolean",
+        date: "Date",
+        unknown: "unknown",
+        // The surrounding encode adds the quotes, so the union is built with the inner quoting
+        // ArkType expects. Emitting `'${...}'` here produces `''admin' | 'user''`, which does not parse.
+        enum: (vals) => vals.map((x) => `'${x.replace(/'/g, "\\'")}'`).join(" | "),
+        nullable: (b) => `(${b} | null)`,
+        optional: (b) => `${b}?`,
+        object: (body) => `type({
+${body}
+})`,
+        objectInline: (body) => `type({ ${body} })`,
+        fieldIsString: true,
+        arrayOf: (s) => `${s}.array()`,
+        nullableOf: (s) => `${s}.or('null')`,
+        booleanSchema: `type('boolean')`
+      }
+    };
+    cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+    singularize = (s) => s.endsWith("ies") ? s.slice(0, -3) + "y" : s.endsWith("s") ? s.slice(0, -1) : s;
+    isIdent = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
+    BASE_MODULE = "trpc";
+    TRPCGenerator = class {
+      constructor(analysis) {
+        this.analysis = analysis;
+      }
+      async generate(opts) {
+        const fs3 = await import("fs/promises");
+        const path6 = await import("path");
+        const out = path6.resolve(process.cwd(), opts.outputDir);
+        const ctx = {
+          out,
+          services: path6.resolve(process.cwd(), opts.servicesDir ?? "src/services")
+        };
+        await fs3.mkdir(out, { recursive: true });
+        const files = [];
+        const write = async (filePath, content) => {
+          const formatted = await (0, import_validation_core2.formatCode)(
+            buildHeader(opts.outputHeader) + content,
+            filePath,
+            opts.format
+          );
+          await fs3.writeFile(filePath, formatted, "utf8");
+          files.push(filePath);
+        };
+        const basePath = path6.join(out, `${BASE_MODULE}.ts`);
+        await write(basePath, renderBase(opts));
+        const routers = [];
+        const total = this.analysis.tables.length;
+        let index = 0;
+        for (const table of this.analysis.tables) {
+          const base = `${table.tsName}${opts.naming?.routerSuffix ?? ""}`;
+          const filePath = path6.join(out, `${toCase(base, opts.naming?.procedureCase)}.ts`);
+          if (filePath === basePath) {
+            throw new Error(
+              `@drzl/generator-trpc: the router for table "${table.name}" would be written to ${filePath}, which is the shared tRPC base module this generator also writes. Set naming.routerSuffix to move it out of the way.`
+            );
+          }
+          await write(filePath, renderRouter(table, opts, ctx));
+          routers.push({ table, filePath, exportName: routerExportName(table, opts.naming) });
+          index++;
+          opts.onProgress?.({ index, total, table: table.name, filePath });
+        }
+        await write(path6.join(out, "index.ts"), renderBarrel(routers, ctx, path6, opts));
+        return { files };
+      }
+    };
+    index_default = TRPCGenerator;
+  }
+});
+
+// ../generator-json-schema/dist/index.js
+var dist_exports2 = {};
+__export(dist_exports2, {
   JsonSchemaGenerator: () => JsonSchemaGenerator,
   componentsDocument: () => componentsDocument,
-  default: () => index_default,
+  default: () => index_default2,
   tableSchemas: () => tableSchemas
 });
 function baseSchema(c, mode, target, checks, sets, lengths) {
@@ -88,14 +601,14 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
     case "string": {
       const out = { type: "string" };
       if (c.format === "uuid") out.format = UUID_FORMAT;
-      else if (c.format && import_validation_core2.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core2.COLUMN_FORMATS[c.format];
+      else if (c.format && import_validation_core3.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core3.COLUMN_FORMATS[c.format];
       if (c.maxLength !== void 0) out.maxLength = c.maxLength;
       applyByteCap(out, c);
       applyLengths(out, c, lengths);
       return out;
     }
     case "number": {
-      const out = { type: (0, import_validation_core2.isIntegerColumn)(c) ? "integer" : "number" };
+      const out = { type: (0, import_validation_core3.isIntegerColumn)(c) ? "integer" : "number" };
       if (!c.arrayDimensions) applyNumericBounds(out, c, checks, target);
       return out;
     }
@@ -232,7 +745,7 @@ function tableSchema(table, cols, mode, target, applyDefaults, parsed) {
   };
 }
 function collect(table) {
-  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core2.parseCheck)(k.expression, k.name));
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core3.parseCheck)(k.expression, k.name));
   return {
     checks: parsed.flatMap((p) => p.ok ? p.checks : []),
     sets: parsed.flatMap((p) => p.ok ? p.sets ?? [] : []),
@@ -246,9 +759,9 @@ function tableSchemas(table, opts = {}) {
   const parsed = collect(table);
   const build = (cols, mode) => tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed);
   return {
-    insert: build((0, import_validation_core2.insertColumns)(table), "insert"),
-    update: build((0, import_validation_core2.updateColumns)(table), "update"),
-    select: build((0, import_validation_core2.selectColumns)(table), "select")
+    insert: build((0, import_validation_core3.insertColumns)(table), "insert"),
+    update: build((0, import_validation_core3.updateColumns)(table), "update"),
+    select: build((0, import_validation_core3.selectColumns)(table), "select")
   };
 }
 function componentsDocument(tables, opts = {}) {
@@ -266,23 +779,23 @@ function componentsDocument(tables, opts = {}) {
 function renderTableModule(table, affix, target, applyDefaults) {
   const T = table.tsName;
   const schemas = tableSchemas(table, { target, applyDefaults });
-  const decl = (mode) => `export const ${(0, import_validation_core2.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
+  const decl = (mode) => `export const ${(0, import_validation_core3.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
 
-export type ${(0, import_validation_core2.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core2.schemaName)(mode, T, affix)};`;
+export type ${(0, import_validation_core3.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core3.schemaName)(mode, T, affix)};`;
   return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
 }
-function buildHeader(h) {
+function buildHeader2(h) {
   if (h?.enabled === false) return "";
   const text = h?.text ?? "// Generated by DRZL. Do not edit by hand.";
   return `${text}
 
 `;
 }
-var import_validation_core2, DEFAULT_FILE_SUFFIX, DRAFT, UUID_FORMAT, JsonSchemaGenerator, index_default;
-var init_dist = __esm({
+var import_validation_core3, DEFAULT_FILE_SUFFIX, DRAFT, UUID_FORMAT, JsonSchemaGenerator, index_default2;
+var init_dist2 = __esm({
   "../generator-json-schema/dist/index.js"() {
     "use strict";
-    import_validation_core2 = require("@drzl/validation-core");
+    import_validation_core3 = require("@drzl/validation-core");
     DEFAULT_FILE_SUFFIX = ".schema.ts";
     DRAFT = "https://json-schema.org/draft/2020-12/schema";
     UUID_FORMAT = "uuid";
@@ -297,14 +810,14 @@ var init_dist = __esm({
         const out = path6.resolve(process.cwd(), opts.outDir);
         const files = [];
         await fs3.mkdir(out, { recursive: true });
-        const affix = (0, import_validation_core2.resolveAffix)(opts);
+        const affix = (0, import_validation_core3.resolveAffix)(opts);
         const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
         const target = opts.target ?? "draft-2020-12";
         for (const table of this.analysis.tables) {
-          const filePath = path6.join(out, (0, import_validation_core2.moduleFileName)(table.tsName, fileSuffix));
+          const filePath = path6.join(out, (0, import_validation_core3.moduleFileName)(table.tsName, fileSuffix));
           const code = renderTableModule(table, affix, target, !!opts.applyDefaults);
-          const formatted = await (0, import_validation_core2.formatCode)(
-            buildHeader(opts.outputHeader) + code,
+          const formatted = await (0, import_validation_core3.formatCode)(
+            buildHeader2(opts.outputHeader) + code,
             filePath,
             opts.format
           );
@@ -321,17 +834,17 @@ var init_dist = __esm({
 `;
           await fs3.writeFile(
             componentsPath,
-            await (0, import_validation_core2.formatCode)(buildHeader(opts.outputHeader) + code, componentsPath, opts.format),
+            await (0, import_validation_core3.formatCode)(buildHeader2(opts.outputHeader) + code, componentsPath, opts.format),
             "utf8"
           );
           files.push(componentsPath);
         }
         const indexPath = path6.join(out, "index.ts");
-        const index = this.analysis.tables.map((t) => `export * from '${(0, import_validation_core2.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`).concat(
+        const index = this.analysis.tables.map((t) => `export * from '${(0, import_validation_core3.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`).concat(
           opts.components ? [`export * from './components${opts.importExtension === "none" ? "" : ".js"}';`] : []
         ).join("\n") + "\n";
-        const indexFormatted = await (0, import_validation_core2.formatCode)(
-          buildHeader(opts.outputHeader) + index,
+        const indexFormatted = await (0, import_validation_core3.formatCode)(
+          buildHeader2(opts.outputHeader) + index,
           indexPath,
           opts.format
         );
@@ -342,13 +855,13 @@ var init_dist = __esm({
       renderTable(table, opts) {
         return renderTableModule(
           table,
-          (0, import_validation_core2.resolveAffix)(opts),
+          (0, import_validation_core3.resolveAffix)(opts),
           opts?.target ?? "draft-2020-12",
           !!opts?.applyDefaults
         );
       }
     };
-    index_default = JsonSchemaGenerator;
+    index_default2 = JsonSchemaGenerator;
   }
 });
 
@@ -362,30 +875,6 @@ var import_commander = require("commander");
 var path5 = __toESM(require("path"), 1);
 var import_ora = __toESM(require("ora"), 1);
 
-// src/validation-options.ts
-function validationOptions(g, cfg, outDir, caps = {}) {
-  return {
-    outDir,
-    outputHeader: g.outputHeader,
-    format: g.format,
-    schemaSuffix: g.schemaSuffix,
-    fileSuffix: g.fileSuffix,
-    importExtension: g.importExtension,
-    affix: g.affix,
-    coerceDates: g.coerceDates,
-    applyDefaults: g.applyDefaults,
-    duplicateFinder: g.duplicateFinder,
-    // Only where the generator can act on them, so an unsupported option is absent rather than
-    // present and ignored.
-    ...caps.schemaTypes ? {
-      // Needed by both: the reference is resolved relative to the emitted file.
-      schemaPath: cfg.schema,
-      typedJson: g.typedJson,
-      typedColumns: g.typedColumns
-    } : {}
-  };
-}
-
 // src/config.ts
 var import_validation_core = require("@drzl/validation-core");
 var fs = __toESM(require("fs"), 1);
@@ -425,7 +914,7 @@ var AffixSchema = import_zod.z.object({
 }).strict();
 var ImportExtensionSchema = import_zod.z.enum(import_validation_core.IMPORT_EXTENSIONS);
 var GeneratorSchema = import_zod.z.object({
-  kind: import_zod.z.enum(["orpc", "service", "zod", "valibot", "arktype", "typebox", "json-schema"]),
+  kind: import_zod.z.enum(["orpc", "trpc", "service", "zod", "valibot", "arktype", "typebox", "json-schema"]),
   /**
    * Overrides the top-level `importExtension` for this generator alone, for a project whose
    * generated directories are compiled by different tsconfigs.
@@ -461,6 +950,22 @@ var GeneratorSchema = import_zod.z.object({
    * fact about the table rather than the row. This checks the half that needs no database.
    */
   duplicateFinder: import_zod.z.boolean().optional(),
+  /**
+   * Emit `NestedInsert<Table>` and `NestedSelect<Table>` beside the flat schemas: the table plus
+   * one key per relation, so `{ ...user, posts: [...] }` can be validated whole.
+   *
+   * Nothing in the Drizzle validator ecosystem describes that payload, and `db.insert` drops the
+   * relation key silently rather than refusing it, so the children are never written and nothing
+   * says so.
+   */
+  nestedSchemas: import_zod.z.boolean().optional(),
+  /**
+   * How many levels of children a nested schema describes. Defaults to 1, capped at 3.
+   *
+   * Nesting is expanded inline rather than by reference, so this multiplies the emitted size, and
+   * it is also what terminates a cycle: `users -> posts -> users` stops here.
+   */
+  nestedDepth: import_zod.z.number().int().optional(),
   naming: NamingSchema.optional(),
   outputHeader: import_zod.z.object({
     enabled: import_zod.z.boolean().default(true).optional(),
@@ -496,7 +1001,22 @@ var GeneratorSchema = import_zod.z.object({
    * Omitting it reproduces the output of every previous release exactly.
    */
   affix: AffixSchema.optional(),
-  // orpc validation sharing
+  /**
+   * How the router generators reach a database handle: through the request context, rather than
+   * through a module-level import in the service layer.
+   *
+   * Documented on the oRPC generator since it was added and, until now, absent from this schema
+   * entirely. `GeneratorSchema` is not strict, so zod stripped the key without a word and the
+   * option did nothing at all when set from a config file. It was only ever reachable by calling
+   * the generator's API directly.
+   */
+  databaseInjection: import_zod.z.object({
+    enabled: import_zod.z.boolean().optional(),
+    /** The type annotation for the injected handle, e.g. `DrizzleD1Database`. */
+    databaseType: import_zod.z.string().optional(),
+    databaseTypeImport: import_zod.z.object({ name: import_zod.z.string(), from: import_zod.z.string() }).optional()
+  }).optional(),
+  // router validation sharing (orpc, trpc)
   validation: import_zod.z.object({
     useShared: import_zod.z.boolean().default(false).optional(),
     library: import_zod.z.enum(["zod", "valibot", "arktype"]).default("zod").optional(),
@@ -568,6 +1088,10 @@ var ConfigSchema = import_zod.z.object({
     );
   });
 });
+var ROUTER_KINDS = /* @__PURE__ */ new Set(["orpc", "trpc"]);
+function trpcOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
 function sharedSchemaNames(opts) {
   const resolved = (0, import_validation_core.resolveAffix)(opts);
   return import_validation_core.NAME_MODES.map((mode) => (0, import_validation_core.schemaName)(mode, import_validation_core.AFFIX_PROBE_TABLE, resolved));
@@ -579,7 +1103,23 @@ function resolveConfig(cfg) {
     importExtension: g.importExtension ?? cfg.importExtension
   }));
   for (const g of generators) {
-    if (g.kind !== "orpc") continue;
+    if (!ROUTER_KINDS.has(g.kind)) continue;
+    if (g.databaseInjection?.enabled) {
+      for (const s of generators.filter((x) => x.kind === "service")) {
+        if (!s.databaseInjection) {
+          s.databaseInjection = g.databaseInjection;
+        } else if (!s.databaseInjection.enabled) {
+          warnings.push(
+            `drzl config: the "${g.kind}" generator sets databaseInjection.enabled while the "service" generator sets it to false. The router will call Service.method(ctx.db, ...) against services that take no database parameter, so the generated project will not compile. Set both, or neither.`
+          );
+        }
+        if ((s.dataAccess ?? "stub") === "stub") {
+          warnings.push(
+            `drzl config: the "${g.kind}" generator sets databaseInjection.enabled, so its handlers call Service.method(ctx.db, ...). The "service" generator emits stub bodies, which take no database parameter whatever this option says, so those calls will not compile. Set dataAccess: 'drizzle' on the "service" generator, or drop databaseInjection.`
+          );
+        }
+      }
+    }
     const v = g.validation;
     if (!v?.useShared) continue;
     const library = v.library ?? "zod";
@@ -604,7 +1144,7 @@ function resolveConfig(cfg) {
       const mine2 = sharedSchemaNames({ schemaSuffix: v.schemaSuffix });
       if (mine2.join(",") !== theirs.join(",")) {
         warnings.push(
-          `drzl config: the "orpc" generator's validation.schemaSuffix (${JSON.stringify(v.schemaSuffix ?? "Schema")}) does not match the "${library}" generator's schemaSuffix (${JSON.stringify(sibling.schemaSuffix ?? "Schema")}). The router will import ${mine2.join(", ")} but the "${library}" generator exports ${theirs.join(", ")}, so the generated router will not compile. Set both to the same value, or move to "affix", which is inherited automatically.`
+          `drzl config: the "${g.kind}" generator's validation.schemaSuffix (${JSON.stringify(v.schemaSuffix ?? "Schema")}) does not match the "${library}" generator's schemaSuffix (${JSON.stringify(sibling.schemaSuffix ?? "Schema")}). The router will import ${mine2.join(", ")} but the "${library}" generator exports ${theirs.join(", ")}, so the generated router will not compile. Set both to the same value, or move to "affix", which is inherited automatically.`
         );
       }
       continue;
@@ -615,7 +1155,7 @@ function resolveConfig(cfg) {
     });
     if (mine.join(",") !== theirs.join(",")) {
       throw new Error(
-        `drzl config: the "orpc" generator imports shared ${library} schemas, but its validation.affix disagrees with the "${library}" generator's own naming. The router would import ${mine.join(", ")} while the "${library}" generator exports ${theirs.join(", ")}. Make them match, or drop validation.affix and let it be inherited from the "${library}" generator.`
+        `drzl config: the "${g.kind}" generator imports shared ${library} schemas, but its validation.affix disagrees with the "${library}" generator's own naming. The router would import ${mine.join(", ")} while the "${library}" generator exports ${theirs.join(", ")}. Make them match, or drop validation.affix and let it be inherited from the "${library}" generator.`
       );
     }
   }
@@ -673,6 +1213,7 @@ function computeGeneratorOutputDirs(cfg, cwd = process.cwd()) {
   const dirs = /* @__PURE__ */ new Set();
   dirs.add(abs(cfg.outDir));
   for (const g of cfg.generators) {
+    if (g.kind === "trpc") dirs.add(abs(trpcOutDir(g, cfg)));
     if (g.kind === "service") dirs.add(abs(g.path ?? "src/services"));
     if (g.kind === "zod") dirs.add(abs(g.path ?? "src/validators/zod"));
     if (g.kind === "valibot") dirs.add(abs(g.path ?? "src/validators/valibot"));
@@ -689,7 +1230,7 @@ function resolveTemplateDirsSync(cfg, cwd = process.cwd()) {
   );
   for (const g of cfg.generators) {
     const t = g.template;
-    if (!t || t === "standard" || t === "minimal") continue;
+    if (!t || t === "standard" || t === "minimal" || t === "service") continue;
     let pkgDir = null;
     try {
       const pkg = req.resolve(`${t}/package.json`, { paths: [cwd] });
@@ -731,6 +1272,51 @@ function computeWatchTargets(cfg, cwd = process.cwd()) {
   return [...targets];
 }
 
+// src/trpc-options.ts
+function trpcOptions(g, cfg, servicesDir) {
+  return {
+    outputDir: trpcOutDir(g, cfg),
+    template: g.template,
+    includeRelations: g.includeRelations,
+    naming: g.naming,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    importExtension: g.importExtension,
+    validation: g.validation,
+    databaseInjection: g.databaseInjection,
+    // Where the service generator is actually writing, so `template: 'service'` emits an import
+    // of a module that exists. The generator defaults this to `src/services`, which is right only
+    // by coincidence for a config that puts them elsewhere.
+    servicesDir
+  };
+}
+
+// src/validation-options.ts
+function validationOptions(g, cfg, outDir, caps = {}) {
+  return {
+    outDir,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    schemaSuffix: g.schemaSuffix,
+    fileSuffix: g.fileSuffix,
+    importExtension: g.importExtension,
+    affix: g.affix,
+    coerceDates: g.coerceDates,
+    applyDefaults: g.applyDefaults,
+    duplicateFinder: g.duplicateFinder,
+    nestedSchemas: g.nestedSchemas,
+    nestedDepth: g.nestedDepth,
+    // Only where the generator can act on them, so an unsupported option is absent rather than
+    // present and ignored.
+    ...caps.schemaTypes ? {
+      // Needed by both: the reference is resolved relative to the emitted file.
+      schemaPath: cfg.schema,
+      typedJson: g.typedJson,
+      typedColumns: g.typedColumns
+    } : {}
+  };
+}
+
 // src/drift.ts
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
@@ -1010,12 +1596,34 @@ program.command("generate").description("Run configured generators (drzl.config.
           templateOptions: g.templateOptions,
           importExtension: g.importExtension,
           validation: g.validation,
+          // Documented on this generator since it was added and never reachable from a config
+          // file, because the config schema had no such key and zod stripped it in silence.
+          databaseInjection: g.databaseInjection,
           servicesDir,
           onProgress: ({ index }) => progress.update(index)
         });
         progress.stop();
         (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (${g.kind}): ${files.length} files`));
         files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+      } else if (g.kind === "trpc") {
+        try {
+          const { TRPCGenerator: TRPCGenerator2 } = await loadGenerator(
+            "@drzl/generator-trpc",
+            () => Promise.resolve().then(() => (init_dist(), dist_exports))
+          );
+          const gen = new TRPCGenerator2(analysis);
+          const { files } = await gen.generate({
+            ...trpcOptions(g, cfg, servicesDir),
+            onProgress: ({ index }) => progress.update(index)
+          });
+          progress.stop();
+          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (trpc): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+        } catch (e) {
+          progress.stop();
+          reportGeneratorFailure(g.kind, e);
+          process.exit(1);
+        }
       } else if (g.kind === "service") {
         try {
           const { ServiceGenerator } = await loadGenerator(
@@ -1031,7 +1639,12 @@ program.command("generate").description("Run configured generators (drzl.config.
             dataAccess: g.dataAccess,
             dbImportPath: g.dbImportPath,
             schemaImportPath: g.schemaImportPath,
-            importExtension: g.importExtension
+            importExtension: g.importExtension,
+            // The other half of `databaseInjection`. A router generator in injection mode
+            // emits `Service.getById(ctx.db, id)`, and only a service generated in the same
+            // mode has a `db` parameter to receive it. This branch never passed the option, so
+            // the two halves of one generated project disagreed about the signature.
+            databaseInjection: g.databaseInjection
           });
           progress.stop();
           (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (service): ${files.length} files`));
@@ -1102,7 +1715,7 @@ program.command("generate").description("Run configured generators (drzl.config.
         try {
           const { JsonSchemaGenerator: JsonSchemaGenerator2 } = await loadGenerator(
             "@drzl/generator-json-schema",
-            () => Promise.resolve().then(() => (init_dist(), dist_exports))
+            () => Promise.resolve().then(() => (init_dist2(), dist_exports2))
           );
           const gen = new JsonSchemaGenerator2(analysis);
           const target = g.path ?? "src/validators/json-schema";
@@ -1196,7 +1809,34 @@ program.command("generate:orpc").argument("<schema>", "path to drizzle schema (T
     process.exit(1);
   }
 });
-program.command("watch").description("Watch schema and regenerate on changes").option("-c, --config <path>", "path to drzl.config").option("--pipeline <name>", "all | analyze | generate-orpc", "all").option("--debounce <ms>", "debounce ms", "200").option("--json", "emit JSON logs", false).option("--poll", "force polling (helps WSL/Docker/remote FS)", false).action(async (opts) => {
+program.command("generate:trpc").argument("<schema>", "path to drizzle schema (TS)").option("-o, --outDir <dir>", "output directory", "src/api").option("--template <name>", "standard | service", "standard").option("--includeRelations", "include relation endpoints").option("--servicesDir <dir>", "where the service generator writes", "src/services").action(async (schema, opts) => {
+  try {
+    const analyzer = new import_analyzer.SchemaAnalyzer(schema);
+    const analysis = await analyzer.analyze({
+      includeRelations: !!opts.includeRelations,
+      validateConstraints: true
+    });
+    const { TRPCGenerator: TRPCGenerator2 } = await loadGenerator(
+      "@drzl/generator-trpc",
+      () => Promise.resolve().then(() => (init_dist(), dist_exports))
+    );
+    const gen = new TRPCGenerator2(analysis);
+    const { files } = await gen.generate({
+      outputDir: opts.outDir,
+      template: opts.template,
+      includeRelations: !!opts.includeRelations,
+      // Only consulted by `--template service`, and passed unconditionally so this command
+      // cannot become the branch that forgets it.
+      servicesDir: opts.servicesDir
+    });
+    console.log(import_chalk2.default.green(`Generated:`), files.map((f) => import_chalk2.default.cyan(f)).join(", "));
+    maybeShowSponsorMessage({ reason: "generate:trpc" });
+  } catch (e) {
+    reportGeneratorFailure("trpc", e);
+    process.exit(1);
+  }
+});
+program.command("watch").description("Watch schema and regenerate on changes").option("-c, --config <path>", "path to drzl.config").option("--pipeline <name>", "all | analyze | generate-orpc | generate-trpc", "all").option("--debounce <ms>", "debounce ms", "200").option("--json", "emit JSON logs", false).option("--poll", "force polling (helps WSL/Docker/remote FS)", false).action(async (opts) => {
   let cfg = await loadConfig(opts.config);
   if (!cfg) {
     console.error(import_chalk2.default.red("No config found. Create drzl.config.ts or pass --config."));
@@ -1296,8 +1936,13 @@ program.command("watch").description("Watch schema and regenerate on changes").o
         return;
       }
       const newFiles = [];
+      const servicesDir = cfg.generators.find((x) => x.kind === "service")?.path ?? "src/services";
+      const PIPELINE_KINDS = {
+        "generate-orpc": "orpc",
+        "generate-trpc": "trpc"
+      };
       for (const g of cfg.generators) {
-        if (opts.pipeline !== "all" && !(opts.pipeline === "generate-orpc" && g.kind === "orpc")) {
+        if (opts.pipeline !== "all" && PIPELINE_KINDS[opts.pipeline] !== g.kind) {
           continue;
         }
         if (g.kind === "orpc") {
@@ -1311,13 +1956,32 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             format: g.format,
             templateOptions: g.templateOptions,
             importExtension: g.importExtension,
-            validation: g.validation
+            validation: g.validation,
+            databaseInjection: g.databaseInjection,
+            servicesDir
           });
           opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
             import_chalk2.default.green(`Generated (${g.kind}):`),
             files.map((f) => import_chalk2.default.cyan(f)).join(", ")
           );
           newFiles.push(...files);
+        } else if (g.kind === "trpc") {
+          try {
+            const { TRPCGenerator: TRPCGenerator2 } = await loadGenerator(
+              "@drzl/generator-trpc",
+              () => Promise.resolve().then(() => (init_dist(), dist_exports))
+            );
+            const gen = new TRPCGenerator2(analysis);
+            const { files } = await gen.generate(trpcOptions(g, cfg, servicesDir));
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk2.default.green(`Generated (trpc): ${files.length} files`),
+              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            reportGeneratorFailure(g.kind, e);
+            return;
+          }
         } else if (g.kind === "service") {
           try {
             const { ServiceGenerator } = await loadGenerator(
@@ -1333,7 +1997,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               dataAccess: g.dataAccess,
               dbImportPath: g.dbImportPath,
               schemaImportPath: g.schemaImportPath,
-              importExtension: g.importExtension
+              importExtension: g.importExtension,
+              databaseInjection: g.databaseInjection
             });
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
               import_chalk2.default.green(`Generated (service): ${files.length} files`),
@@ -1352,15 +2017,9 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             );
             const gen = new ZodGenerator(analysis);
             const target = g.path ?? "src/validators/zod";
-            const files = await gen.generate({
-              outDir: target,
-              outputHeader: g.outputHeader,
-              format: g.format,
-              schemaSuffix: g.schemaSuffix,
-              fileSuffix: g.fileSuffix,
-              importExtension: g.importExtension,
-              affix: g.affix
-            });
+            const files = await gen.generate(
+              validationOptions(g, cfg, target, { schemaTypes: true })
+            );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
               import_chalk2.default.green(`Generated (zod): ${files.length} files`),
               files.map((f) => import_chalk2.default.cyan(f)).join(", ")
@@ -1378,15 +2037,9 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             );
             const gen = new ValibotGenerator(analysis);
             const target = g.path ?? "src/validators/valibot";
-            const files = await gen.generate({
-              outDir: target,
-              outputHeader: g.outputHeader,
-              format: g.format,
-              schemaSuffix: g.schemaSuffix,
-              fileSuffix: g.fileSuffix,
-              importExtension: g.importExtension,
-              affix: g.affix
-            });
+            const files = await gen.generate(
+              validationOptions(g, cfg, target, { schemaTypes: true })
+            );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
               import_chalk2.default.green(`Generated (valibot): ${files.length} files`),
               files.map((f) => import_chalk2.default.cyan(f)).join(", ")
@@ -1404,17 +2057,54 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             );
             const gen = new ArkTypeGenerator(analysis);
             const target = g.path ?? "src/validators/arktype";
+            const files = await gen.generate(
+              validationOptions(g, cfg, target, { schemaTypes: false })
+            );
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk2.default.green(`Generated (arktype): ${files.length} files`),
+              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            reportGeneratorFailure(g.kind, e);
+            return;
+          }
+        } else if (g.kind === "typebox") {
+          try {
+            const { TypeBoxGenerator } = await loadGenerator(
+              "@drzl/generator-typebox",
+              () => import("@drzl/generator-typebox")
+            );
+            const gen = new TypeBoxGenerator(analysis);
+            const target = g.path ?? "src/validators/typebox";
+            const files = await gen.generate(
+              validationOptions(g, cfg, target, { schemaTypes: true })
+            );
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk2.default.green(`Generated (typebox): ${files.length} files`),
+              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            reportGeneratorFailure(g.kind, e);
+            return;
+          }
+        } else if (g.kind === "json-schema") {
+          try {
+            const { JsonSchemaGenerator: JsonSchemaGenerator2 } = await loadGenerator(
+              "@drzl/generator-json-schema",
+              () => Promise.resolve().then(() => (init_dist2(), dist_exports2))
+            );
+            const gen = new JsonSchemaGenerator2(analysis);
+            const target = g.path ?? "src/validators/json-schema";
             const files = await gen.generate({
-              outDir: target,
-              outputHeader: g.outputHeader,
-              format: g.format,
-              schemaSuffix: g.schemaSuffix,
-              fileSuffix: g.fileSuffix,
-              importExtension: g.importExtension,
-              affix: g.affix
+              // JSON Schema is data, so nothing here references a type from the schema module.
+              ...validationOptions(g, cfg, target, { schemaTypes: false }),
+              target: g.target,
+              components: g.components
             });
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (arktype): ${files.length} files`),
+              import_chalk2.default.green(`Generated (json-schema): ${files.length} files`),
               files.map((f) => import_chalk2.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
@@ -1478,6 +2168,8 @@ program.command("init").description("Scaffold a drzl.config.ts").option("-y, --y
   outDir: 'src/api',
   analyzer: { includeRelations: true, validateConstraints: true },
   generators: [
+    // For tRPC instead: { kind: 'trpc', template: 'standard', includeRelations: true }
+    // To run both, give one of them its own \`path\`; they share \`outDir\` otherwise.
     { kind: 'orpc', template: 'standard', includeRelations: true }
   ]
 } as const