@drzl/cli 4.23.0 → 4.24.0

package/dist/cli.cjs

@@ -7,4298 +7,25 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// ../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.every(serviceKeyExpressible);
-  const keyArg = key ? key.map((c) => `input.${c.name}`).join(", ") : "";
-  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_core3.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_core3.resolveConfiguredImport)(
-        opts.validation.importPath,
-        ctx.out,
-        process.cwd(),
-        opts.importExtension
-      );
-      const names = wanted.map(([mode, local]) => {
-        const exported = (0, import_validation_core3.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_core3.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, path9, opts) {
-  const baseSpec = (0, import_validation_core3.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_core3.importSpecifier)(
-      "./" + path9.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 serviceKeyExpressible(c) {
-  if (c.enumValues && c.enumValues.length) return true;
-  return ["number", "string", "boolean", "Date"].includes(c.tsType);
-}
-function serviceKeyNote(table) {
-  const cols = table.primaryKey?.columns ?? [];
-  const untyped = cols.filter((n) => {
-    const c = table.columns.find((x) => x.name === n);
-    return !c || !serviceKeyExpressible(c);
-  });
-  const what = untyped.length === 1 ? `its column ${untyped[0]}` : `its columns ${untyped.join(", ")}`;
-  return `// ${table.name} is keyed on (${cols.join(", ")}) and DRZL cannot type ${what}: the input
-// schema carries unknown there, which the service's typed key parameter does not accept.
-// 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_core3.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, import_validation_core3, 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");
-    import_validation_core3 = 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 fs6 = (0, import_validation_core2.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outputDir);
-        const ctx = {
-          out,
-          services: path9.resolve(process.cwd(), opts.servicesDir ?? "src/services")
-        };
-        await fs6.mkdir(out, { recursive: true });
-        const files = [];
-        const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core3.formatCode)(
-            buildHeader(opts.outputHeader) + content,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        };
-        const basePath = path9.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 = path9.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(path9.join(out, "index.ts"), renderBarrel(routers, ctx, path9, opts));
-        return { files };
-      }
-    };
-    index_default = TRPCGenerator;
-  }
-});
-
-// ../generator-hono/dist/index.js
-var dist_exports2 = {};
-__export(dist_exports2, {
-  APP_MODULE: () => APP_MODULE,
-  HonoGenerator: () => HonoGenerator,
-  default: () => index_default2
-});
-function keyColumns2(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 isWide2(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 mapExpr2(column, lib, mode) {
-  const d = LIBS2[lib];
-  let base = (() => {
-    if (column.enumValues && column.enumValues.length) return d.enum(column.enumValues);
-    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 objectKey2(name) {
-  return isIdent2(name) ? name : JSON.stringify(name);
-}
-function field2(column, lib, mode) {
-  const d = LIBS2[lib];
-  const expr = mapExpr2(column, lib, mode);
-  return `${objectKey2(column.name)}: ${d.fieldIsString ? JSON.stringify(expr) : expr}`;
-}
-function paramField(column, lib) {
-  const d = LIBS2[lib];
-  const expr = (() => {
-    if (column.enumValues && column.enumValues.length) return d.enum(column.enumValues);
-    return d.coerce(column.tsType) ?? d.string;
-  })();
-  return `${objectKey2(column.name)}: ${d.fieldIsString ? JSON.stringify(expr) : expr}`;
-}
-function renderSchema2(table, lib, mode) {
-  const d = LIBS2[lib];
-  const cols = table.columns.filter((c) => mode === "select" ? true : !c.isGenerated);
-  const body = cols.map((c) => `  ${field2(c, lib, mode)},`).join("\n");
-  const schema = d.object(body);
-  return mode === "update" && d.partialUpdate ? d.partialUpdate(schema) : schema;
-}
-function toCase2(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 routesExportName(table, naming) {
-  const base = `${table.tsName}${naming?.routerSuffix ?? "Routes"}`;
-  const c = naming?.procedureCase;
-  return toCase2(base, c === "kebab" ? "camel" : c);
-}
-function mountPath(table, naming) {
-  return `/${toCase2(table.tsName, naming?.procedureCase)}`;
-}
-function buildHeader2(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";
-}
-function renderRoutes(table, opts, ctx) {
-  const lib = opts.validation?.library ?? "zod";
-  const d = LIBS2[lib];
-  const validator = VALIDATORS[opts.validator ?? "standard"];
-  const insertName = `Insert${table.tsName}Schema`;
-  const updateName = `Update${table.tsName}Schema`;
-  const selectName = `Select${table.tsName}Schema`;
-  const paramsName = `${cap2(table.tsName)}ParamsSchema`;
-  const rowType = `Select${table.tsName}Row`;
-  const writable = !table.readOnly;
-  const key = keyColumns2(table);
-  const routes = [];
-  const notImplemented = (what) => `throw new Error('Not implemented: ${what} ${table.tsName}.');`;
-  routes.push({
-    name: "list",
-    method: "get",
-    path: "/",
-    middleware: [],
-    // The stub states its own contract. tRPC has `.output()` and Hono has nothing like it: what a
-    // Hono client infers is the *handler's return type*, so the only place an output schema can be
-    // honoured is the value handed to `c.json`. Annotating the local is what puts the select shape
-    // into `hc<AppType>()` rather than `never[]`.
-    body: [`const rows: ${rowType}[] = [];`, "return c.json(rows);"]
-  });
-  if (key) {
-    const keyPath = "/" + key.map((c) => `:${c.name}`).join("/");
-    routes.push({
-      name: "byId",
-      method: "get",
-      path: keyPath,
-      middleware: [`${validator.fn}('param', ${paramsName})`],
-      body: [VALID_PARAM_HINT, `const row: ${rowType} | null = null;`, "return c.json(row);"]
-    });
-    if (writable) {
-      routes.push({
-        name: "update",
-        method: "patch",
-        path: keyPath,
-        middleware: [
-          `${validator.fn}('param', ${paramsName})`,
-          `${validator.fn}('json', ${updateName})`
-        ],
-        body: [notImplemented("update")]
-      });
-      routes.push({
-        name: "delete",
-        method: "delete",
-        path: keyPath,
-        middleware: [`${validator.fn}('param', ${paramsName})`],
-        body: [VALID_PARAM_HINT, "return c.json(true);"]
-      });
-    }
-  }
-  if (writable) {
-    routes.push({
-      name: "create",
-      method: "post",
-      path: "/",
-      middleware: [`${validator.fn}('json', ${insertName})`],
-      body: [notImplemented("create")]
-    });
-  }
-  if (opts.includeRelations) {
-    routes.push(...relationRoutes(table, lib, rowType, validator.fn, opts));
-  }
-  const order = ["list", "byId", "create", "update", "delete"];
-  const rank = (n) => order.indexOf(n) === -1 ? order.length : order.indexOf(n);
-  routes.sort((a, b) => rank(a.name) - rank(b.name));
-  const exportName = routesExportName(table, opts.naming);
-  const chain = routes.map((r) => {
-    const args = [lit(r.path), ...r.middleware].join(", ");
-    const ctxParam = r.body.some((line) => /\bc\./.test(line)) ? "c" : "_c";
-    return [
-      `  .${r.method}(${args}, async (${ctxParam}) => {`,
-      ...r.body.map((line) => `    ${line}`),
-      `  })`
-    ].join("\n");
-  }).join("\n");
-  const body = `export const ${exportName} = new Hono()
-${chain};
-`;
-  const useShared = !!opts.validation?.useShared && !!opts.validation?.importPath;
-  const declared = [];
-  if (!useShared) {
-    if (writable) {
-      declared.push(`export const ${insertName} = ${renderSchema2(table, lib, "insert")};`);
-      declared.push(`export const ${updateName} = ${renderSchema2(table, lib, "update")};`);
-    }
-    declared.push(`export const ${selectName} = ${renderSchema2(table, lib, "select")};`);
-  }
-  if (key) {
-    declared.push(
-      `export const ${paramsName} = ${d.objectInline(
-        key.map((c) => paramField(c, lib)).join(", ")
-      )};`
-    );
-  }
-  declared.push(`export type ${rowType} = ${d.infer(selectName)};`);
-  const decided = [...declared, body].join("\n\n");
-  const imports = [];
-  if (useShared) {
-    const sharedAffix = (0, import_validation_core5.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_core5.resolveConfiguredImport)(
-        opts.validation.importPath,
-        ctx.out,
-        process.cwd(),
-        opts.importExtension
-      );
-      const names = wanted.map(([mode, local]) => {
-        const exported = (0, import_validation_core5.schemaName)(mode, table.tsName, sharedAffix);
-        return exported === local ? local : `${exported} as ${local}`;
-      }).join(", ");
-      imports.push(`import { ${names} } from '${spec}';`);
-    }
-  }
-  imports.push(`import { Hono } from 'hono';`);
-  if (decided.includes(`${validator.fn}(`)) {
-    imports.push(`import { ${validator.fn} } from '${validator.from}';`);
-  }
-  if (LIB_USAGE2[lib].test(decided)) imports.unshift(LIB_IMPORTS2[lib]);
-  const wide = table.columns.filter(isWide2).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 these routes accept any value there.
-` : "";
-  return `// Generated by @drzl/generator-hono
-// Routes for table: ${table.name}
-${wideNote}${imports.join("\n")}
-
-${decided}`;
-}
-function relationRoutes(table, lib, rowType, validatorFn, opts) {
-  const d = LIBS2[lib];
-  const out = [];
-  const taken = /* @__PURE__ */ new Set();
-  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 segment = toCase2(`by-${colName}`, opts.naming?.procedureCase ?? "kebab");
-    if (taken.has(segment)) continue;
-    taken.add(segment);
-    const inline = d.objectInline(paramField(column, lib));
-    out.push({
-      name: `listBy${cap2(colName)}`,
-      method: "get",
-      path: `/${segment}/:${colName}`,
-      middleware: [`${validatorFn}('param', ${inline})`],
-      body: [VALID_PARAM_HINT, `const rows: ${rowType}[] = [];`, "return c.json(rows);"]
-    });
-  }
-  return out;
-}
-function renderBarrel2(modules, ctx, path9, opts) {
-  if (!modules.length) {
-    return `// Generated by @drzl/generator-hono
-// No tables detected in analysis. Add tables to your schema and regenerate.
-import { Hono } from 'hono';
-
-export const app = new Hono();
-
-/** The type a Hono client is parameterised by: \`hc<AppType>('/')\`. */
-export type AppType = typeof app;
-`;
-  }
-  const entries = modules.map(({ filePath, exportName, table }) => ({
-    rel: (0, import_validation_core5.importSpecifier)(
-      "./" + path9.relative(ctx.out, filePath).replace(/\\/g, "/"),
-      opts.importExtension
-    ),
-    exportName,
-    mount: mountPath(table, opts.naming)
-  }));
-  const imports = entries.map((e) => `import { ${e.exportName} } from '${e.rel}';`).join("\n");
-  const chain = entries.map((e) => `  .route(${lit(e.mount)}, ${e.exportName})`).join("\n");
-  const reExports = entries.map((e) => `export * from '${e.rel}';`).join("\n");
-  return `// Generated by @drzl/generator-hono
-import { Hono } from 'hono';
-${imports}
-
-export const app = new Hono()
-${chain};
-
-/** The type a Hono client is parameterised by: \`hc<AppType>('/')\`. */
-export type AppType = typeof app;
-
-${reExports}
-`;
-}
-var import_validation_core4, import_validation_core5, APP_MODULE, q2, lit, NUMERIC_SEGMENT, LIB_IMPORTS2, LIB_USAGE2, LIBS2, cap2, isIdent2, HonoGenerator, index_default2, VALIDATORS, VALID_PARAM_HINT;
-var init_dist2 = __esm({
-  "../generator-hono/dist/index.js"() {
-    "use strict";
-    import_validation_core4 = require("@drzl/validation-core");
-    import_validation_core5 = require("@drzl/validation-core");
-    APP_MODULE = "index";
-    q2 = (v) => JSON.stringify(v);
-    lit = (v) => /['\\]/.test(v) ? JSON.stringify(v) : `'${v}'`;
-    NUMERIC_SEGMENT = String.raw`/^-?\d+(\.\d+)?$/`;
-    LIB_IMPORTS2 = {
-      zod: "import { z } from 'zod';",
-      valibot: "import * as v from 'valibot';",
-      arktype: "import { type } from 'arktype';"
-    };
-    LIB_USAGE2 = {
-      zod: /\bz\./,
-      valibot: /\bv\./,
-      arktype: /\btype\(|\.infer\b/
-    };
-    LIBS2 = {
-      zod: {
-        number: "z.number()",
-        string: "z.string()",
-        boolean: "z.boolean()",
-        date: "z.date()",
-        unknown: "z.unknown()",
-        enum: (vals) => `z.enum([${vals.map(q2).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()`,
-        // Not `z.coerce.number()`, and not `z.coerce.date()`: both accept far more than a path
-        // segment addressing a row should. See the measured grid on `LibDialect.coerce`.
-        coerce: (t) => t === "number" ? `z.string().regex(${NUMERIC_SEGMENT}).transform(Number)` : t === "Date" ? "z.iso.datetime().transform((s) => new Date(s))" : null,
-        infer: (s) => `z.output<typeof ${s}>`
-      },
-      valibot: {
-        number: "v.number()",
-        string: "v.string()",
-        boolean: "v.boolean()",
-        date: "v.date()",
-        unknown: "v.unknown()",
-        enum: (vals) => `v.picklist([${vals.map(q2).join(", ")}] as const)`,
-        nullable: (b) => `v.nullable(${b})`,
-        optional: (b) => `v.optional(${b})`,
-        object: (body) => `v.object({
-${body}
-})`,
-        objectInline: (body) => `v.object({ ${body} })`,
-        // A valibot pipe step sees the previous step's *output*, so the check has to happen while the
-        // value is still the string: by the time a `v.transform(Number)` has run there is no string
-        // left to look at. See the measured grid on `LibDialect.coerce`.
-        coerce: (t) => t === "number" ? `v.pipe(v.string(), v.regex(${NUMERIC_SEGMENT}), v.transform(Number))` : t === "Date" ? "v.pipe(v.string(), v.isoTimestamp(), v.transform((s) => new Date(s)))" : null,
-        infer: (s) => `v.InferOutput<typeof ${s}>`
-      },
-      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.
-        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,
-        // ArkType ships these as keywords, and they are *morphs*: the declared output type is
-        // `number`, not `string`. Returned bare, because `fieldIsString` quotes every expression this
-        // dialect produces and a keyword returned pre-quoted arrives as `"'string.numeric.parse'"`,
-        // which ArkType reads as a string *literal* type matching nothing but that sentence.
-        //
-        // `string.date.parse` and not `string.date.iso.parse` was the first draft, and it accepts
-        // `"1"` as the year 2001, which is the same over-permissiveness the coercing spellings have.
-        coerce: (t) => t === "number" ? "string.numeric.parse" : t === "Date" ? "string.date.iso.parse" : null,
-        infer: (s) => `typeof ${s}.infer`
-      }
-    };
-    cap2 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-    isIdent2 = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
-    HonoGenerator = class {
-      constructor(analysis) {
-        this.analysis = analysis;
-      }
-      async generate(opts) {
-        const fs6 = (0, import_validation_core4.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outputDir);
-        const ctx = { out };
-        await fs6.mkdir(out, { recursive: true });
-        const files = [];
-        const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core5.formatCode)(
-            buildHeader2(opts.outputHeader) + content,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        };
-        const barrelPath = path9.join(out, `${APP_MODULE}.ts`);
-        const modules = [];
-        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 = path9.join(out, `${toCase2(base, opts.naming?.procedureCase)}.ts`);
-          if (filePath === barrelPath) {
-            throw new Error(
-              `@drzl/generator-hono: the routes for table "${table.name}" would be written to ${filePath}, which is the barrel this generator also writes. Set naming.routerSuffix to move it out of the way.`
-            );
-          }
-          await write(filePath, renderRoutes(table, opts, ctx));
-          modules.push({ table, filePath, exportName: routesExportName(table, opts.naming) });
-          index++;
-          opts.onProgress?.({ index, total, table: table.name, filePath });
-        }
-        await write(barrelPath, renderBarrel2(modules, ctx, path9, opts));
-        return { files };
-      }
-    };
-    index_default2 = HonoGenerator;
-    VALIDATORS = {
-      standard: { fn: "sValidator", from: "@hono/standard-validator" },
-      zod: { fn: "zValidator", from: "@hono/zod-validator" }
-    };
-    VALID_PARAM_HINT = "// The validated path parameters are at c.req.valid('param').";
-  }
-});
-
-// ../generator-express/dist/index.js
-var dist_exports3 = {};
-__export(dist_exports3, {
-  APP_MODULE: () => APP_MODULE2,
-  ExpressGenerator: () => ExpressGenerator,
-  VALIDATION_MODULE: () => VALIDATION_MODULE,
-  default: () => index_default3
-});
-function keyColumns3(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 isWide3(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 mapExpr3(column, lib, mode) {
-  const d = LIBS3[lib];
-  let base = (() => {
-    if (column.enumValues && column.enumValues.length) return d.enum(column.enumValues);
-    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 objectKey3(name) {
-  return isIdent3(name) ? name : JSON.stringify(name);
-}
-function field3(column, lib, mode) {
-  const d = LIBS3[lib];
-  const expr = mapExpr3(column, lib, mode);
-  return `${objectKey3(column.name)}: ${d.fieldIsString ? JSON.stringify(expr) : expr}`;
-}
-function paramField2(column, lib) {
-  const d = LIBS3[lib];
-  const expr = (() => {
-    if (column.enumValues && column.enumValues.length) return d.enum(column.enumValues);
-    return d.coerce(column.tsType) ?? d.string;
-  })();
-  return `${objectKey3(column.name)}: ${d.fieldIsString ? JSON.stringify(expr) : expr}`;
-}
-function renderSchema3(table, lib, mode) {
-  const d = LIBS3[lib];
-  const cols = table.columns.filter((c) => mode === "select" ? true : !c.isGenerated);
-  const body = cols.map((c) => `  ${field3(c, lib, mode)},`).join("\n");
-  const schema = d.object(body);
-  return mode === "update" && d.partialUpdate ? d.partialUpdate(schema) : schema;
-}
-function toCase3(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 routesExportName2(table, naming) {
-  const base = `${table.tsName}${naming?.routerSuffix ?? "Routes"}`;
-  const c = naming?.procedureCase;
-  return toCase3(base, c === "kebab" ? "camel" : c);
-}
-function mountPath2(table, naming) {
-  return `/${toCase3(table.tsName, naming?.procedureCase)}`;
-}
-function buildHeader3(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";
-}
-function renderValidationModule() {
-  return `// Generated by @drzl/generator-express
-// A validation middleware over Standard Schema v1, so the same routes accept zod, valibot or
-// arktype schemas. On failure it answers 400 with { error, slot, issues: [{ message, path }] };
-// on success it replaces req[slot] with the parsed output and calls next().
-import type { RequestHandler } from 'express';
-
-interface StandardIssue {
-  readonly message: string;
-  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined;
-}
-
-type StandardResult<Output> =
-  | { readonly value: Output; readonly issues?: undefined }
-  | { readonly issues: ReadonlyArray<StandardIssue> };
-
-export interface StandardSchema<Output = unknown> {
-  readonly '~standard': {
-    readonly version: 1;
-    readonly vendor: string;
-    readonly validate: (
-      value: unknown
-    ) => StandardResult<Output> | Promise<StandardResult<Output>>;
-  };
-}
-
-export function ${VALIDATE_FN}(slot: 'params' | 'body', schema: StandardSchema): RequestHandler {
-  return async (req, res, next) => {
-    const result = await schema['~standard'].validate(req[slot]);
-    if (result.issues) {
-      res.status(400).json({
-        error: 'Validation failed',
-        slot,
-        issues: result.issues.map((issue) => ({
-          message: issue.message,
-          path: (issue.path ?? []).map((p) => (typeof p === 'object' && p !== null ? p.key : p)),
-        })),
-      });
-      return;
-    }
-    req[slot] = result.value as never;
-    next();
-  };
-}
-`;
-}
-function renderRoutes2(table, opts, ctx) {
-  const lib = opts.validation?.library ?? "zod";
-  const d = LIBS3[lib];
-  const insertName = `Insert${table.tsName}Schema`;
-  const updateName = `Update${table.tsName}Schema`;
-  const selectName = `Select${table.tsName}Schema`;
-  const paramsName = `${cap3(table.tsName)}ParamsSchema`;
-  const rowType = `Select${table.tsName}Row`;
-  const writable = !table.readOnly;
-  const key = keyColumns3(table);
-  const routes = [];
-  const notImplemented = (what) => `throw new Error('Not implemented: ${what} ${table.tsName}.');`;
-  routes.push({
-    name: "list",
-    method: "get",
-    path: "/",
-    middleware: [],
-    resType: `${rowType}[]`,
-    // The stub states its own contract twice over: the annotated local is what a reader sees,
-    // and the annotated res parameter is what Express's own types hold the handler to. Nothing
-    // infers a client from either, which the docs say plainly; the types are for the person
-    // filling the stub in.
-    body: [`const rows: ${rowType}[] = [];`, "res.json(rows);"]
-  });
-  if (key) {
-    const keyPath = "/" + key.map((c) => `:${c.name}`).join("/");
-    routes.push({
-      name: "byId",
-      method: "get",
-      path: keyPath,
-      middleware: [`${VALIDATE_FN}('params', ${paramsName})`],
-      resType: `${rowType} | null`,
-      body: [VALID_PARAM_HINT2, `const row: ${rowType} | null = null;`, "res.json(row);"]
-    });
-    if (writable) {
-      routes.push({
-        name: "update",
-        method: "patch",
-        path: keyPath,
-        middleware: [
-          `${VALIDATE_FN}('params', ${paramsName})`,
-          "json()",
-          `${VALIDATE_FN}('body', ${updateName})`
-        ],
-        resType: rowType,
-        body: [notImplemented("update")]
-      });
-      routes.push({
-        name: "delete",
-        method: "delete",
-        path: keyPath,
-        middleware: [`${VALIDATE_FN}('params', ${paramsName})`],
-        resType: "boolean",
-        body: [VALID_PARAM_HINT2, "res.json(true);"]
-      });
-    }
-  }
-  if (writable) {
-    routes.push({
-      name: "create",
-      method: "post",
-      path: "/",
-      middleware: ["json()", `${VALIDATE_FN}('body', ${insertName})`],
-      resType: rowType,
-      body: [notImplemented("create")]
-    });
-  }
-  if (opts.includeRelations) {
-    routes.push(...relationRoutes2(table, lib, rowType, opts));
-  }
-  const order = ["list", "byId", "create", "update", "delete"];
-  const rank = (n) => order.indexOf(n) === -1 ? order.length : order.indexOf(n);
-  routes.sort((a, b) => rank(a.name) - rank(b.name));
-  const exportName = routesExportName2(table, opts.naming);
-  const statements = routes.map((r) => {
-    const args = [lit2(r.path), ...r.middleware].join(", ");
-    const reads = (what) => r.body.some((line) => !line.startsWith("//") && what.test(line));
-    const reqParam = reads(/\breq\./) ? "req" : "_req";
-    const resParam = reads(/\bres\./) ? "res" : "_res";
-    return [
-      `${exportName}.${r.method}(${args}, async (${reqParam}, ${resParam}: Response<${r.resType}>) => {`,
-      ...r.body.map((line) => `  ${line}`),
-      `});`
-    ].join("\n");
-  }).join("\n\n");
-  const body = `export const ${exportName} = Router();
-
-${statements}
-`;
-  const useShared = !!opts.validation?.useShared && !!opts.validation?.importPath;
-  const declared = [];
-  if (!useShared) {
-    if (writable) {
-      declared.push(`export const ${insertName} = ${renderSchema3(table, lib, "insert")};`);
-      declared.push(`export const ${updateName} = ${renderSchema3(table, lib, "update")};`);
-    }
-    declared.push(`export const ${selectName} = ${renderSchema3(table, lib, "select")};`);
-  }
-  if (key) {
-    declared.push(
-      `export const ${paramsName} = ${d.objectInline(
-        key.map((c) => paramField2(c, lib)).join(", ")
-      )};`
-    );
-  }
-  declared.push(`export type ${rowType} = ${d.infer(selectName)};`);
-  const decided = [...declared, body].join("\n\n");
-  const imports = [];
-  if (useShared) {
-    const sharedAffix = (0, import_validation_core7.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_core7.resolveConfiguredImport)(
-        opts.validation.importPath,
-        ctx.out,
-        process.cwd(),
-        opts.importExtension
-      );
-      const names = wanted.map(([mode, local]) => {
-        const exported = (0, import_validation_core7.schemaName)(mode, table.tsName, sharedAffix);
-        return exported === local ? local : `${exported} as ${local}`;
-      }).join(", ");
-      imports.push(`import { ${names} } from '${spec}';`);
-    }
-  }
-  const expressNames = ["Router"];
-  if (decided.includes("json()")) expressNames.push("json");
-  expressNames.push("type Response");
-  imports.push(`import { ${expressNames.join(", ")} } from 'express';`);
-  if (decided.includes(`${VALIDATE_FN}('`)) {
-    const spec = (0, import_validation_core7.importSpecifier)(`./${VALIDATION_MODULE}.ts`, opts.importExtension);
-    imports.push(`import { ${VALIDATE_FN} } from '${spec}';`);
-  }
-  if (LIB_USAGE3[lib].test(decided)) imports.unshift(LIB_IMPORTS3[lib]);
-  const wide = table.columns.filter(isWide3).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 these routes accept any value there.
-` : "";
-  return `// Generated by @drzl/generator-express
-// Routes for table: ${table.name}
-${wideNote}${imports.join("\n")}
-
-${decided}`;
-}
-function relationRoutes2(table, lib, rowType, opts) {
-  const d = LIBS3[lib];
-  const out = [];
-  const taken = /* @__PURE__ */ new Set();
-  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 segment = toCase3(`by-${colName}`, opts.naming?.procedureCase ?? "kebab");
-    if (taken.has(segment)) continue;
-    taken.add(segment);
-    const inline = d.objectInline(paramField2(column, lib));
-    out.push({
-      name: `listBy${cap3(colName)}`,
-      method: "get",
-      path: `/${segment}/:${colName}`,
-      middleware: [`${VALIDATE_FN}('params', ${inline})`],
-      resType: `${rowType}[]`,
-      body: [VALID_PARAM_HINT2, `const rows: ${rowType}[] = [];`, "res.json(rows);"]
-    });
-  }
-  return out;
-}
-function renderBarrel3(modules, ctx, path9, opts) {
-  if (!modules.length) {
-    return `// Generated by @drzl/generator-express
-// No tables detected in analysis. Add tables to your schema and regenerate.
-import express from 'express';
-
-export const app = express();
-`;
-  }
-  const entries = modules.map(({ filePath, exportName, table }) => ({
-    rel: (0, import_validation_core7.importSpecifier)(
-      "./" + path9.relative(ctx.out, filePath).replace(/\\/g, "/"),
-      opts.importExtension
-    ),
-    exportName,
-    mount: mountPath2(table, opts.naming)
-  }));
-  const imports = entries.map((e) => `import { ${e.exportName} } from '${e.rel}';`).join("\n");
-  const mounts = entries.map((e) => `app.use(${lit2(e.mount)}, ${e.exportName});`).join("\n");
-  const reExports = entries.map((e) => `export * from '${e.rel}';`).join("\n");
-  return `// Generated by @drzl/generator-express
-import express from 'express';
-${imports}
-
-export const app = express();
-
-${mounts}
-
-${reExports}
-`;
-}
-var import_validation_core6, import_validation_core7, APP_MODULE2, VALIDATION_MODULE, q3, lit2, NUMERIC_SEGMENT2, LIB_IMPORTS3, LIB_USAGE3, LIBS3, cap3, isIdent3, ExpressGenerator, index_default3, VALIDATE_FN, VALID_PARAM_HINT2;
-var init_dist3 = __esm({
-  "../generator-express/dist/index.js"() {
-    "use strict";
-    import_validation_core6 = require("@drzl/validation-core");
-    import_validation_core7 = require("@drzl/validation-core");
-    APP_MODULE2 = "index";
-    VALIDATION_MODULE = "validation";
-    q3 = (v) => JSON.stringify(v);
-    lit2 = (v) => /['\\]/.test(v) ? JSON.stringify(v) : `'${v}'`;
-    NUMERIC_SEGMENT2 = String.raw`/^-?\d+(\.\d+)?$/`;
-    LIB_IMPORTS3 = {
-      zod: "import { z } from 'zod';",
-      valibot: "import * as v from 'valibot';",
-      arktype: "import { type } from 'arktype';"
-    };
-    LIB_USAGE3 = {
-      zod: /\bz\./,
-      valibot: /\bv\./,
-      arktype: /\btype\(|\.infer\b/
-    };
-    LIBS3 = {
-      zod: {
-        number: "z.number()",
-        string: "z.string()",
-        boolean: "z.boolean()",
-        date: "z.date()",
-        unknown: "z.unknown()",
-        enum: (vals) => `z.enum([${vals.map(q3).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()`,
-        // Not `z.coerce.number()`, and not `z.coerce.date()`: both accept far more than a path
-        // segment addressing a row should. See the grid referenced on `LibDialect.coerce`.
-        coerce: (t) => t === "number" ? `z.string().regex(${NUMERIC_SEGMENT2}).transform(Number)` : t === "Date" ? "z.iso.datetime().transform((s) => new Date(s))" : null,
-        infer: (s) => `z.output<typeof ${s}>`
-      },
-      valibot: {
-        number: "v.number()",
-        string: "v.string()",
-        boolean: "v.boolean()",
-        date: "v.date()",
-        unknown: "v.unknown()",
-        enum: (vals) => `v.picklist([${vals.map(q3).join(", ")}] as const)`,
-        nullable: (b) => `v.nullable(${b})`,
-        optional: (b) => `v.optional(${b})`,
-        object: (body) => `v.object({
-${body}
-})`,
-        objectInline: (body) => `v.object({ ${body} })`,
-        // A valibot pipe step sees the previous step's *output*, so the check has to happen while the
-        // value is still the string: after a `v.transform(Number)` there is no string left to look at.
-        coerce: (t) => t === "number" ? `v.pipe(v.string(), v.regex(${NUMERIC_SEGMENT2}), v.transform(Number))` : t === "Date" ? "v.pipe(v.string(), v.isoTimestamp(), v.transform((s) => new Date(s)))" : null,
-        infer: (s) => `v.InferOutput<typeof ${s}>`
-      },
-      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.
-        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,
-        // ArkType ships these as keywords, and they are morphs: the declared output type is `number`,
-        // not `string`. Returned bare, because `fieldIsString` quotes every expression this dialect
-        // produces, and a keyword returned pre-quoted arrives as a string *literal* type matching
-        // nothing but that sentence. `string.date.iso.parse` and not `string.date.parse`, which
-        // accepts `"1"` as the year 2001.
-        coerce: (t) => t === "number" ? "string.numeric.parse" : t === "Date" ? "string.date.iso.parse" : null,
-        infer: (s) => `typeof ${s}.infer`
-      }
-    };
-    cap3 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-    isIdent3 = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
-    ExpressGenerator = class {
-      constructor(analysis) {
-        this.analysis = analysis;
-      }
-      async generate(opts) {
-        const fs6 = (0, import_validation_core6.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outputDir);
-        const ctx = { out };
-        await fs6.mkdir(out, { recursive: true });
-        const files = [];
-        const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core7.formatCode)(
-            buildHeader3(opts.outputHeader) + content,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        };
-        const barrelPath = path9.join(out, `${APP_MODULE2}.ts`);
-        const validationPath = path9.join(out, `${VALIDATION_MODULE}.ts`);
-        const modules = [];
-        const total = this.analysis.tables.length;
-        let index = 0;
-        let anyValidates = false;
-        for (const table of this.analysis.tables) {
-          const base = `${table.tsName}${opts.naming?.routerSuffix ?? ""}`;
-          const filePath = path9.join(out, `${toCase3(base, opts.naming?.procedureCase)}.ts`);
-          if (filePath === barrelPath || filePath === validationPath) {
-            const which = filePath === barrelPath ? "the barrel" : "the validation middleware module";
-            throw new Error(
-              `@drzl/generator-express: the routes for table "${table.name}" would be written to ${filePath}, which is ${which} this generator also writes. Set naming.routerSuffix to move it out of the way.`
-            );
-          }
-          const source = renderRoutes2(table, opts, ctx);
-          if (source.includes(`${VALIDATE_FN}('`)) anyValidates = true;
-          await write(filePath, source);
-          modules.push({ table, filePath, exportName: routesExportName2(table, opts.naming) });
-          index++;
-          opts.onProgress?.({ index, total, table: table.name, filePath });
-        }
-        if (anyValidates) {
-          await write(validationPath, renderValidationModule());
-        }
-        await write(barrelPath, renderBarrel3(modules, ctx, path9, opts));
-        return { files };
-      }
-    };
-    index_default3 = ExpressGenerator;
-    VALIDATE_FN = "validate";
-    VALID_PARAM_HINT2 = "// validate() has already replaced req.params with the parsed values.";
-  }
-});
-
-// ../generator-json-schema/dist/index.js
-var dist_exports4 = {};
-__export(dist_exports4, {
-  DRAFT: () => DRAFT,
-  JsonSchemaGenerator: () => JsonSchemaGenerator,
-  allColumns: () => allColumns,
-  componentSchemaName: () => componentSchemaName,
-  componentsDocument: () => componentsDocument,
-  default: () => index_default4,
-  documentSchemas: () => documentSchemas,
-  enumKey: () => enumKey,
-  openApiDocument: () => openApiDocument,
-  planSharedEnums: () => planSharedEnums,
-  tableSchemas: () => tableSchemas
-});
-function enumKey(name) {
-  const safe = name.replace(/[^A-Za-z0-9.\-_]/g, "_").replace(/^_+|_+$/g, "");
-  return safe.length ? safe : void 0;
-}
-function declaredEnumColumns(columns) {
-  return columns.filter((c) => !c.shape && c.enumValues && c.enumValues.length);
-}
-function planSharedEnums(columns, enums, ref2, reserved = /* @__PURE__ */ new Set()) {
-  if (!enums?.length) return void 0;
-  const uses = /* @__PURE__ */ new Map();
-  for (const c of declaredEnumColumns(columns)) {
-    const id = identity(c.enumValues);
-    uses.set(id, (uses.get(id) ?? 0) + 1);
-  }
-  const keyed = /* @__PURE__ */ new Map();
-  const taken = new Set(reserved);
-  for (const e of enums) {
-    const id = identity(e.values);
-    if ((uses.get(id) ?? 0) < 2) continue;
-    if (keyed.has(id)) continue;
-    const key = enumKey(e.name);
-    if (!key || taken.has(key)) continue;
-    taken.add(key);
-    keyed.set(id, { key, values: [...e.values] });
-  }
-  if (!keyed.size) return void 0;
-  const used = /* @__PURE__ */ new Set();
-  return {
-    resolve(values) {
-      const hit = keyed.get(identity(values));
-      if (!hit) return void 0;
-      used.add(hit.key);
-      return ref2(hit.key);
-    },
-    definitions() {
-      const out = {};
-      for (const { key, values } of keyed.values()) {
-        if (used.has(key)) out[key] = { enum: [...values] };
-      }
-      return out;
-    }
-  };
-}
-function canonicalSetPattern(values, integerOnly) {
-  const branches = (0, import_validation_core10.canonicalMembers)(values).map((member) => {
-    if (member === "0") return integerOnly ? "[+-]?0+" : "[+-]?(?:0+(?:\\.0*)?|0*\\.0+)";
-    const sign = member.startsWith("-") ? "-" : "\\+?";
-    const body = member.startsWith("-") ? member.slice(1) : member;
-    const [int = "", frac = ""] = body.split(".");
-    if (integerOnly) return `${sign}0*${int}`;
-    if (!frac) return `${sign}0*${int}(?:\\.0*)?`;
-    return int === "0" ? `${sign}0*\\.${frac}0*` : `${sign}0*${int}\\.${frac}0*`;
-  });
-  return `^(?:${branches.join("|")})$`;
-}
-function baseSchema(c, mode, target, checks, sets, lengths, enumRef) {
-  const s = c.shape;
-  if (s) {
-    switch (s.kind) {
-      case "json":
-        return {};
-      case "custom":
-        return {};
-      case "buffer": {
-        const bin = base64(target);
-        applyBinaryLengths(bin, c, lengths);
-        return bin;
-      }
-      case "tuple":
-        return target === "openapi-3.0" ? { type: "array", items: { type: "number" }, minItems: s.length, maxItems: s.length } : {
-          type: "array",
-          prefixItems: Array.from({ length: s.length }, () => ({ type: "number" })),
-          minItems: s.length,
-          maxItems: s.length
-        };
-      case "numberObject":
-        return {
-          type: "object",
-          properties: Object.fromEntries(s.fields.map((f) => [f, { type: "number" }])),
-          required: [...s.fields]
-        };
-      case "numberVector":
-        return {
-          type: "array",
-          items: { type: "number" },
-          ...s.length ? { minItems: s.length, maxItems: s.length } : {}
-        };
-      case "bitstring":
-        return {
-          type: "string",
-          pattern: "^[01]*$",
-          ...s.length ? s.exact ? { minLength: s.length, maxLength: s.length } : { maxLength: s.length } : {}
-        };
-      case "byteString":
-        return { type: "string", ...s.length ? { maxLength: s.length } : {} };
-    }
-  }
-  const set = sets.find((x) => x.column === c.name);
-  if (set) {
-    if ((0, import_validation_core10.comparisonWire)(c) === "numeric-string") {
-      return { type: "string", pattern: canonicalSetPattern(set.values, c.dbType === "BIGINT") };
-    }
-    return {
-      enum: set.values.map(
-        (v) => set.kind === "string" || c.tsType === "bigint" ? v : Number(v)
-      )
-    };
-  }
-  if (c.enumValues && c.enumValues.length) {
-    const ref2 = enumRef?.(c.enumValues);
-    return ref2 ? { $ref: ref2 } : { enum: [...c.enumValues] };
-  }
-  const mine = c.arrayDimensions ? [] : checks.filter((k) => k.column === c.name);
-  const eq = mine.find((k) => k.operator === "=");
-  if (eq) {
-    if ((0, import_validation_core10.comparisonWire)(c) === "numeric-string") {
-      return { type: "string", pattern: canonicalSetPattern([eq.value], c.dbType === "BIGINT") };
-    }
-    const only = eq.kind === "string" || c.tsType === "bigint" ? eq.value : Number(eq.value);
-    return target === "openapi-3.0" ? { enum: [only] } : { const: only };
-  }
-  switch (c.tsType) {
-    case "string": {
-      const out = { type: "string" };
-      if (c.format === "uuid") out.format = UUID_FORMAT;
-      else if (c.format && import_validation_core10.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core10.COLUMN_FORMATS[c.format];
-      if (c.maxLength !== void 0) out.maxLength = c.maxLength;
-      applyByteCap(out, c, lengths);
-      applyLengths(out, c, lengths);
-      return out;
-    }
-    case "number": {
-      const out = { type: (0, import_validation_core10.isIntegerColumn)(c) ? "integer" : "number" };
-      if (!c.arrayDimensions) applyNumericBounds(out, c, checks, target);
-      return out;
-    }
-    case "bigint":
-      return {
-        type: "string",
-        pattern: typeof c.min === "string" && !c.min.startsWith("-") ? "^\\d+$" : "^-?\\d+$"
-      };
-    case "boolean":
-      return { type: "boolean" };
-    case "Date":
-      return { type: "string", format: "date-time" };
-    case "Uint8Array":
-      return base64(target);
-    default:
-      return {};
-  }
-}
-function applyByteCap(out, c, lengths) {
-  const budget = byteBudget(c, lengths);
-  if (budget === void 0) return;
-  out.maxLength = Math.min(Number(out.maxLength ?? Infinity), budget);
-  out.description = BYTE_BUDGET_NOTE(budget);
-}
-function ceilingOf(k) {
-  if (k.operator === "<=" || k.operator === "=") return Number(k.value);
-  if (k.operator === "<") return Number(k.value) - 1;
-  return void 0;
-}
-function byteBudget(c, lengths) {
-  const bounds = [
-    ...c.maxBytes ? [c.maxBytes] : [],
-    ...lengths.filter((k) => k.column === c.name && k.unit === "bytes").map(ceilingOf).filter((n) => n !== void 0)
-  ];
-  return bounds.length ? Math.min(...bounds) : void 0;
-}
-function applyLengths(out, c, lengths) {
-  for (const k of lengths.filter((x) => x.column === c.name && x.unit !== "bytes")) {
-    const n = Number(k.value);
-    if (k.operator === ">=") out.minLength = Math.max(Number(out.minLength ?? 0), n);
-    else if (k.operator === ">") out.minLength = Math.max(Number(out.minLength ?? 0), n + 1);
-    else if (k.operator === "<=") out.maxLength = Math.min(Number(out.maxLength ?? Infinity), n);
-    else if (k.operator === "<") out.maxLength = Math.min(Number(out.maxLength ?? Infinity), n - 1);
-    else if (k.operator === "=") {
-      out.minLength = n;
-      out.maxLength = n;
-    }
-  }
-}
-function applyBinaryLengths(out, c, lengths) {
-  const budget = byteBudget(c, lengths);
-  if (budget === void 0) return;
-  out.maxLength = 4 * Math.ceil(budget / 3);
-  out.description = `At most ${budget} bytes, which JSON Schema has no keyword for. The value travels as base64, and maxLength counts the characters of that encoding: it refuses nothing the column accepts, and a value one or two bytes over the limit encodes to the same number of characters as one inside it.`;
-}
-function applyNumericBounds(out, c, checks, target) {
-  let min = c.min !== void 0 ? { value: Number(c.min), exclusive: false } : void 0;
-  let max = c.max !== void 0 ? { value: Number(c.max), exclusive: false } : void 0;
-  for (const k of checks.filter((x) => x.column === c.name && x.kind === "number")) {
-    if (k.operator === ">=") min = { value: Number(k.value), exclusive: false };
-    else if (k.operator === ">") min = { value: Number(k.value), exclusive: true };
-    else if (k.operator === "<=") max = { value: Number(k.value), exclusive: false };
-    else if (k.operator === "<") max = { value: Number(k.value), exclusive: true };
-  }
-  const old = target === "openapi-3.0";
-  if (min) {
-    if (min.exclusive && !old) out.exclusiveMinimum = min.value;
-    else {
-      out.minimum = min.value;
-      if (min.exclusive) out.exclusiveMinimum = true;
-    }
-  }
-  if (max) {
-    if (max.exclusive && !old) out.exclusiveMaximum = max.value;
-    else {
-      out.maximum = max.value;
-      if (max.exclusive) out.exclusiveMaximum = true;
-    }
-  }
-}
-function cardinalityBounds(c, cardinalities) {
-  if (!c.arrayDimensions) return {};
-  const out = {};
-  for (const k of cardinalities.filter((x) => x.column === c.name)) {
-    const n = Number(k.value);
-    if (k.operator === ">=") out.minItems = n;
-    else if (k.operator === ">") out.minItems = n + 1;
-    else if (k.operator === "<=") out.maxItems = n;
-    else if (k.operator === "<") out.maxItems = n - 1;
-    else if (k.operator === "=") {
-      out.minItems = n;
-      out.maxItems = n;
-    }
-  }
-  return out;
-}
-function makeNullable(s, target) {
-  if (target === "openapi-3.0") return { ...s, nullable: true };
-  if ("$ref" in s) return { anyOf: [s, { type: "null" }] };
-  if (s.type === void 0) {
-    if (Array.isArray(s.enum)) return { ...s, enum: [...s.enum, null] };
-    if ("const" in s) {
-      const { const: k, ...rest } = s;
-      return { ...rest, enum: [k, null] };
-    }
-    return s;
-  }
-  return { ...s, type: [s.type, "null"] };
-}
-function columnSchema(c, mode, target, checks, sets, lengths, cardinalities, applyDefault, enumRef) {
-  const wantsDefault = mode === "insert" && applyDefault && c.defaultValue !== void 0;
-  const refBlockedBy30 = target === "openapi-3.0" && !c.arrayDimensions && (c.nullable || wantsDefault);
-  let s = baseSchema(c, mode, target, checks, sets, lengths, refBlockedBy30 ? void 0 : enumRef);
-  const dims = c.arrayDimensions ?? 0;
-  for (let i = 0; i < dims; i++) {
-    s = { type: "array", items: s, ...i === dims - 1 ? cardinalityBounds(c, cardinalities) : {} };
-  }
-  if (c.nullable) s = makeNullable(s, target);
-  if (mode === "insert" && applyDefault && c.defaultValue !== void 0) {
-    s = { ...s, default: c.defaultValue };
-  }
-  return s;
-}
-function rowDescription(rows, cols) {
-  const present = new Set(cols.map((c) => c.name));
-  const applicable = rows.filter((r) => present.has(r.left) && present.has(r.right));
-  if (!applicable.length) return void 0;
-  const list = applicable.map((r) => `${r.name ? `${r.name}: ` : ""}${r.left} ${r.operator} ${r.right}`).join("; ");
-  return `Row constraints not expressible in JSON Schema: ${list}`;
-}
-function tableSchema(table, cols, mode, target, applyDefaults, parsed, enums, localDefs) {
-  const properties = {};
-  const required = [];
-  for (const c of cols) {
-    properties[c.name] = columnSchema(
-      c,
-      mode,
-      target,
-      parsed.checks,
-      parsed.sets,
-      parsed.lengths,
-      parsed.cardinalities,
-      applyDefaults,
-      enums?.resolve
-    );
-    const suppliedOnInsert = c.hasDefault || applyDefaults && c.defaultValue !== void 0 || c.isGenerated;
-    const optional = mode === "update" || mode === "insert" && suppliedOnInsert;
-    if (!optional) required.push(c.name);
-  }
-  const desc = rowDescription(parsed.rows, cols);
-  const defs = localDefs ? enums?.definitions() ?? {} : {};
-  return {
-    ...target === "draft-2020-12" ? { $schema: DRAFT } : {},
-    $id: `${table.tsName}.${mode}`,
-    title: `${mode} ${table.tsName}`,
-    ...desc ? { description: desc } : {},
-    type: "object",
-    properties,
-    ...required.length ? { required } : {},
-    additionalProperties: false,
-    ...Object.keys(defs).length ? { $defs: defs } : {}
-  };
-}
-function collect(table) {
-  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core10.parseCheck)(k.expression, k.name));
-  const { checks, sets } = (0, import_validation_core10.applyWirePolicy)(
-    table.columns,
-    parsed.flatMap((p) => p.ok ? p.checks : []),
-    parsed.flatMap((p) => p.ok ? p.sets ?? [] : [])
-  );
-  return {
-    checks,
-    sets,
-    rows: parsed.flatMap((p) => p.ok ? p.rows ?? [] : []),
-    lengths: parsed.flatMap((p) => p.ok ? p.lengths ?? [] : []),
-    cardinalities: parsed.flatMap((p) => p.ok ? p.cardinalities ?? [] : [])
-  };
-}
-function tableSchemas(table, opts = {}) {
-  const target = opts.target ?? "draft-2020-12";
-  const parsed = collect(table);
-  const localDefs = target === "draft-2020-12";
-  const build2 = (cols, mode) => {
-    const plan = localDefs ? planSharedEnums(cols, opts.enums, (key) => `#/$defs/${key}`) : void 0;
-    return tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed, plan, localDefs);
-  };
-  return {
-    insert: build2((0, import_validation_core10.insertColumns)(table), "insert"),
-    update: build2((0, import_validation_core10.updateColumns)(table), "update"),
-    select: build2((0, import_validation_core10.selectColumns)(table), "select")
-  };
-}
-function tableSchemasWith(table, target, applyDefaults, plan, modes = MODES) {
-  const parsed = collect(table);
-  const columns = {
-    insert: () => (0, import_validation_core10.insertColumns)(table),
-    update: () => (0, import_validation_core10.updateColumns)(table),
-    select: () => (0, import_validation_core10.selectColumns)(table)
-  };
-  const out = {};
-  for (const mode of modes) {
-    out[mode] = tableSchema(
-      table,
-      columns[mode](),
-      mode,
-      target,
-      applyDefaults,
-      parsed,
-      plan,
-      false
-    );
-  }
-  return out;
-}
-function componentsDocument(tables, opts = {}) {
-  const target = opts.target ?? "draft-2020-12";
-  const schemas = {};
-  for (const table of tables) {
-    const built = tableSchemasWith(table, target, !!opts.applyDefaults, void 0);
-    for (const mode of MODES) {
-      const { $schema: _dialect, $id: _id, ...rest } = built[mode];
-      schemas[componentSchemaName(table, mode)] = rest;
-    }
-  }
-  return { schemas };
-}
-function documentSchemas(tables, opts) {
-  const plan = planSharedEnums(
-    tables.flatMap((t) => t.columns),
-    opts.enums,
-    (key) => `#/components/schemas/${key}`,
-    opts.reserved
-  );
-  const built = /* @__PURE__ */ new Map();
-  for (const table of tables) {
-    const all = tableSchemasWith(table, opts.target, opts.applyDefaults, plan, opts.modes(table));
-    built.set(table, all);
-  }
-  return { built, definitions: () => plan?.definitions() ?? {} };
-}
-function keyColumns4(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 foreignKeysOf(table) {
-  if (table.foreignKeys?.length) return table.foreignKeys;
-  return table.columns.filter((c) => c.references).map((c) => ({
-    columns: [c.name],
-    foreignTable: c.references.table,
-    ...c.references.schema ? { foreignSchema: c.references.schema } : {},
-    foreignColumns: [c.references.column]
-  }));
-}
-function build(tables, opts) {
-  const target = opts.target ?? "draft-2020-12";
-  const schemaTarget = target === "openapi-3.0" ? "openapi-3.0" : "openapi-3.1";
-  const failure = String(opts.validationStatus ?? 400);
-  const paths = {};
-  const schemas = {};
-  const tags = [];
-  const operationIds = /* @__PURE__ */ new Map();
-  const owner = /* @__PURE__ */ new Map();
-  const claim = (path9, by, label) => {
-    const taken = owner.get(path9);
-    if (taken !== void 0 && taken.by !== by) {
-      throw new Error(
-        `@drzl/generator-json-schema: the OpenAPI path "${path9}" is claimed twice: by table "${taken.label}" (exported as ${taken.by}) and by table "${label}" (exported as ${by}). A path names one resource, so one of the two has to be left out of this generator with the config's "exclude" list.`
-      );
-    }
-    owner.set(path9, { by, label });
-  };
-  const operation = (id, table, rest) => {
-    const clash = operationIds.get(id);
-    if (clash !== void 0) {
-      throw new Error(
-        `@drzl/generator-json-schema: the operationId "${id}" would be emitted for both "${clash}" and "${(0, import_analyzer.qualifiedTableName)(table)}". An operationId is the method name a client generator derives, and the specification requires it to be unique across the document.`
-      );
-    }
-    operationIds.set(id, (0, import_analyzer.qualifiedTableName)(table));
-    return { operationId: id, tags: [(0, import_analyzer.qualifiedTableName)(table)], ...rest };
-  };
-  const keys = new Map(tables.map((t) => [t, keyColumns4(t)]));
-  const carried = new Map(tables.map((t) => [t, modesFor(t, keys.get(t))]));
-  const reserved = /* @__PURE__ */ new Set([
-    ERROR_SCHEMA,
-    ...tables.flatMap((t) => carried.get(t).map((m) => componentName(t, m)))
-  ]);
-  const shared = documentSchemas(tables, {
-    target: schemaTarget,
-    applyDefaults: !!opts.applyDefaults,
-    reserved,
-    modes: (t) => carried.get(t),
-    ...opts.enums ? { enums: opts.enums } : {}
-  });
-  const built = tables.map((table) => ({
-    table,
-    key: keys.get(table),
-    segment: resourceSegment(table),
-    schemas: shared.built.get(table)
-  }));
-  for (const { table, key, segment, schemas: built3 } of built) {
-    for (const mode of carried.get(table)) {
-      const { $schema: _dialect, $id: _id, ...rest } = built3[mode];
-      schemas[componentName(table, mode)] = rest;
-    }
-    const notes = [];
-    if (!key) notes.push("It has no primary key, so no path addresses a single row.");
-    if (table.readOnly) {
-      notes.push("It refuses every write, so only reads are described.");
-    }
-    tags.push({
-      name: (0, import_analyzer.qualifiedTableName)(table),
-      description: [`Table "${(0, import_analyzer.qualifiedTableName)(table)}".`, ...notes].join(" ")
-    });
-    const T = pascal(table.tsName);
-    const select = ref(componentName(table, "select"));
-    const validationFailed = {
-      description: "The request does not match the schema for this operation.",
-      ...jsonBody(ref(ERROR_SCHEMA))
-    };
-    const collidable = [
-      ...table.primaryKey ? [`primary key (${table.primaryKey.columns.join(", ")})`] : [],
-      ...table.unique.map((u) => `${u.name ? `${u.name} ` : ""}(${u.columns.join(", ")})`)
-    ];
-    const conflict = (constraints) => ({
-      description: `The row collides with an existing one on ${constraints.join("; ")}.`,
-      ...jsonBody(ref(ERROR_SCHEMA))
-    });
-    const collection = `/${segment}`;
-    claim(collection, table.tsName, (0, import_analyzer.qualifiedTableName)(table));
-    const item = {
-      get: operation(`list${T}`, table, {
-        summary: `List every ${table.name} row.`,
-        // No pagination parameters. Whether the server implements a limit, an offset or a cursor is
-        // not something a Drizzle schema states, and a declared parameter nothing honours is worse
-        // than an undeclared one.
-        responses: {
-          "200": {
-            description: `Every ${table.name} row.`,
-            ...jsonBody({ type: "array", items: select })
-          }
-        }
-      })
-    };
-    if (!table.readOnly) {
-      item.post = operation(`create${T}`, table, {
-        summary: `Create a ${table.name} row.`,
-        requestBody: { required: true, ...jsonBody(ref(componentName(table, "insert"))) },
-        responses: {
-          "201": { description: `The ${table.name} row that was created.`, ...jsonBody(select) },
-          [failure]: validationFailed,
-          ...collidable.length ? { "409": conflict(collidable) } : {}
-        }
-      });
-    }
-    paths[collection] = item;
-    if (!key) continue;
-    const itemPath = `${collection}/${key.map((c) => `{${c.name}}`).join("/")}`;
-    claim(itemPath, table.tsName, (0, import_analyzer.qualifiedTableName)(table));
-    const parameters = key.map((c) => ({
-      name: c.name,
-      in: "path",
-      required: true,
-      description: `${c.name}, from the primary key of ${table.name}.`,
-      // The column's own schema rather than a string, so an integer key is declared as one and a
-      // uuid key carries its format. This is the whole point of reading the real key.
-      schema: built3.select.properties[c.name] ?? {}
-    }));
-    const missing = {
-      description: `No ${table.name} row has that ${key.map((c) => c.name).join(" and ")}.`,
-      ...jsonBody(ref(ERROR_SCHEMA))
-    };
-    const byId = {
-      parameters,
-      get: operation(`get${T}`, table, {
-        summary: `Read one ${table.name} row.`,
-        responses: {
-          "200": { description: `The requested ${table.name} row.`, ...jsonBody(select) },
-          [failure]: validationFailed,
-          "404": missing
-        }
-      })
-    };
-    if (!table.readOnly) {
-      byId.patch = operation(`update${T}`, table, {
-        summary: `Patch one ${table.name} row.`,
-        requestBody: { required: true, ...jsonBody(ref(componentName(table, "update"))) },
-        responses: {
-          "200": { description: `The ${table.name} row after the patch.`, ...jsonBody(select) },
-          [failure]: validationFailed,
-          "404": missing,
-          // The primary key is not in the update schema, so a patch cannot collide on it. Only a
-          // unique constraint over other columns can.
-          ...table.unique.length ? {
-            "409": conflict(
-              table.unique.map((u) => `${u.name ? `${u.name} ` : ""}(${u.columns.join(", ")})`)
-            )
-          } : {}
-        }
-      });
-      byId.delete = operation(`delete${T}`, table, {
-        summary: `Delete one ${table.name} row.`,
-        responses: {
-          // No body. Handing back the deleted row is the alternative and it is not a true statement
-          // on every dialect DRZL supports: RETURNING is Postgres and SQLite, and MySQL has no such
-          // clause, so an implementation there has nothing to send.
-          "204": { description: `The ${table.name} row was deleted. No content is returned.` },
-          [failure]: validationFailed,
-          "404": missing
-        }
-      });
-    }
-    paths[itemPath] = byId;
-    if (!opts.includeRelations) continue;
-    for (const child of built) {
-      if (child.table === table) continue;
-      const matching = foreignKeysOf(child.table).filter(
-        (fk) => (
-          // Qualified on both sides. On the bare name a key pointing at `reporting.users` also
-          // answered for `public.users`, so the child was hung under a parent in another schema.
-          (0, import_analyzer.qualifiedForeignTable)(fk) === (0, import_analyzer.qualifiedTableName)(table) && fk.foreignColumns.length === key.length && fk.foreignColumns.every((c, i) => c === key[i].name)
-        )
-      );
-      if (matching.length !== 1) continue;
-      const subPath = `${itemPath}/${child.segment}`;
-      claim(
-        subPath,
-        `${table.tsName} -> ${child.table.tsName}`,
-        `${(0, import_analyzer.qualifiedTableName)(table)} -> ${(0, import_analyzer.qualifiedTableName)(child.table)}`
-      );
-      paths[subPath] = {
-        parameters,
-        get: operation(`list${T}${pascal(child.table.tsName)}`, child.table, {
-          summary: `List the ${child.table.name} rows belonging to one ${table.name} row.`,
-          responses: {
-            "200": {
-              description: `The ${child.table.name} rows whose ${matching[0].columns.join(", ")} names this ${table.name} row.`,
-              ...jsonBody({ type: "array", items: ref(componentName(child.table, "select")) })
-            },
-            [failure]: validationFailed,
-            "404": missing
-          }
-        })
-      };
-    }
-  }
-  return { paths, schemas: { ...schemas, ...shared.definitions() }, tags };
-}
-function openApiDocument(tables, opts = {}) {
-  const target = opts.target ?? "draft-2020-12";
-  const { paths, schemas, tags } = build(tables, opts);
-  if (ERROR_SCHEMA in schemas) {
-    throw new Error(
-      `@drzl/generator-json-schema: a table produced the component schema name "${ERROR_SCHEMA}", which the document already uses for its error responses.`
-    );
-  }
-  return {
-    openapi: target === "openapi-3.0" ? "3.0.3" : "3.1.1",
-    info: {
-      title: opts.info?.title ?? "API",
-      version: opts.info?.version ?? "0.0.0",
-      description: opts.info?.description ?? "Generated by DRZL from a Drizzle schema. Paths, request bodies and response bodies are derived from the schema alone; nothing here has been checked against a running server."
-    },
-    ...opts.servers?.length ? { servers: opts.servers } : {},
-    paths,
-    components: { schemas: { ...schemas, [ERROR_SCHEMA]: errorSchema() } },
-    tags
-  };
-}
-function renderTableModule(table, affix, target, applyDefaults, enums) {
-  const T = table.tsName;
-  const schemas = tableSchemas(table, { target, applyDefaults, ...enums ? { enums } : {} });
-  const decl = (mode) => `export const ${(0, import_validation_core9.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
-
-export type ${(0, import_validation_core9.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core9.schemaName)(mode, T, affix)};`;
-  return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
-}
-function resolveDocument(opt) {
-  if (!opt) return null;
-  const o = opt === true ? {} : opt;
-  if (o.enabled === false) return null;
-  return { ...o, format: o.format ?? "ts" };
-}
-function buildHeader4(h) {
-  if (h?.enabled === false) return "";
-  const text = h?.text ?? "// Generated by DRZL. Do not edit by hand.";
-  return `${text}
-
-`;
-}
-var import_validation_core8, import_validation_core9, import_analyzer, import_validation_core10, identity, allColumns, DRAFT, UUID_FORMAT, base64, BYTE_BUDGET_NOTE, MODES, componentSchemaName, ERROR_SCHEMA, componentName, ref, pascal, modesFor, resourceSegment, jsonBody, errorSchema, DEFAULT_FILE_SUFFIX, JsonSchemaGenerator, index_default4;
-var init_dist4 = __esm({
-  "../generator-json-schema/dist/index.js"() {
-    "use strict";
-    import_validation_core8 = require("@drzl/validation-core");
-    import_validation_core9 = require("@drzl/validation-core");
-    import_analyzer = require("@drzl/analyzer");
-    import_validation_core10 = require("@drzl/validation-core");
-    identity = (values) => JSON.stringify([...values]);
-    allColumns = (tables) => tables.flatMap((t) => t.columns);
-    DRAFT = "https://json-schema.org/draft/2020-12/schema";
-    UUID_FORMAT = "uuid";
-    base64 = (target) => target === "openapi-3.0" ? { type: "string", format: "byte" } : { type: "string", contentEncoding: "base64" };
-    BYTE_BUDGET_NOTE = (n) => `At most ${n} bytes of UTF-8, which JSON Schema has no keyword for. maxLength counts characters: it refuses nothing the column accepts, and a string of multi-byte characters can satisfy it and still be too long for the column.`;
-    MODES = ["insert", "update", "select"];
-    componentSchemaName = (table, mode) => `${table.tsName}${mode[0].toUpperCase()}${mode.slice(1)}`;
-    ERROR_SCHEMA = "Error";
-    componentName = componentSchemaName;
-    ref = (name) => ({ $ref: `#/components/schemas/${name}` });
-    pascal = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-    modesFor = (table, key) => [
-      ...table.readOnly ? [] : ["insert"],
-      ...table.readOnly || !key ? [] : ["update"],
-      "select"
-    ];
-    resourceSegment = (table) => table.schema ? `${encodeURIComponent(table.schema)}/${encodeURIComponent(table.name)}` : encodeURIComponent(table.name);
-    jsonBody = (schema) => ({ content: { "application/json": { schema } } });
-    errorSchema = () => ({
-      title: "error",
-      description: "What an operation returns when it does not return the row.",
-      type: "object",
-      properties: {
-        message: { type: "string" },
-        code: { type: "string" }
-      },
-      required: ["message"],
-      additionalProperties: true
-    });
-    DEFAULT_FILE_SUFFIX = ".schema.ts";
-    JsonSchemaGenerator = class {
-      constructor(analysis) {
-        this.analysis = analysis;
-        this.library = "json-schema";
-      }
-      async generate(opts) {
-        const fs6 = (0, import_validation_core8.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outDir);
-        const files = [];
-        await fs6.mkdir(out, { recursive: true });
-        const affix = (0, import_validation_core9.resolveAffix)(opts);
-        const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
-        const target = opts.target ?? "draft-2020-12";
-        const document = resolveDocument(opts.document);
-        for (const table of this.analysis.tables) {
-          const filePath = path9.join(out, (0, import_validation_core9.moduleFileName)(table.tsName, fileSuffix));
-          const code = renderTableModule(
-            table,
-            affix,
-            target,
-            !!opts.applyDefaults,
-            opts.sharedEnums ? this.analysis.enums : void 0
-          );
-          const formatted = await (0, import_validation_core9.formatCode)(
-            buildHeader4(opts.outputHeader) + code,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        }
-        if (opts.components) {
-          const doc = componentsDocument(this.analysis.tables, {
-            target,
-            applyDefaults: !!opts.applyDefaults
-          });
-          const componentsPath = path9.join(out, "components.ts");
-          const code = `export const components = ${JSON.stringify(doc, null, 2)} as const;
-`;
-          await fs6.writeFile(
-            componentsPath,
-            await (0, import_validation_core9.formatCode)(buildHeader4(opts.outputHeader) + code, componentsPath, opts.format),
-            "utf8"
-          );
-          files.push(componentsPath);
-        }
-        if (document) {
-          const built = openApiDocument(this.analysis.tables, {
-            target,
-            applyDefaults: !!opts.applyDefaults,
-            includeRelations: !!opts.includeRelations,
-            enums: this.analysis.enums,
-            info: document.info,
-            servers: document.servers,
-            validationStatus: document.validationStatus
-          });
-          const body = JSON.stringify(built, null, 2);
-          if (document.format !== "json") {
-            const tsPath = path9.join(out, "openapi.ts");
-            const code = `export const openapi = ${body} as const;
-`;
-            await fs6.writeFile(
-              tsPath,
-              await (0, import_validation_core9.formatCode)(buildHeader4(opts.outputHeader) + code, tsPath, opts.format),
-              "utf8"
-            );
-            files.push(tsPath);
-          }
-          if (document.format !== "ts") {
-            const jsonPath = path9.join(out, "openapi.json");
-            await fs6.writeFile(jsonPath, body + "\n", "utf8");
-            files.push(jsonPath);
-          }
-        }
-        const ext = opts.importExtension === "none" ? "" : ".js";
-        const indexPath = path9.join(out, "index.ts");
-        const index = this.analysis.tables.map(
-          (t) => `export * from '${(0, import_validation_core9.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
-        ).concat(opts.components ? [`export * from './components${ext}';`] : []).concat(document && document.format !== "json" ? [`export * from './openapi${ext}';`] : []).join("\n") + "\n";
-        const indexFormatted = await (0, import_validation_core9.formatCode)(
-          buildHeader4(opts.outputHeader) + index,
-          indexPath,
-          opts.format
-        );
-        await fs6.writeFile(indexPath, indexFormatted, "utf8");
-        files.push(indexPath);
-        return files;
-      }
-      renderTable(table, opts) {
-        return renderTableModule(
-          table,
-          (0, import_validation_core9.resolveAffix)(opts),
-          opts?.target ?? "draft-2020-12",
-          !!opts?.applyDefaults,
-          opts?.sharedEnums ? this.analysis.enums : void 0
-        );
-      }
-    };
-    index_default4 = JsonSchemaGenerator;
-  }
-});
-
-// ../generator-fastify/dist/index.js
-var dist_exports5 = {};
-__export(dist_exports5, {
-  APP_MODULE: () => APP_MODULE3,
-  FastifyGenerator: () => FastifyGenerator,
-  default: () => index_default5
-});
-function keyColumns5(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 segmentSchema(column) {
-  if (column.enumValues && column.enumValues.length) return { enum: [...column.enumValues] };
-  switch (column.tsType) {
-    case "number":
-      return { type: "string", pattern: NUMERIC_SEGMENT_PATTERN };
-    case "bigint":
-      return { type: "string", pattern: BIGINT_SEGMENT_PATTERN };
-    case "Date":
-      return { type: "string", format: "date-time" };
-    default:
-      return { type: "string" };
-  }
-}
-function paramsSchema(cols) {
-  return {
-    type: "object",
-    properties: Object.fromEntries(cols.map((c) => [c.name, segmentSchema(c)])),
-    required: cols.map((c) => c.name),
-    additionalProperties: false
-  };
-}
-function adaptForFastify(schema) {
-  const { $schema: _dialect, $id: _id, ...rest } = walk(schema);
-  return rest;
-}
-function walk(value) {
-  if (Array.isArray(value)) return value.map(walk);
-  if (value && typeof value === "object") {
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-      if (k === "prefixItems") continue;
-      out[k] = walk(v);
-    }
-    const prefix = value.prefixItems;
-    if (Array.isArray(prefix) && prefix.length) out.items = walk(prefix[0]);
-    return out;
-  }
-  return value;
-}
-function rowFieldType(column) {
-  if (column.enumValues && column.enumValues.length) {
-    return column.enumValues.map((v) => `'${v.replace(/'/g, "\\'")}'`).join(" | ");
-  }
-  const s = column.shape;
-  if (s) {
-    switch (s.kind) {
-      case "tuple":
-        return `[${Array.from({ length: s.length }, () => "number").join(", ")}]`;
-      case "numberObject":
-        return `{ ${s.fields.map((f) => `${f}: number`).join("; ")} }`;
-      case "numberVector":
-        return "number[]";
-      default:
-        return "unknown";
-    }
-  }
-  switch (column.tsType) {
-    case "number":
-      return "number";
-    case "string":
-      return "string";
-    case "boolean":
-      return "boolean";
-    case "Date":
-      return "Date";
-    case "bigint":
-      return "bigint";
-    default:
-      return "unknown";
-  }
-}
-function objectKey4(name) {
-  return isIdent4(name) ? name : JSON.stringify(name);
-}
-function toCase4(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 routesExportName3(table, naming) {
-  const base = `${table.tsName}${naming?.routerSuffix ?? "Routes"}`;
-  const c = naming?.procedureCase;
-  return toCase4(base, c === "kebab" ? "camel" : c);
-}
-function mountPath3(table, naming) {
-  return `/${toCase4(table.tsName, naming?.procedureCase)}`;
-}
-function buildHeader5(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";
-}
-function renderRoutes3(table, opts) {
-  const insertName = `Insert${table.tsName}Schema`;
-  const updateName = `Update${table.tsName}Schema`;
-  const selectName = `Select${table.tsName}Schema`;
-  const paramsName = `${cap4(table.tsName)}ParamsSchema`;
-  const rowType = `Select${table.tsName}Row`;
-  const writable = !table.readOnly;
-  const key = keyColumns5(table);
-  const routes = [];
-  const notImplemented = (what) => `throw new Error('Not implemented: ${what} ${table.tsName}.');`;
-  const paramHint = `// Fastify has already validated req.params against ${paramsName}; numeric key segments stay strings here.`;
-  routes.push({
-    name: "list",
-    method: "get",
-    path: "/",
-    schema: [`response: { 200: { type: 'array', items: ${selectName} } }`],
-    replyType: `${rowType}[]`,
-    // The stub states its contract twice over: the annotated local is what a reader sees, and the
-    // Reply generic is what Fastify's own types hold the handler to. The response schema is what
-    // the serializer runs; nothing infers a client from any of them, which the docs say plainly.
-    body: [`const rows: ${rowType}[] = [];`, "return rows;"]
-  });
-  if (key) {
-    const keyPath = "/" + key.map((c) => `:${c.name}`).join("/");
-    routes.push({
-      name: "byId",
-      method: "get",
-      path: keyPath,
-      schema: [
-        `params: ${paramsName}`,
-        `response: { 200: ${selectName}, 404: ${NOT_FOUND_SCHEMA} }`
-      ],
-      replyType: `${rowType} | { message: string }`,
-      body: [
-        paramHint,
-        `const row: ${rowType} | null = null;`,
-        "if (row !== null) return row;",
-        `return reply.code(404).send({ message: ${lit3(`${table.tsName} row not found`)} });`
-      ]
-    });
-    if (writable) {
-      routes.push({
-        name: "update",
-        method: "patch",
-        path: keyPath,
-        schema: [
-          `params: ${paramsName}`,
-          `body: ${updateName}`,
-          `response: { 200: ${selectName} }`
-        ],
-        replyType: rowType,
-        body: [notImplemented("update")]
-      });
-      routes.push({
-        name: "delete",
-        method: "delete",
-        path: keyPath,
-        schema: [`params: ${paramsName}`, `response: { 200: { type: 'boolean' } }`],
-        replyType: "boolean",
-        body: [paramHint, "return true;"]
-      });
-    }
-  }
-  if (writable) {
-    routes.push({
-      name: "create",
-      method: "post",
-      path: "/",
-      schema: [`body: ${insertName}`, `response: { 200: ${selectName} }`],
-      replyType: rowType,
-      body: [notImplemented("create")]
-    });
-  }
-  if (opts.includeRelations) {
-    routes.push(...relationRoutes3(table, rowType, selectName, opts));
-  }
-  const order = ["list", "byId", "create", "update", "delete"];
-  const rank = (n) => order.indexOf(n) === -1 ? order.length : order.indexOf(n);
-  routes.sort((a, b) => rank(a.name) - rank(b.name));
-  const exportName = routesExportName3(table, opts.naming);
-  const statements = routes.map((r) => {
-    const reads = (what) => r.body.some((line) => !line.startsWith("//") && what.test(line));
-    const params = reads(/\breply\./) ? reads(/\breq\./) ? "(req, reply)" : "(_req, reply)" : reads(/\breq\./) ? "(req)" : "()";
-    return [
-      `  app.${r.method}<{ Reply: ${r.replyType} }>(${lit3(r.path)}, {`,
-      `    schema: { ${r.schema.join(", ")} },`,
-      `  }, async ${params} => {`,
-      ...r.body.map((line) => `    ${line}`),
-      `  });`
-    ].join("\n");
-  }).join("\n\n");
-  const plugin = `export const ${exportName}: FastifyPluginAsync = async (app) => {
-${statements}
-};
-`;
-  const schemas = tableSchemas(table);
-  const declared = [];
-  const emit = (name, schema) => `export const ${name} = ${JSON.stringify(adaptForFastify(schema), null, 2)} as const;`;
-  if (writable) {
-    declared.push(emit(insertName, schemas.insert));
-    declared.push(emit(updateName, schemas.update));
-  }
-  declared.push(emit(selectName, schemas.select));
-  if (key) {
-    declared.push(emit(paramsName, paramsSchema(key)));
-  }
-  const rowFields = (0, import_validation_core12.selectColumns)(table).map((c) => `  ${objectKey4(c.name)}: ${rowFieldType(c)}${c.nullable ? " | null" : ""};`).join("\n");
-  declared.push(`export interface ${rowType} {
-${rowFields}
-}`);
-  const wide = (0, import_validation_core12.selectColumns)(table).filter((c) => rowFieldType(c) === "unknown").map((c) => c.name);
-  const wideNote = wide.length ? `// No precise type for ${wide.length === 1 ? "this column" : "these columns"}: ${wide.join(", ")}.
-// DRZL could not derive one from the schema, so these routes carry it as unknown and its
-// schema constrains only what the builder could state.
-` : "";
-  return `// Generated by @drzl/generator-fastify
-// Routes for table: ${table.name}
-${wideNote}import type { FastifyPluginAsync } from 'fastify';
-
-${declared.join("\n\n")}
-
-${plugin}`;
-}
-function relationRoutes3(table, rowType, selectName, opts) {
-  const out = [];
-  const taken = /* @__PURE__ */ new Set();
-  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 segment = toCase4(`by-${colName}`, opts.naming?.procedureCase ?? "kebab");
-    if (taken.has(segment)) continue;
-    taken.add(segment);
-    const params = JSON.stringify(paramsSchema([column]));
-    out.push({
-      name: `listBy${cap4(colName)}`,
-      method: "get",
-      path: `/${segment}/:${colName}`,
-      schema: [`params: ${params}`, `response: { 200: { type: 'array', items: ${selectName} } }`],
-      replyType: `${rowType}[]`,
-      body: [`const rows: ${rowType}[] = [];`, "return rows;"]
-    });
-  }
-  return out;
-}
-function renderBarrel4(modules, ctx, path9, opts) {
-  if (!modules.length) {
-    return `// Generated by @drzl/generator-fastify
-// No tables detected in analysis. Add tables to your schema and regenerate.
-import type { FastifyPluginAsync } from 'fastify';
-
-export const routes: FastifyPluginAsync = async () => {};
-`;
-  }
-  const entries = modules.map(({ filePath, exportName, table }) => ({
-    rel: (0, import_validation_core12.importSpecifier)(
-      "./" + path9.relative(ctx.out, filePath).replace(/\\/g, "/"),
-      opts.importExtension
-    ),
-    exportName,
-    mount: mountPath3(table, opts.naming)
-  }));
-  const imports = entries.map((e) => `import { ${e.exportName} } from '${e.rel}';`).join("\n");
-  const registrations = entries.map((e) => `  app.register(${e.exportName}, { prefix: ${lit3(e.mount)} });`).join("\n");
-  const reExports = entries.map((e) => `export * from '${e.rel}';`).join("\n");
-  return `// Generated by @drzl/generator-fastify
-import type { FastifyPluginAsync } from 'fastify';
-${imports}
-
-export const routes: FastifyPluginAsync = async (app) => {
-${registrations}
-};
-
-${reExports}
-`;
-}
-var import_validation_core11, import_validation_core12, APP_MODULE3, lit3, NUMERIC_SEGMENT_PATTERN, BIGINT_SEGMENT_PATTERN, NOT_FOUND_SCHEMA, cap4, isIdent4, FastifyGenerator, index_default5;
-var init_dist5 = __esm({
-  "../generator-fastify/dist/index.js"() {
-    "use strict";
-    import_validation_core11 = require("@drzl/validation-core");
-    init_dist4();
-    import_validation_core12 = require("@drzl/validation-core");
-    APP_MODULE3 = "index";
-    lit3 = (v) => /['\\]/.test(v) ? JSON.stringify(v) : `'${v}'`;
-    NUMERIC_SEGMENT_PATTERN = "^-?\\d+(\\.\\d+)?$";
-    BIGINT_SEGMENT_PATTERN = "^-?\\d+$";
-    NOT_FOUND_SCHEMA = "{ type: 'object', properties: { message: { type: 'string' } }, required: ['message'], additionalProperties: false }";
-    cap4 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-    isIdent4 = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
-    FastifyGenerator = class {
-      constructor(analysis) {
-        this.analysis = analysis;
-      }
-      async generate(opts) {
-        const fs6 = (0, import_validation_core11.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outputDir);
-        const ctx = { out };
-        await fs6.mkdir(out, { recursive: true });
-        const files = [];
-        const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core12.formatCode)(
-            buildHeader5(opts.outputHeader) + content,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        };
-        const barrelPath = path9.join(out, `${APP_MODULE3}.ts`);
-        const modules = [];
-        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 = path9.join(out, `${toCase4(base, opts.naming?.procedureCase)}.ts`);
-          if (filePath === barrelPath) {
-            throw new Error(
-              `@drzl/generator-fastify: the routes for table "${table.name}" would be written to ${filePath}, which is the barrel this generator also writes. Set naming.routerSuffix to move it out of the way.`
-            );
-          }
-          await write(filePath, renderRoutes3(table, opts));
-          modules.push({ table, filePath, exportName: routesExportName3(table, opts.naming) });
-          index++;
-          opts.onProgress?.({ index, total, table: table.name, filePath });
-        }
-        await write(barrelPath, renderBarrel4(modules, ctx, path9, opts));
-        return { files };
-      }
-    };
-    index_default5 = FastifyGenerator;
-  }
-});
-
-// ../generator-nestjs/dist/index.js
-var dist_exports6 = {};
-__export(dist_exports6, {
-  APP_MODULE: () => APP_MODULE4,
-  NestJSGenerator: () => NestJSGenerator,
-  VALIDATION_MODULE: () => VALIDATION_MODULE2,
-  default: () => index_default6
-});
-function keyColumns6(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 isWide4(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", "bigint"].includes(column.tsType);
-}
-function baseExpr(column, d, mode) {
-  if (column.enumValues && column.enumValues.length) return d.enum(column.enumValues);
-  switch (column.tsType) {
-    case "number":
-      return d.number;
-    case "string":
-      return d.string;
-    case "boolean":
-      return d.boolean;
-    case "Date":
-      return mode === "select" ? d.date : d.dateInput;
-    case "bigint":
-      return d.bigint;
-    default:
-      return d.unknown;
-  }
-}
-function mapExpr4(column, lib, mode) {
-  const d = LIBS4[lib];
-  let expr = baseExpr(column, d, mode);
-  if (column.nullable) expr = d.nullable(expr);
-  if (mode === "update" || mode === "insert" && column.hasDefault) expr = d.optional(expr);
-  return expr;
-}
-function objectKey5(name) {
-  return isIdent5(name) ? name : JSON.stringify(name);
-}
-function field4(column, lib, mode) {
-  const d = LIBS4[lib];
-  const expr = mapExpr4(column, lib, mode);
-  return `${objectKey5(column.name)}: ${d.fieldIsString ? JSON.stringify(expr) : expr}`;
-}
-function paramField3(column, lib) {
-  const d = LIBS4[lib];
-  const expr = (() => {
-    if (column.enumValues && column.enumValues.length) return d.enum(column.enumValues);
-    return d.coerce(column.tsType) ?? d.string;
-  })();
-  return `${objectKey5(column.name)}: ${d.fieldIsString ? JSON.stringify(expr) : expr}`;
-}
-function renderSchema4(cols, lib, mode) {
-  const d = LIBS4[lib];
-  const body = cols.map((c) => `  ${field4(c, lib, mode)},`).join("\n");
-  return d.object(body);
-}
-function fieldType(column) {
-  if (column.enumValues && column.enumValues.length) {
-    return column.enumValues.map((x) => `'${x.replace(/'/g, "\\'")}'`).join(" | ");
-  }
-  switch (column.tsType) {
-    case "number":
-      return "number";
-    case "string":
-      return "string";
-    case "boolean":
-      return "boolean";
-    case "Date":
-      return "Date";
-    case "bigint":
-      return "string";
-    default:
-      return "unknown";
-  }
-}
-function paramFieldType(column) {
-  if (column.enumValues && column.enumValues.length) return fieldType(column);
-  switch (column.tsType) {
-    case "number":
-      return "number";
-    case "Date":
-      return "Date";
-    default:
-      return "string";
-  }
-}
-function classField(column, mode) {
-  const key = isIdent5(column.name) ? column.name : `'${column.name.replace(/'/g, "\\'")}'`;
-  if (mode === "params") return `  ${key}!: ${paramFieldType(column)};`;
-  const optional = mode === "update" || mode === "insert" && column.hasDefault;
-  const type = `${fieldType(column)}${column.nullable ? " | null" : ""}`;
-  return optional ? `  ${key}?: ${type};` : `  ${key}!: ${type};`;
-}
-function toCase5(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 buildHeader6(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";
-}
-function renderValidationModule2() {
-  return `// Generated by @drzl/generator-nestjs
-// A validation pipe over Standard Schema v1. Bind it globally
-// (app.useGlobalPipes(new SchemaValidationPipe())) or per handler with @UsePipes. A parameter
-// whose class carries a static Standard Schema (every DTO in this directory) is validated and
-// replaced by the parsed output; anything else, primitives and foreign DTOs alike, passes
-// through untouched. On failure it throws BadRequestException with
-// { error, slot, issues: [{ message, path }] }, which Nest answers as a 400.
-//
-// These DTOs do not use Nest's class-validator ValidationPipe and assume nothing about its
-// options. If your app also binds one globally, note one measured interaction: with
-// whitelist: true it strips every property of these classes before this pipe runs, because
-// they carry no class-validator metadata.
-import { BadRequestException, type ArgumentMetadata, type PipeTransform } from '@nestjs/common';
-
-interface StandardIssue {
-  readonly message: string;
-  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined;
-}
-
-type StandardResult<Output> =
-  | { readonly value: Output; readonly issues?: undefined }
-  | { readonly issues: ReadonlyArray<StandardIssue> };
-
-export interface StandardSchema<Output = unknown> {
-  readonly '~standard': {
-    readonly version: 1;
-    readonly vendor: string;
-    readonly validate: (
-      value: unknown
-    ) => StandardResult<Output> | Promise<StandardResult<Output>>;
-  };
-}
-
-interface CarriesSchema {
-  readonly schema: StandardSchema;
-}
-
-function carriesSchema(metatype: unknown): metatype is CarriesSchema {
-  return (
-    typeof metatype === 'function' &&
-    typeof (metatype as { schema?: { '~standard'?: { validate?: unknown } } }).schema?.[
-      '~standard'
-    ]?.validate === 'function'
-  );
-}
-
-export class SchemaValidationPipe implements PipeTransform {
-  async transform(value: unknown, metadata: ArgumentMetadata): Promise<unknown> {
-    const { metatype } = metadata;
-    if (!carriesSchema(metatype)) return value;
-    const result = await metatype.schema['~standard'].validate(value);
-    if (result.issues) {
-      throw new BadRequestException({
-        error: 'Validation failed',
-        slot: metadata.type,
-        issues: result.issues.map((issue) => ({
-          message: issue.message,
-          path: (issue.path ?? []).map((p) => (typeof p === 'object' && p !== null ? p.key : p)),
-        })),
-      });
-    }
-    return result.value;
-  }
-}
-`;
-}
-function renderTable(table, opts) {
-  const lib = opts.validation?.library ?? "zod";
-  const d = LIBS4[lib];
-  const insertName = `Insert${table.tsName}Schema`;
-  const updateName = `Update${table.tsName}Schema`;
-  const selectName = `Select${table.tsName}Schema`;
-  const paramsName = `${cap5(table.tsName)}ParamsSchema`;
-  const createDto = `Create${cap5(table.tsName)}Dto`;
-  const updateDto = `Update${cap5(table.tsName)}Dto`;
-  const paramsDto = `${cap5(table.tsName)}ParamsDto`;
-  const entity = `${cap5(table.tsName)}Entity`;
-  const writable = !table.readOnly;
-  const key = keyColumns6(table);
-  const declared = [];
-  const insertCols = (0, import_validation_core14.insertColumns)(table);
-  const updateCols = (0, import_validation_core14.updateColumns)(table);
-  const selectCols = (0, import_validation_core14.selectColumns)(table);
-  if (writable) {
-    declared.push(`export const ${insertName} = ${renderSchema4(insertCols, lib, "insert")};`);
-    declared.push(`export const ${updateName} = ${renderSchema4(updateCols, lib, "update")};`);
-  }
-  declared.push(`export const ${selectName} = ${renderSchema4(selectCols, lib, "select")};`);
-  if (key) {
-    declared.push(
-      `export const ${paramsName} = ${d.objectInline(key.map((c) => paramField3(c, lib)).join(", "))};`
-    );
-  }
-  const dtoClass = (name, doc, cols, mode, schema) => {
-    const fields = cols.map((c) => classField(c, mode)).join("\n");
-    return `/**
- * ${doc}
- */
-export class ${name} {
-${fields}
-
-  static readonly schema: StandardSchema<${name}> = ${schema};
-}`;
-  };
-  if (writable) {
-    declared.push(
-      dtoClass(
-        createDto,
-        `The insert shape of ${table.name}. Fields state what the pipe hands your controller; a nullable column with no default is required, null spelled out.`,
-        insertCols,
-        "insert",
-        insertName
-      )
-    );
-    declared.push(
-      dtoClass(
-        updateDto,
-        `The update shape of ${table.name}: every field optional, primary key excluded.`,
-        updateCols,
-        "update",
-        updateName
-      )
-    );
-  }
-  if (key) {
-    declared.push(
-      dtoClass(
-        paramsDto,
-        `The path parameters addressing one ${table.name} row, parsed strictly from their string segments.`,
-        key,
-        "params",
-        paramsName
-      )
-    );
-  }
-  declared.push(
-    dtoClass(
-      entity,
-      `One ${table.name} row, at its select shape.`,
-      selectCols,
-      "select",
-      selectName
-    )
-  );
-  const decided = declared.join("\n\n");
-  const imports = [];
-  imports.push(LIB_IMPORTS4[lib]);
-  const spec = (0, import_validation_core14.importSpecifier)(`./${VALIDATION_MODULE2}.ts`, opts.importExtension);
-  imports.push(`import type { StandardSchema } from '${spec}';`);
-  const wide = table.columns.filter(isWide4).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 these DTOs accept any value there.
-` : "";
-  return `// Generated by @drzl/generator-nestjs
-// DTOs for table: ${table.name}
-${wideNote}${imports.join("\n")}
-
-${decided}
-`;
-}
-function renderBarrel5(modules, ctx, path9, opts) {
-  const validationSpec = (0, import_validation_core14.importSpecifier)(`./${VALIDATION_MODULE2}.ts`, opts.importExtension);
-  if (!modules.length) {
-    return `// Generated by @drzl/generator-nestjs
-// No tables detected in analysis. Add tables to your schema and regenerate.
-export * from '${validationSpec}';
-`;
-  }
-  const reExports = modules.map(({ filePath }) => {
-    const rel = (0, import_validation_core14.importSpecifier)(
-      "./" + path9.relative(ctx.out, filePath).replace(/\\/g, "/"),
-      opts.importExtension
-    );
-    return `export * from '${rel}';`;
-  }).join("\n");
-  return `// Generated by @drzl/generator-nestjs
-${reExports}
-export * from '${validationSpec}';
-`;
-}
-var import_validation_core13, import_validation_core14, APP_MODULE4, VALIDATION_MODULE2, q4, NUMERIC_SEGMENT3, BIGINT_DIGITS, LIB_IMPORTS4, LIBS4, cap5, isIdent5, NestJSGenerator, index_default6;
-var init_dist6 = __esm({
-  "../generator-nestjs/dist/index.js"() {
-    "use strict";
-    import_validation_core13 = require("@drzl/validation-core");
-    import_validation_core14 = require("@drzl/validation-core");
-    APP_MODULE4 = "index";
-    VALIDATION_MODULE2 = "validation";
-    q4 = (v) => JSON.stringify(v);
-    NUMERIC_SEGMENT3 = String.raw`/^-?\d+(\.\d+)?$/`;
-    BIGINT_DIGITS = String.raw`/^-?\d+$/`;
-    LIB_IMPORTS4 = {
-      zod: "import { z } from 'zod';",
-      valibot: "import * as v from 'valibot';",
-      arktype: "import { type } from 'arktype';"
-    };
-    LIBS4 = {
-      zod: {
-        number: "z.number()",
-        string: "z.string()",
-        boolean: "z.boolean()",
-        date: "z.date()",
-        dateInput: "z.iso.datetime().transform((s) => new Date(s))",
-        bigint: `z.string().regex(${BIGINT_DIGITS})`,
-        unknown: "z.unknown()",
-        enum: (vals) => `z.enum([${vals.map(q4).join(", ")}] as const)`,
-        nullable: (b) => `${b}.nullable()`,
-        optional: (b) => `${b}.optional()`,
-        object: (body) => `z.object({
-${body}
-})`,
-        objectInline: (body) => `z.object({ ${body} })`,
-        coerce: (t) => t === "number" ? `z.string().regex(${NUMERIC_SEGMENT3}).transform(Number)` : t === "Date" ? "z.iso.datetime().transform((s) => new Date(s))" : t === "bigint" ? `z.string().regex(${BIGINT_DIGITS})` : null
-      },
-      valibot: {
-        number: "v.number()",
-        string: "v.string()",
-        boolean: "v.boolean()",
-        date: "v.date()",
-        dateInput: "v.pipe(v.string(), v.isoTimestamp(), v.transform((s) => new Date(s)))",
-        bigint: `v.pipe(v.string(), v.regex(${BIGINT_DIGITS}))`,
-        unknown: "v.unknown()",
-        enum: (vals) => `v.picklist([${vals.map(q4).join(", ")}] as const)`,
-        nullable: (b) => `v.nullable(${b})`,
-        optional: (b) => `v.optional(${b})`,
-        object: (body) => `v.object({
-${body}
-})`,
-        objectInline: (body) => `v.object({ ${body} })`,
-        // A valibot pipe step sees the previous step's *output*, so the check has to happen while
-        // the value is still the string: after a `v.transform(Number)` there is no string left.
-        coerce: (t) => t === "number" ? `v.pipe(v.string(), v.regex(${NUMERIC_SEGMENT3}), v.transform(Number))` : t === "Date" ? "v.pipe(v.string(), v.isoTimestamp(), v.transform((s) => new Date(s)))" : t === "bigint" ? `v.pipe(v.string(), v.regex(${BIGINT_DIGITS}))` : null
-      },
-      arktype: {
-        number: "number",
-        string: "string",
-        boolean: "boolean",
-        date: "Date",
-        dateInput: "string.date.iso.parse",
-        bigint: BIGINT_DIGITS,
-        unknown: "unknown",
-        // The surrounding encode adds the quotes, so the union is built with the inner quoting
-        // ArkType expects.
-        enum: (vals) => vals.map((x) => `'${x.replace(/'/g, "\\'")}'`).join(" | "),
-        nullable: (b) => `(${b} | null)`,
-        optional: (b) => `${b}?`,
-        // `.onUndeclaredKey('delete')` because ArkType's default keeps undeclared keys (measured on
-        // 2.2.3), where zod and valibot strip them. A DTO's whole point is that the controller
-        // receives the declared shape, so the three libraries are aligned on the strict side.
-        object: (body) => `type({
-${body}
-}).onUndeclaredKey('delete')`,
-        objectInline: (body) => `type({ ${body} }).onUndeclaredKey('delete')`,
-        fieldIsString: true,
-        // ArkType ships these as keywords, and they are morphs: the declared output type is the
-        // parsed one. `string.date.iso.parse` and not `string.date.parse`, which accepts `"1"` as
-        // the year 2001.
-        coerce: (t) => t === "number" ? "string.numeric.parse" : t === "Date" ? "string.date.iso.parse" : t === "bigint" ? BIGINT_DIGITS : null
-      }
-    };
-    cap5 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-    isIdent5 = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
-    NestJSGenerator = class {
-      constructor(analysis) {
-        this.analysis = analysis;
-      }
-      async generate(opts) {
-        const fs6 = (0, import_validation_core13.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outputDir);
-        const ctx = { out };
-        await fs6.mkdir(out, { recursive: true });
-        const files = [];
-        const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core14.formatCode)(
-            buildHeader6(opts.outputHeader) + content,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        };
-        const barrelPath = path9.join(out, `${APP_MODULE4}.ts`);
-        const validationPath = path9.join(out, `${VALIDATION_MODULE2}.ts`);
-        const modules = [];
-        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 = path9.join(out, `${toCase5(base, opts.naming?.procedureCase)}.ts`);
-          if (filePath === barrelPath || filePath === validationPath) {
-            const which = filePath === barrelPath ? "the barrel" : "the validation pipe module";
-            throw new Error(
-              `@drzl/generator-nestjs: the DTOs for table "${table.name}" would be written to ${filePath}, which is ${which} this generator also writes. Set naming.routerSuffix to move it out of the way.`
-            );
-          }
-          await write(filePath, renderTable(table, opts));
-          modules.push({ filePath });
-          index++;
-          opts.onProgress?.({ index, total, table: table.name, filePath });
-        }
-        await write(validationPath, renderValidationModule2());
-        await write(barrelPath, renderBarrel5(modules, ctx, path9, opts));
-        return { files };
-      }
-    };
-    index_default6 = NestJSGenerator;
-  }
-});
-
-// ../generator-graphql/dist/index.js
-var dist_exports7 = {};
-__export(dist_exports7, {
-  APP_MODULE: () => APP_MODULE5,
-  GraphQLGenerator: () => GraphQLGenerator,
-  SCALARS_MODULE: () => SCALARS_MODULE,
-  default: () => index_default7
-});
-function gqlIdent(s) {
-  const cleaned = s.replace(/[^_0-9A-Za-z]+/g, "_");
-  return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
-}
-function tpl(s) {
-  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-}
-function keyColumns7(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 fitsInt32(c) {
-  if (c.min === void 0 || c.max === void 0) return false;
-  try {
-    return BigInt(c.min) >= INT32_MIN && BigInt(c.max) <= INT32_MAX;
-  } catch {
-    return false;
-  }
-}
-function planEnum(typeName3, values) {
-  const members = values.map((value) => {
-    const verbatimOk = GRAPHQL_NAME.test(value) && !RESERVED_ENUM_VALUES.has(value) && !value.startsWith("__");
-    if (verbatimOk) return { name: value, value, renamed: false };
-    let name = gqlIdent(value.toUpperCase());
-    name = name.replace(/^_+/, "_");
-    if (!GRAPHQL_NAME.test(name) || RESERVED_ENUM_VALUES.has(name) || name.startsWith("__")) {
-      return { name: "", value, renamed: true };
-    }
-    return { name, value, renamed: true };
-  });
-  if (members.some((m) => !m.name)) return null;
-  const seen = /* @__PURE__ */ new Set();
-  for (const m of members) {
-    if (seen.has(m.name)) return null;
-    seen.add(m.name);
-  }
-  return { typeName: typeName3, members };
-}
-function mapped(sdl, rowTs, inputTs = rowTs, scalars = []) {
-  return { sdl, rowTs, inputTs, scalars };
-}
-function planColumn(table, c) {
-  const field5 = GRAPHQL_NAME.test(c.name) ? c.name : gqlIdent(c.name);
-  const base = (() => {
-    if (c.enumValues && c.enumValues.length) {
-      const typeName3 = `${cap6(gqlIdent(table.tsName))}${cap6(gqlIdent(c.name))}Enum`;
-      const plan = planEnum(typeName3, c.enumValues);
-      if (!plan) {
-        return {
-          ...mapped("String", "string"),
-          note: `Column "${c.name}": the enum values ${c.enumValues.join(", ")} cannot all be spelled as distinct GraphQL enum members, so the column is exposed as String carrying the database values verbatim.`
-        };
-      }
-      const union = c.enumValues.map(q5).join(" | ");
-      return { ...mapped(plan.typeName, union), enumPlan: plan };
-    }
-    switch (c.shape?.kind) {
-      case "tuple":
-        return mapped("[Float!]", "number[]");
-      case "numberObject":
-        return mapped("JSON", "unknown", "unknown", ["JSON"]);
-      case "buffer":
-        return {
-          ...mapped("JSON", "unknown", "unknown", ["JSON"]),
-          note: `Column "${c.name}" is binary; GraphQL has no binary type, so it rides the JSON scalar and your resolver picks an encoding.`
-        };
-      case "json":
-        return mapped("JSON", "unknown", "unknown", ["JSON"]);
-      case "bitstring":
-      case "byteString":
-        return mapped("String", "string");
-      default:
-        break;
-    }
-    if (c.dbType === "VECTOR") return mapped("[Float!]", "number[]");
-    switch (c.tsType) {
-      case "number":
-        return mapped((0, import_validation_core16.isIntegerColumn)(c) && fitsInt32(c) ? "Int" : "Float", "number");
-      case "string":
-        return mapped(c.format === "uuid" ? "ID" : "String", "string");
-      case "boolean":
-        return mapped("Boolean", "boolean");
-      case "Date":
-        return mapped("DateTime", "Date", "Date", ["DateTime"]);
-      case "bigint":
-        return mapped("BigInt", "string | bigint", "string", ["BigInt"]);
-      default:
-        return {
-          ...mapped("JSON", "unknown", "unknown", ["JSON"]),
-          note: `No GraphQL type for column "${c.name}": DRZL could not derive one from the schema, so it is exposed through the JSON scalar and accepts any value there.`
-        };
-    }
-  })();
-  let { sdl, rowTs, inputTs } = base;
-  const dims = c.arrayDimensions ?? 0;
-  for (let i = 0; i < dims; i++) {
-    sdl = `[${sdl}]`;
-    rowTs = `(${rowTs} | null)[]`;
-    inputTs = `(${inputTs} | null)[]`;
-  }
-  return {
-    column: c,
-    field: field5,
-    renamed: field5 !== c.name,
-    sdl,
-    rowTs,
-    inputTs,
-    scalars: base.scalars,
-    enumPlan: base.enumPlan,
-    note: base.note
-  };
-}
-function planTable(table) {
-  const typeName3 = cap6(gqlIdent(table.tsName));
-  const fieldBase = gqlIdent(table.tsName);
-  const select = (0, import_validation_core16.selectColumns)(table).map((c) => planColumn(table, c));
-  const writable = !table.readOnly;
-  const insert = writable ? (0, import_validation_core16.insertColumns)(table).map((c) => planColumn(table, c)) : [];
-  const update = writable ? (0, import_validation_core16.updateColumns)(table).map((c) => planColumn(table, c)) : [];
-  const keyCols = keyColumns7(table);
-  const key = keyCols ? keyCols.map((c) => planColumn(table, c)) : null;
-  const scalars = /* @__PURE__ */ new Set();
-  const enums = [];
-  const notes = [];
-  for (const p of select) {
-    for (const s of p.scalars) scalars.add(s);
-    if (p.enumPlan) enums.push(p.enumPlan);
-    if (p.note) notes.push(p.note);
-  }
-  const createInput = `Create${typeName3}Input`;
-  const updateInput = `Update${typeName3}Input`;
-  const hasCreate = writable && insert.length > 0;
-  const hasUpdate = writable && key !== null && update.length > 0;
-  const keyArgsSdl = key ? key.map((p) => `${p.field}: ${p.sdl}!`).join(", ") : "";
-  const keyArgsTs = key ? key.map((p) => `${p.field}: ${p.inputTs}`).join("; ") : "";
-  const ops = [];
-  ops.push({
-    parent: "Query",
-    name: fieldBase,
-    argsSdl: "",
-    resultSdl: `[${typeName3}!]!`,
-    argsTs: "Record<string, never>",
-    resultTs: `${typeName3}[]`
-  });
-  if (key) {
-    ops.push({
-      parent: "Query",
-      name: `${fieldBase}ById`,
-      argsSdl: keyArgsSdl,
-      resultSdl: typeName3,
-      argsTs: `{ ${keyArgsTs} }`,
-      resultTs: `${typeName3} | null`
-    });
-  }
-  if (hasCreate) {
-    ops.push({
-      parent: "Mutation",
-      name: `create${typeName3}`,
-      argsSdl: `input: ${createInput}!`,
-      resultSdl: `${typeName3}!`,
-      argsTs: `{ input: ${createInput} }`,
-      resultTs: typeName3
-    });
-  }
-  if (hasUpdate) {
-    ops.push({
-      parent: "Mutation",
-      name: `update${typeName3}`,
-      argsSdl: `${keyArgsSdl}, input: ${updateInput}!`,
-      resultSdl: `${typeName3}!`,
-      argsTs: `{ ${keyArgsTs}; input: ${updateInput} }`,
-      resultTs: typeName3
-    });
-  }
-  if (writable && key) {
-    ops.push({
-      parent: "Mutation",
-      name: `delete${typeName3}`,
-      argsSdl: keyArgsSdl,
-      resultSdl: "Boolean!",
-      argsTs: `{ ${keyArgsTs} }`,
-      resultTs: "boolean"
-    });
-  }
-  const renamedSelect = select.filter((p) => p.renamed);
-  for (const p of renamedSelect) {
-    notes.push(
-      `Column "${p.column.name}" is not a valid GraphQL field name, so it is exposed as "${p.field}": output is mapped back by the emitted field resolver, and on inputs the value arrives under "${p.field}" for your resolver to write back.`
-    );
-  }
-  return {
-    table,
-    typeName: typeName3,
-    createInput,
-    updateInput,
-    select,
-    insert,
-    update,
-    key,
-    writable,
-    hasCreate,
-    hasUpdate,
-    ops,
-    scalars,
-    enums,
-    notes,
-    renamedSelect
-  };
-}
-function renderEnumSdl(plan) {
-  const lines = [`enum ${plan.typeName} {`];
-  for (const m of plan.members) {
-    if (m.renamed) lines.push(`  ${JSON.stringify(`Database value: ${m.value}`)}`);
-    lines.push(`  ${m.name}`);
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-function renderTypeSdl(plan) {
-  const parts = [];
-  for (const e of plan.enums) parts.push(renderEnumSdl(e));
-  parts.push(
-    [
-      `type ${plan.typeName} {`,
-      ...plan.select.map((p) => `  ${p.field}: ${p.sdl}${p.column.nullable ? "" : "!"}`),
-      "}"
-    ].join("\n")
-  );
-  if (plan.hasCreate) {
-    parts.push(
-      [
-        `input ${plan.createInput} {`,
-        ...plan.insert.map((p) => {
-          const required = !p.column.nullable && !p.column.hasDefault;
-          return `  ${p.field}: ${p.sdl}${required ? "!" : ""}`;
-        }),
-        "}"
-      ].join("\n")
-    );
-  }
-  if (plan.hasUpdate) {
-    parts.push(
-      [
-        `input ${plan.updateInput} {`,
-        ...plan.update.map((p) => `  ${p.field}: ${p.sdl}`),
-        "}"
-      ].join("\n")
-    );
-  }
-  return parts.join("\n\n");
-}
-function rowField(p) {
-  const key = isIdent6(p.column.name) ? p.column.name : q5(p.column.name);
-  return `  ${key}: ${p.rowTs}${p.column.nullable ? " | null" : ""};`;
-}
-function inputField(p, mode) {
-  const required = mode === "insert" && !p.column.nullable && !p.column.hasDefault;
-  return required ? `  ${p.field}: ${p.inputTs};` : `  ${p.field}?: ${p.inputTs} | null;`;
-}
-function renderResolvers(plan) {
-  const lines = ["{"];
-  const byParent = (parent) => plan.ops.filter((o) => o.parent === parent);
-  const renderOps = (parent) => {
-    lines.push(`  ${parent}: {`);
-    for (const op of byParent(parent)) {
-      lines.push(
-        `    ${op.name}: (_parent: unknown, _args: ${op.argsTs}): ${op.resultTs} => {`,
-        `      ${stubBody(parent, op.name)}`,
-        `    },`
-      );
-    }
-    lines.push("  },");
-  };
-  renderOps("Query");
-  if (byParent("Mutation").length) renderOps("Mutation");
-  for (const e of plan.enums) {
-    const mapped2 = e.members.filter((m) => m.renamed);
-    if (!mapped2.length) continue;
-    lines.push(
-      `  ${e.typeName}: { ${mapped2.map((m) => `${m.name}: ${q5(m.value)}`).join(", ")} },`
-    );
-  }
-  if (plan.renamedSelect.length) {
-    lines.push(`  ${plan.typeName}: {`);
-    for (const p of plan.renamedSelect) {
-      const type = `${p.rowTs}${p.column.nullable ? " | null" : ""}`;
-      lines.push(`    ${p.field}: (parent: ${plan.typeName}): ${type} => parent[${q5(p.column.name)}],`);
-    }
-    lines.push("  },");
-  }
-  lines.push("}");
-  return lines.join("\n");
-}
-function renderTable2(plan) {
-  const t = plan.table;
-  const declared = [];
-  declared.push(
-    `/** One ${t.name} row, as your resolvers return it: database values, database spellings. */`,
-    `export interface ${plan.typeName} {`,
-    ...plan.select.map(rowField),
-    "}"
-  );
-  if (plan.hasCreate) {
-    declared.push(
-      "",
-      `/** The create${plan.typeName} input, as GraphQL hands it to your resolver. */`,
-      `export interface ${plan.createInput} {`,
-      ...plan.insert.map((p) => inputField(p, "insert")),
-      "}"
-    );
-  }
-  if (plan.hasUpdate) {
-    declared.push(
-      "",
-      `/** The update${plan.typeName} patch: every field optional, primary key excluded. */`,
-      `export interface ${plan.updateInput} {`,
-      ...plan.update.map((p) => inputField(p, "update")),
-      "}"
-    );
-  }
-  const tsName = gqlIdent(t.tsName);
-  const notes = plan.notes.length ? plan.notes.map((n) => `// ${n.replace(/\n/g, " ")}`).join("\n") + "\n" : "";
-  return `// Generated by @drzl/generator-graphql
-// GraphQL SDL and resolver stubs for table: ${t.name}
-${notes}${declared.join("\n")}
-
-/** The SDL for this table's types. The Query and Mutation fields live in the barrel. */
-export const ${tsName}TypeDefs = \`${tpl(renderTypeSdl(plan))}\`;
-
-/** Stubs that throw until replaced, plus the enum value maps and field resolvers the schema needs. */
-export const ${tsName}Resolvers = ${renderResolvers(plan)};
-`;
-}
-function renderScalarsModule() {
-  return `// Generated by @drzl/generator-graphql
-// Dependency-free scalar configs for the resolvers map. Each hook is named twice because
-// graphql 17 renamed serialize/parseValue/parseLiteral to coerceOutputValue/coerceInputValue/
-// coerceInputLiteral, and the schema builder assigns whichever names the running graphql reads.
-
-/** The literal AST shape the literal hooks read, structurally, so nothing is imported. */
-export interface LiteralNode {
-  kind: string;
-  value?: unknown;
-  values?: LiteralNode[];
-  fields?: { name: { value: string }; value: LiteralNode }[];
-  name?: { value: string };
-}
-
-// Strict ISO 8601 datetime with seconds and an offset: new Date('1') is the year 2001.
-const ISO_DATETIME = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$/;
-
-const toIso = (value: unknown): string => {
-  if (value instanceof Date && !Number.isNaN(value.getTime())) return value.toISOString();
-  throw new Error('DateTime.serialize: expected a Date');
-};
-const fromIso = (value: unknown): Date => {
-  if (typeof value !== 'string' || !ISO_DATETIME.test(value)) {
-    throw new Error('DateTime: expected a strict ISO 8601 datetime string');
-  }
-  const parsed = new Date(value);
-  if (Number.isNaN(parsed.getTime())) throw new Error('DateTime: unreadable datetime string');
-  return parsed;
-};
-const fromIsoLiteral = (ast: LiteralNode): Date => {
-  if (ast.kind !== 'StringValue') throw new Error('DateTime: expected a string literal');
-  return fromIso(ast.value);
-};
-
-/** ISO 8601 datetime string in, real Date to the resolver, toISOString() out. */
-export const DateTimeScalar = {
-  name: 'DateTime',
-  description: 'A strict ISO 8601 datetime string, e.g. 2026-01-02T03:04:05.000Z.',
-  serialize: toIso,
-  parseValue: fromIso,
-  parseLiteral: fromIsoLiteral,
-  coerceOutputValue: toIso,
-  coerceInputValue: fromIso,
-  coerceInputLiteral: fromIsoLiteral,
-};
-
-const DIGITS = /^-?\\d+$/;
-
-const toDigits = (value: unknown): string => {
-  if (typeof value === 'bigint') return value.toString();
-  if (typeof value === 'string' && DIGITS.test(value)) return value;
-  throw new Error('BigInt.serialize: expected a bigint or a decimal digit string');
-};
-// Variables take the digit string only: a JSON number was already rounded by JSON.parse.
-const fromDigits = (value: unknown): string => {
-  if (typeof value !== 'string' || !DIGITS.test(value)) {
-    throw new Error('BigInt: expected a string of decimal digits');
-  }
-  return value;
-};
-// An inline integer literal is lossless: the AST carries its raw digits as a string.
-const fromDigitsLiteral = (ast: LiteralNode): string => {
-  if (ast.kind === 'IntValue') return String(ast.value);
-  if (ast.kind === 'StringValue' && typeof ast.value === 'string' && DIGITS.test(ast.value)) {
-    return ast.value;
-  }
-  throw new Error('BigInt: expected an integer literal or a string of decimal digits');
-};
-
-/** A 64-bit-safe integer crossing the wire as its decimal digits. */
-export const BigIntScalar = {
-  name: 'BigInt',
-  description: 'An arbitrary-precision integer as a string of decimal digits.',
-  serialize: toDigits,
-  parseValue: fromDigits,
-  parseLiteral: fromDigitsLiteral,
-  coerceOutputValue: toDigits,
-  coerceInputValue: fromDigits,
-  coerceInputLiteral: fromDigitsLiteral,
-};
-
-const identity = (value: unknown): unknown => value;
-const fromJSONLiteral = (ast: LiteralNode, variables?: Record<string, unknown> | null): unknown => {
-  switch (ast.kind) {
-    case 'StringValue':
-    case 'BooleanValue':
-    case 'EnumValue':
-      return ast.value;
-    case 'IntValue':
-    case 'FloatValue':
-      return Number(ast.value);
-    case 'NullValue':
-      return null;
-    case 'ListValue':
-      return (ast.values ?? []).map((v) => fromJSONLiteral(v, variables));
-    case 'ObjectValue': {
-      const out: Record<string, unknown> = {};
-      for (const f of ast.fields ?? []) out[f.name.value] = fromJSONLiteral(f.value, variables);
-      return out;
-    }
-    case 'Variable':
-      return variables ? variables[ast.name?.value ?? ''] : undefined;
-    default:
-      throw new Error('JSON: unsupported literal kind ' + ast.kind);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
 };
-
-/** Any JSON value, untouched on both value paths, rebuilt from the AST for inline literals. */
-export const JSONScalar = {
-  name: 'JSON',
-  description: 'Any JSON value, passed through as-is.',
-  serialize: identity,
-  parseValue: identity,
-  parseLiteral: fromJSONLiteral,
-  coerceOutputValue: identity,
-  coerceInputValue: identity,
-  coerceInputLiteral: fromJSONLiteral,
-};
-`;
-}
-function renderBarrel6(plans, modules, usedScalars, scalarsSpec) {
-  if (!plans.length) {
-    return `// Generated by @drzl/generator-graphql
-// No tables detected in analysis. Add tables to your schema and regenerate.
-// A GraphQL schema needs a Query type with at least one field, so no typeDefs are composed.
-export * from '${scalarsSpec}';
-
-export const typeDefs = '';
-
-export const resolvers = {};
-`;
-  }
-  const imports = [];
-  if (usedScalars.length) {
-    const names = usedScalars.map((s) => SCALAR_EXPORTS[s]).sort();
-    imports.push(`import { ${names.join(", ")} } from '${scalarsSpec}';`);
-  }
-  for (const plan of plans) {
-    const tsName = gqlIdent(plan.table.tsName);
-    imports.push(
-      `import { ${tsName}Resolvers, ${tsName}TypeDefs } from '${modules.get(plan)}';`
-    );
-  }
-  const reExports = [
-    `export * from '${scalarsSpec}';`,
-    ...plans.map((p) => `export * from '${modules.get(p)}';`)
-  ];
-  const queryLines = plans.flatMap(
-    (p) => p.ops.filter((o) => o.parent === "Query").map((o) => `  ${o.name}${o.argsSdl ? `(${o.argsSdl})` : ""}: ${o.resultSdl}`)
-  );
-  const mutationLines = plans.flatMap(
-    (p) => p.ops.filter((o) => o.parent === "Mutation").map((o) => `  ${o.name}(${o.argsSdl}): ${o.resultSdl}`)
-  );
-  const typeDefParts = [
-    ...usedScalars.map((s) => `'scalar ${s}'`),
-    ...plans.map((p) => `${gqlIdent(p.table.tsName)}TypeDefs`),
-    `\`${tpl(["type Query {", ...queryLines, "}"].join("\n"))}\``
-  ];
-  if (mutationLines.length) {
-    typeDefParts.push(`\`${tpl(["type Mutation {", ...mutationLines, "}"].join("\n"))}\``);
-  }
-  const resolverLines = ["export const resolvers = {"];
-  for (const s of usedScalars) resolverLines.push(`  ${s}: ${SCALAR_EXPORTS[s]},`);
-  for (const p of plans) {
-    const tsName = gqlIdent(p.table.tsName);
-    for (const e of p.enums) {
-      if (e.members.some((m) => m.renamed)) {
-        resolverLines.push(`  ${e.typeName}: ${tsName}Resolvers.${e.typeName},`);
-      }
-    }
-    if (p.renamedSelect.length) {
-      resolverLines.push(`  ${p.typeName}: ${tsName}Resolvers.${p.typeName},`);
-    }
-  }
-  resolverLines.push("  Query: {");
-  for (const p of plans) resolverLines.push(`    ...${gqlIdent(p.table.tsName)}Resolvers.Query,`);
-  resolverLines.push("  },");
-  const mutating = plans.filter((p) => p.ops.some((o) => o.parent === "Mutation"));
-  if (mutating.length) {
-    resolverLines.push("  Mutation: {");
-    for (const p of mutating) {
-      resolverLines.push(`    ...${gqlIdent(p.table.tsName)}Resolvers.Mutation,`);
-    }
-    resolverLines.push("  },");
-  }
-  resolverLines.push("};");
-  return `// Generated by @drzl/generator-graphql
-// The whole schema in one pair: hand typeDefs and resolvers to makeExecutableSchema,
-// createSchema (graphql-yoga) or new ApolloServer(...). Plain buildSchema(typeDefs) accepts
-// the SDL too, but takes no resolvers, so scalar and enum behaviour will not attach there.
-${imports.join("\n")}
-
-${reExports.join("\n")}
-
-/** The whole schema's SDL. */
-export const typeDefs = [
-${typeDefParts.map((p) => `  ${p},`).join("\n")}
-].join('\\n\\n');
-
-/** Everything merged. Override per field: { ...resolvers, Query: { ...resolvers.Query, users: yours } } */
-${resolverLines.join("\n")}
-`;
-}
-function buildHeader7(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";
-}
-function toCase6(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;
-}
-var import_validation_core15, import_validation_core16, APP_MODULE5, SCALARS_MODULE, GRAPHQL_NAME, RESERVED_ENUM_VALUES, INT32_MIN, INT32_MAX, cap6, isIdent6, q5, stubBody, SCALAR_EXPORTS, GraphQLGenerator, index_default7;
-var init_dist7 = __esm({
-  "../generator-graphql/dist/index.js"() {
-    "use strict";
-    import_validation_core15 = require("@drzl/validation-core");
-    import_validation_core16 = require("@drzl/validation-core");
-    APP_MODULE5 = "index";
-    SCALARS_MODULE = "scalars";
-    GRAPHQL_NAME = /^[_A-Za-z][_0-9A-Za-z]*$/;
-    RESERVED_ENUM_VALUES = /* @__PURE__ */ new Set(["true", "false", "null"]);
-    INT32_MIN = -2147483648n;
-    INT32_MAX = 2147483647n;
-    cap6 = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-    isIdent6 = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
-    q5 = (v) => `'${v.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-    stubBody = (parent, name) => `throw new Error('Not implemented: ${parent}.${name}. Replace this stub with your data layer.');`;
-    SCALAR_EXPORTS = {
-      DateTime: "DateTimeScalar",
-      BigInt: "BigIntScalar",
-      JSON: "JSONScalar"
-    };
-    GraphQLGenerator = class {
-      constructor(analysis) {
-        this.analysis = analysis;
-      }
-      async generate(opts) {
-        const fs6 = (0, import_validation_core15.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outputDir);
-        await fs6.mkdir(out, { recursive: true });
-        const files = [];
-        const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core16.formatCode)(
-            buildHeader7(opts.outputHeader) + content,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        };
-        const barrelPath = path9.join(out, `${APP_MODULE5}.ts`);
-        const scalarsPath = path9.join(out, `${SCALARS_MODULE}.ts`);
-        const plans = this.analysis.tables.map(planTable);
-        const modules = /* @__PURE__ */ new Map();
-        const total = plans.length;
-        let index = 0;
-        for (const plan of plans) {
-          const base = `${plan.table.tsName}${opts.naming?.routerSuffix ?? ""}`;
-          const filePath = path9.join(out, `${toCase6(base, opts.naming?.procedureCase)}.ts`);
-          if (filePath === barrelPath || filePath === scalarsPath) {
-            const which = filePath === barrelPath ? "the barrel" : "the scalars module";
-            throw new Error(
-              `@drzl/generator-graphql: the module for table "${plan.table.name}" would be written to ${filePath}, which is ${which} this generator also writes. Set naming.routerSuffix to move it out of the way.`
-            );
-          }
-          await write(filePath, renderTable2(plan));
-          modules.set(
-            plan,
-            (0, import_validation_core16.importSpecifier)("./" + path9.relative(out, filePath).replace(/\\/g, "/"), opts.importExtension)
-          );
-          index++;
-          opts.onProgress?.({ index, total, table: plan.table.name, filePath });
-        }
-        const usedScalars = ["DateTime", "BigInt", "JSON"].filter(
-          (s) => plans.some((p) => p.scalars.has(s))
-        );
-        const scalarsSpec = (0, import_validation_core16.importSpecifier)(`./${SCALARS_MODULE}.ts`, opts.importExtension);
-        await write(scalarsPath, renderScalarsModule());
-        await write(barrelPath, renderBarrel6(plans, modules, usedScalars, scalarsSpec));
-        return { files };
-      }
-    };
-    index_default7 = GraphQLGenerator;
-  }
-});
-
-// ../generator-effect/dist/index.js
-var dist_exports8 = {};
-__export(dist_exports8, {
-  EffectGenerator: () => EffectGenerator,
-  default: () => index_default8
-});
-function filter(expr, description) {
-  return `${NS}.filter((v) => ${expr}, { description: ${JSON.stringify(description)} })`;
-}
-function piped(base, steps) {
-  return steps.length ? `${base}.pipe(${steps.join(", ")})` : base;
-}
-function isUnknownExpr(expr) {
-  return expr === UNKNOWN_EXPR;
-}
-function withNarrowedType(expr, ref2) {
-  return `${expr} as unknown as ${NS}.Schema<${ref2}>`;
-}
-function numericBounds(c, checks) {
-  let lo = c.min !== void 0 ? { fn: "greaterThanOrEqualTo", value: c.min } : void 0;
-  let hi = c.max !== void 0 ? { fn: "lessThanOrEqualTo", value: c.max } : void 0;
-  for (const k of checks.filter((x) => x.column === c.name && x.kind === "number")) {
-    if (k.operator === ">=") lo = { fn: "greaterThanOrEqualTo", value: k.value };
-    else if (k.operator === ">") lo = { fn: "greaterThan", value: k.value };
-    else if (k.operator === "<=") hi = { fn: "lessThanOrEqualTo", value: k.value };
-    else if (k.operator === "<") hi = { fn: "lessThan", value: k.value };
-  }
-  return [lo, hi].filter(Boolean).map((x) => `${NS}.${x.fn}(${x.value})`);
-}
-function foldedIntoBounds(c, checks) {
-  if (c.arrayDimensions || c.shape) return /* @__PURE__ */ new Set();
-  if (c.tsType !== "number" && c.tsType !== "bigint") return /* @__PURE__ */ new Set();
-  return new Set(
-    checks.filter(
-      (k) => k.column === c.name && k.kind === "number" && k.operator !== "=" && k.operator !== "<>"
-    )
-  );
-}
-function nonFiniteBranches(c) {
-  const { nan, infinity } = (0, import_validation_core18.nonFiniteAccepted)(c);
-  return [
-    ...nan ? [`${NS}.Number.pipe(${filter("Number.isNaN(v)", "NaN, which this column stores")})`] : [],
-    ...infinity ? [`${NS}.Literal(Infinity, -Infinity)`] : []
-  ];
-}
-function withNonFinite(c, base) {
-  const branches = nonFiniteBranches(c);
-  return branches.length ? `${NS}.Union(${base}, ${branches.join(", ")})` : base;
-}
-function dateExpr(mode, coerceDates) {
-  const plain = `${NS}.ValidDateFromSelf`;
-  if (coerceDates === "none") return plain;
-  const fromString = piped(`${NS}.String`, [
-    `${NS}.pattern(new RegExp(${JSON.stringify(import_validation_core18.COERCIBLE_DATE_STRING)}))`,
-    filter((0, import_validation_core18.parsesToADate)("new Date(v)"), "a date the runtime can parse")
-  ]);
-  const fromNumber = piped(`${NS}.Number`, [
-    filter((0, import_validation_core18.parsesToADate)("new Date(v)"), "a date the runtime can parse")
-  ]);
-  const union = `${NS}.Union(${plain}, ${fromString}, ${fromNumber})`;
-  if (coerceDates === "all") return union;
-  return mode === "select" ? plain : union;
-}
-function capSteps(c, mode) {
-  const steps = [];
-  if (c.shape?.kind === "byteString") {
-    const n = c.shape.length;
-    if (!n) return steps;
-    return mode === "select" ? [filter(`${import_validation_core18.CODEPOINT_LENGTH} <= ${n}`, `at most ${n} characters`)] : [filter(`new TextEncoder().encode(v).length <= ${n}`, `at most ${n} bytes`)];
-  }
-  if (c.maxLength) {
-    steps.push(
-      filter(`${import_validation_core18.CODEPOINT_LENGTH} <= ${c.maxLength}`, `at most ${c.maxLength} characters`)
-    );
-  }
-  if (c.maxBytes) {
-    steps.push(
-      filter(`new TextEncoder().encode(v).length <= ${c.maxBytes}`, `at most ${c.maxBytes} bytes`)
-    );
-  }
-  return steps;
-}
-function lengthSteps(c, lengths) {
-  return lengths.filter((k) => k.column === c.name).flatMap((k) => {
-    const measure = (0, import_validation_core18.lengthMeasure)(c, k);
-    if (!measure) return [];
-    return [
-      filter(
-        `${(0, import_validation_core18.measureExpression)(measure, "v")} ${OPS[k.operator]} ${k.value}`,
-        (0, import_validation_core18.lengthCheckLabel)(k)
-      )
-    ];
-  });
-}
-function cardinalitySteps(c, cardinalities) {
-  if (!c.arrayDimensions) return [];
-  return cardinalities.filter((k) => k.column === c.name).map(
-    (k) => filter(
-      `v.length ${OPS[k.operator]} ${k.value}`,
-      `${k.name ? `${k.name}: ` : ""}cardinality(${c.name}) ${k.operator} ${k.value}`
-    )
-  );
-}
-function checkSteps(c, checks) {
-  if (c.arrayDimensions || c.shape) return [];
-  const folded2 = foldedIntoBounds(c, checks);
-  const numericWire = (0, import_validation_core18.comparisonWire)(c) === "numeric-string";
-  return checks.filter((k) => k.column === c.name && !folded2.has(k)).map((k) => {
-    const label = `${k.name ? `${k.name}: ` : ""}${c.name} ${k.operator} ${k.value}`;
-    if (numericWire) {
-      if (k.operator === "=" || k.operator === "<>") {
-        const canon = JSON.stringify((0, import_validation_core18.canonicalNumericText)(k.value));
-        const op = k.operator === "=" ? "===" : "!==";
-        return filter(`${import_validation_core18.NUMERIC_CANON_NAME}(v) ${op} ${canon}`, label);
-      }
-      return filter(`Number(v) ${OPS[k.operator]} ${k.value}`, label);
-    }
-    const literal = k.kind === "string" ? JSON.stringify(k.value) : (0, import_validation_core18.wireNumberLiteral)(c, k.value);
-    return filter(`v ${OPS[k.operator]} ${literal}`, label);
-  });
-}
-function hasNoRuntimeType(c) {
-  return c.tsType === "any" || c.shape?.kind === "custom" || c.shape?.kind === "json";
-}
-function shapeExpr(c, mode, replaced = false) {
-  const s = c.shape;
-  if (!s) return void 0;
-  switch (s.kind) {
-    case "json":
-      return replaced ? UNKNOWN_EXPR : JSON_CONST;
-    case "custom":
-      return UNKNOWN_EXPR;
-    case "buffer":
-      return `${NS}.Uint8ArrayFromSelf`;
-    case "tuple":
-      return `${NS}.Tuple(${Array.from({ length: s.length }, () => `${NS}.Number`).join(", ")})`;
-    case "numberObject":
-      return `${NS}.Struct({ ${s.fields.map((f) => `${f}: ${NS}.Number`).join(", ")} })`;
-    case "numberVector":
-      return piped(
-        `${NS}.Array(${NS}.Number)`,
-        s.length ? [filter(`v.length === ${s.length}`, `exactly ${s.length} elements`)] : []
-      );
-    case "bitstring":
-      return piped(`${NS}.String`, [
-        `${NS}.pattern(/^[01]*$/)`,
-        ...s.length ? [
-          s.exact ? filter(`v.length === ${s.length}`, `exactly ${s.length} binary digits`) : filter(`v.length <= ${s.length}`, `at most ${s.length} binary digits`)
-        ] : []
-      ]);
-    case "byteString":
-      return piped(`${NS}.String`, capSteps(c, mode));
-  }
-}
-function exprForColumn(c, mode, coerceDates, checks, sets, lengths, replaced) {
-  const shaped = shapeExpr(c, mode, replaced);
-  if (shaped) return piped(shaped, lengthSteps(c, lengths));
-  const set = sets.find((x) => x.column === c.name);
-  if (set) {
-    if ((0, import_validation_core18.comparisonWire)(c) === "numeric-string") {
-      const members = (0, import_validation_core18.canonicalMembers)(set.values);
-      const test = members.map((m) => `canon === ${JSON.stringify(m)}`).join(" || ");
-      return piped(`${NS}.String`, [
-        filter(`((canon) => ${test})(${import_validation_core18.NUMERIC_CANON_NAME}(v))`, (0, import_validation_core18.describeSet)(set))
-      ]);
-    }
-    const values = set.values.map(
-      (v) => set.kind === "string" ? JSON.stringify(v) : (0, import_validation_core18.wireNumberLiteral)(c, v)
-    );
-    return `${NS}.Literal(${values.join(", ")})`;
-  }
-  if (c.arrayDimensions) checks = [];
-  if (c.enumValues && c.enumValues.length) {
-    return `${NS}.Literal(${c.enumValues.map((v) => JSON.stringify(v)).join(", ")})`;
-  }
-  const eq = checks.find((k) => k.column === c.name && k.operator === "=");
-  if (eq && !c.shape && (0, import_validation_core18.comparisonWire)(c) !== "numeric-string") {
-    return `${NS}.Literal(${eq.kind === "string" ? JSON.stringify(eq.value) : (0, import_validation_core18.wireNumberLiteral)(c, eq.value)})`;
-  }
-  const rest = [...checkSteps(c, checks), ...lengthSteps(c, lengths)];
-  switch (c.tsType) {
-    case "string": {
-      const base = c.format === "uuid" ? `${NS}.UUID` : `${NS}.String`;
-      const pattern = c.format && c.format !== "uuid" && import_validation_core18.COLUMN_FORMATS[c.format] ? [`${NS}.pattern(new RegExp(${JSON.stringify(import_validation_core18.COLUMN_FORMATS[c.format])}))`] : [];
-      return piped(base, [...pattern, ...capSteps(c, mode), ...rest]);
-    }
-    case "number": {
-      const base = (0, import_validation_core18.isIntegerColumn)(c) ? `${NS}.Int` : `${NS}.Finite`;
-      return withNonFinite(c, piped(base, [...numericBounds(c, checks), ...rest]));
-    }
-    case "bigint":
-      return piped(`${NS}.BigIntFromSelf`, [
-        ...c.min !== void 0 ? [`${NS}.greaterThanOrEqualToBigInt(${c.min}n)`] : [],
-        ...c.max !== void 0 ? [`${NS}.lessThanOrEqualToBigInt(${c.max}n)`] : [],
-        ...rest
-      ]);
-    case "boolean":
-      return `${NS}.Boolean`;
-    case "Date":
-      return dateExpr(mode, coerceDates);
-    case "Uint8Array":
-      return `${NS}.Uint8ArrayFromSelf`;
-    case "any":
-      return UNKNOWN_EXPR;
-    default:
-      return UNKNOWN_EXPR;
-  }
-}
-function renderField(c, mode, coerceDates, checks, sets, lengths, cardinalities, applyDefault, narrowRef, brand) {
-  let expr = exprForColumn(
-    c,
-    mode,
-    coerceDates,
-    checks,
-    sets,
-    lengths,
-    !!narrowRef && hasNoRuntimeType(c)
-  );
-  const dims = c.arrayDimensions ?? 0;
-  for (let i = 0; i < dims; i++) {
-    expr = `${NS}.Array(${expr})`;
-    if (i === dims - 1) expr = piped(expr, cardinalitySteps(c, cardinalities));
-  }
-  if (brand) expr = piped(expr, [`${NS}.brand(${JSON.stringify(brand)})`]);
-  if (c.nullable && !isUnknownExpr(expr)) expr = `${NS}.NullOr(${expr})`;
-  if (narrowRef && !brand) expr = withNarrowedType(expr, narrowRef);
-  if (mode === "select") return expr;
-  const wantsDefault = mode === "insert" && applyDefault && c.defaultValue !== void 0;
-  if (wantsDefault) {
-    return `${NS}.optionalWith(${expr}, { default: () => ${JSON.stringify(c.defaultValue)} })`;
-  }
-  if (mode === "update" || c.nullable || c.hasDefault) return `${NS}.optional(${expr})`;
-  return expr;
-}
-function wantsRef(c, allColumns2) {
-  return allColumns2 || hasNoRuntimeType(c);
-}
-function renderObjectShape(cols, mode, coerceDates, checks, sets, lengths, cardinalities, typedJson, applyDefaults, brands) {
-  return cols.map((c) => {
-    const ref2 = typedJson && wantsRef(c, !!typedJson.allColumns) ? `(typeof ${typedJson.table}.$infer${typedJson.mode === "insert" ? "Insert" : "Select"})[${JSON.stringify(c.name)}]` : void 0;
-    const field5 = renderField(
-      c,
-      mode,
-      coerceDates,
-      checks,
-      sets,
-      lengths,
-      cardinalities,
-      applyDefaults,
-      ref2,
-      brands?.plan.brandOf(brands.tsName, c.name)
-    );
-    return `  ${JSON.stringify(c.name)}: ${field5},`;
-  }).join("\n");
-}
-function rowSteps(rows, cols) {
-  const present = new Set(cols.map((c) => c.name));
-  return rows.filter((r) => present.has(r.left) && present.has(r.right)).map((r) => {
-    const l = `o[${JSON.stringify(r.left)}]`;
-    const rt = `o[${JSON.stringify(r.right)}]`;
-    const msg = `${r.name ? `${r.name}: ` : ""}${r.left} ${r.operator} ${r.right}`;
-    return `${NS}.filter((o) => ${l} == null || ${rt} == null || ${l} ${OPS[r.operator]} ${rt}, { description: ${JSON.stringify(msg)} })`;
-  });
-}
-function indentBlock(code, by = "  ") {
-  return code.split("\n").map((line) => line ? by + line : line).join("\n");
-}
-function parsedChecksFor(table) {
-  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core18.parseCheck)(k.expression, k.name));
-  const { checks, sets } = (0, import_validation_core18.applyWirePolicy)(
-    table.columns,
-    parsed.flatMap((p) => p.ok ? p.checks : []),
-    parsed.flatMap((p) => p.ok ? p.sets ?? [] : [])
-  );
-  return {
-    checks,
-    sets,
-    rows: parsed.flatMap((p) => p.ok ? p.rows ?? [] : []),
-    lengths: parsed.flatMap((p) => p.ok ? p.lengths ?? [] : []),
-    cardinalities: parsed.flatMap((p) => p.ok ? p.cardinalities ?? [] : [])
-  };
-}
-function nestedNodeCols(node, mode) {
-  const all = mode === "insert" ? (0, import_validation_core18.insertColumns)(node.table) : (0, import_validation_core18.selectColumns)(node.table);
-  return (0, import_validation_core18.nestedNodeColumns)(all, node);
-}
-function nestedNodes(node, into = []) {
-  into.push(node);
-  for (const arm of node.arms) nestedNodes(arm.child, into);
-  return into;
-}
-function renderNestedObject(node, mode, coerceDates, typedJson, applyDefaults, brands) {
-  const cols = nestedNodeCols(node, mode);
-  const { checks, sets, rows, lengths, cardinalities } = parsedChecksFor(node.table);
-  const tj = typedJson ? { table: node.table.tsName, mode, allColumns: typedJson.allColumns } : void 0;
-  const fields = renderObjectShape(
-    cols,
-    mode,
-    coerceDates,
-    checks,
-    sets,
-    lengths,
-    cardinalities,
-    tj,
-    applyDefaults,
-    brands ? { plan: brands, tsName: node.table.tsName } : void 0
-  );
-  const arms = node.arms.map((arm) => {
-    const notes = (0, import_validation_core18.nestedArmNotes)(arm).map((n) => `  // ${n}
-`).join("");
-    const child = renderNestedObject(
-      arm.child,
-      mode,
-      coerceDates,
-      typedJson,
-      applyDefaults,
-      brands
-    );
-    const inner = arm.single ? `${NS}.NullOr(
-${indentBlock(indentBlock(child))}
-  )` : `${NS}.Array(
-${indentBlock(indentBlock(child))}
-  )`;
-    return `${notes}  ${JSON.stringify(arm.key)}: ${NS}.optional(${inner}),`;
-  });
-  const body = [fields, ...arms].filter(Boolean).join("\n");
-  return piped(`${NS}.Struct({
-${body}
-})`, rowSteps(rows, cols));
-}
-function renderNestedSchemas(table, affix, coerceDates, typedJson, applyDefaults, plans, brands) {
-  const out = [];
-  for (const mode of ["insert", "select"]) {
-    const plan = plans[mode];
-    if (!plan) continue;
-    const name = (0, import_validation_core18.nestedSchemaName)(mode, table.tsName, affix);
-    const tname = (0, import_validation_core18.nestedTypeName)(mode, table.tsName, affix);
-    const expr = renderNestedObject(plan, mode, coerceDates, typedJson, applyDefaults, brands);
-    out.push(
-      `export const ${name} = ${expr};
-
-export type ${tname} = ${NS}.Schema.Type<typeof ${name}>;
-
-export const ${STANDARD_PREFIX}${name} = ${NS}.standardSchemaV1(${name});`
-    );
-  }
-  return out.length ? `
-${out.join("\n\n")}
-` : "";
-}
-function nestedPlansFor(table, analysis, depth) {
-  const out = {};
-  for (const mode of ["insert", "select"]) {
-    if (mode === "insert" && table.readOnly) continue;
-    const plan = (0, import_validation_core18.buildNestedPlan)(table, analysis.tables, analysis.relations ?? [], mode, depth);
-    if (plan) out[mode] = plan;
-  }
-  return out;
-}
-function renderTableSchemas(table, affix, coerceDates, typedJson, applyDefaults = false, wantsDuplicateFinder = false, nested = {}, brands) {
-  const T = table.tsName;
-  const insertCols = (0, import_validation_core18.insertColumns)(table);
-  const updateCols = (0, import_validation_core18.updateColumns)(table);
-  const selectCols = (0, import_validation_core18.selectColumns)(table);
-  const { checks, sets, rows, lengths, cardinalities } = parsedChecksFor(table);
-  const tj = typedJson ? { table: T, allColumns: typedJson.allColumns } : void 0;
-  const modes = [
-    ["insert", insertCols],
-    ["update", updateCols],
-    ["select", selectCols]
-  ];
-  const blocks = modes.map(([mode, cols]) => {
-    const name = (0, import_validation_core18.schemaName)(mode, T, affix);
-    const tname = (0, import_validation_core18.typeName)(mode, T, affix);
-    const body = renderObjectShape(
-      cols,
-      mode,
-      coerceDates,
-      checks,
-      sets,
-      lengths,
-      cardinalities,
-      // The update schema references the insert-side inferred types: both describe a value going
-      // in, and `$inferSelect` would name the post-default type for a column a write may omit.
-      tj ? { ...tj, mode: mode === "select" ? "select" : "insert" } : void 0,
-      applyDefaults,
-      brands ? { plan: brands, tsName: T } : void 0
-    );
-    const expr = piped(`${NS}.Struct({
-${body}
-})`, rowSteps(rows, cols));
-    return `export const ${name} = ${expr};
-
-export type ${tname} = ${NS}.Schema.Type<typeof ${name}>;
-
-export const ${STANDARD_PREFIX}${name} = ${NS}.standardSchemaV1(${name});`;
-  });
-  const nestedByTable = ["insert", "select"].flatMap((m) => {
-    const plan = nested[m];
-    return plan ? nestedNodes(plan).map((n) => [n.table.tsName, nestedNodeCols(n, m)]) : [];
-  });
-  const nestedCols = nestedByTable.flatMap(([, cs]) => cs);
-  const referenced = /* @__PURE__ */ new Set();
-  if (typedJson) {
-    const all = !!typedJson.allColumns;
-    if ([...insertCols, ...updateCols, ...selectCols].some((c) => wantsRef(c, all))) {
-      referenced.add(T);
-    }
-    for (const [name, cs] of nestedByTable) {
-      if (cs.some((c) => wantsRef(c, all))) referenced.add(name);
-    }
-  }
-  const schemaImport = referenced.size ? `import type { ${[...referenced].join(", ")} } from '${typedJson.schemaSpecifier}';
-` : "";
-  const needsJson = !typedJson && [...insertCols, ...updateCols, ...selectCols, ...nestedCols].some(
-    (c) => c.shape?.kind === "json"
-  );
-  const finder = wantsDuplicateFinder ? (0, import_validation_core18.renderDuplicateFinder)(table, `findDuplicate${T}`, (0, import_validation_core18.typeName)("insert", T, affix)) : void 0;
-  const duplicates = finder ? `
-${finder}
-` : "";
-  const nestedCode = renderNestedSchemas(
-    table,
-    affix,
-    coerceDates,
-    typedJson,
-    applyDefaults,
-    nested,
-    brands
-  );
-  const selectName = (0, import_validation_core18.schemaName)("select", T, affix);
-  const brandAliases = (brands?.aliasesFor(T) ?? []).map(
-    (a) => `/** The nominal type of ${T}.${a.column}. */
-export type ${a.alias} = ${NS}.Schema.Type<typeof ${selectName}>[${JSON.stringify(a.column)}];`
-  ).join("\n\n");
-  const brandCode = brandAliases ? `
-${brandAliases}
-` : "";
-  const involved = [
-    table,
-    ...["insert", "select"].flatMap((m) => {
-      const plan = nested[m];
-      return plan ? nestedNodes(plan).map((n) => n.table) : [];
-    })
-  ];
-  const canonPreamble = involved.some((t) => {
-    const own = parsedChecksFor(t);
-    return (0, import_validation_core18.needsNumericCanon)(t.columns, own.checks, own.sets);
-  }) ? `
-${import_validation_core18.NUMERIC_CANON_SOURCE}` : "";
-  return `import * as ${NS} from 'effect/Schema';
-${schemaImport}${needsJson ? `
-${JSON_PREAMBLE}` : ""}${canonPreamble}
-${blocks.join("\n\n")}
-${brandCode}${nestedCode}${duplicates}`;
-}
-function buildHeader8(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_core17, import_validation_core18, DEFAULT_FILE_SUFFIX2, STANDARD_PREFIX, NS, OPS, JSON_CONST, JSON_PREAMBLE, UNKNOWN_EXPR, EffectGenerator, index_default8;
-var init_dist8 = __esm({
-  "../generator-effect/dist/index.js"() {
-    "use strict";
-    import_validation_core17 = require("@drzl/validation-core");
-    import_validation_core18 = require("@drzl/validation-core");
-    DEFAULT_FILE_SUFFIX2 = ".effect.ts";
-    STANDARD_PREFIX = "Standard";
-    NS = "Schema";
-    OPS = {
-      ">=": ">=",
-      ">": ">",
-      "<=": "<=",
-      "<": "<",
-      "=": "===",
-      "<>": "!=="
-    };
-    JSON_CONST = "DrzlJsonValue";
-    JSON_PREAMBLE = `type ${JSON_CONST}Type =
-  | string
-  | number
-  | boolean
-  | null
-  | readonly ${JSON_CONST}Type[]
-  | { readonly [key: string]: ${JSON_CONST}Type };
-
-const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(() =>
-  ${NS}.Union(
-    ${NS}.String,
-    ${NS}.Finite,
-    ${NS}.Boolean,
-    ${NS}.Null,
-    ${NS}.Array(${JSON_CONST}),
-    // The plain-object test comes before the record, not after it. \`Schema.Record\` rebuilds its
-    // output, so a check placed after it inspects that new object and reports every input as
-    // plain. A Date sailed through: it has no own enumerable keys, so the record accepted it and
-    // rebuilt it as \`{}\`.
-    ${NS}.Unknown.pipe(
-      ${NS}.filter(
-        (o) => {
-          if (typeof o !== 'object' || o === null || Array.isArray(o)) return false;
-          const p = Object.getPrototypeOf(o);
-          return p === Object.prototype || p === null;
-        },
-        { description: 'a plain object' }
-      ),
-      ${NS}.compose(${NS}.Record({ key: ${NS}.String, value: ${JSON_CONST} }), { strict: false })
-    )
-  )
-);
-`;
-    UNKNOWN_EXPR = `${NS}.Unknown`;
-    EffectGenerator = class {
-      constructor(analysis) {
-        this.analysis = analysis;
-        this.library = "effect";
-      }
-      async generate(opts) {
-        const fs6 = (0, import_validation_core17.fileWriter)(opts.fileSink);
-        const path9 = await import("path");
-        const out = path9.resolve(process.cwd(), opts.outDir);
-        const files = [];
-        await fs6.mkdir(out, { recursive: true });
-        const affix = (0, import_validation_core18.resolveAffix)(opts);
-        const coerceDates = opts.coerceDates ?? "input";
-        const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX2;
-        const wantsTypes = opts.typedJson || opts.typedColumns;
-        const typedJson = wantsTypes && opts.schemaPath ? {
-          schemaSpecifier: (0, import_validation_core18.resolveConfiguredImport)(
-            opts.schemaPath,
-            out,
-            process.cwd(),
-            opts.importExtension
-          ),
-          allColumns: !!opts.typedColumns
-        } : void 0;
-        if (wantsTypes && !opts.schemaPath) {
-          console.warn(
-            "[drzl] typedJson was requested but the schema path is unknown, so json columns keep their wide type."
-          );
-        }
-        const nestedDepth = opts.nestedSchemas ? (0, import_validation_core18.resolveNestedDepth)(opts.nestedDepth, (m) => console.warn(m)) : 0;
-        const brands = (0, import_validation_core18.buildBrandPlan)(this.analysis.tables, opts.branded);
-        for (const note of brands?.notes ?? []) console.warn(`[drzl] ${note}`);
-        for (const table of this.analysis.tables) {
-          const filePath = path9.join(out, (0, import_validation_core18.moduleFileName)(table.tsName, fileSuffix));
-          const code = renderTableSchemas(
-            table,
-            affix,
-            coerceDates,
-            typedJson,
-            !!opts.applyDefaults,
-            !!opts?.duplicateFinder,
-            opts.nestedSchemas ? nestedPlansFor(table, this.analysis, nestedDepth) : {},
-            brands
-          );
-          const formatted = await (0, import_validation_core18.formatCode)(
-            buildHeader8(opts.outputHeader) + code,
-            filePath,
-            opts.format
-          );
-          await fs6.writeFile(filePath, formatted, "utf8");
-          files.push(filePath);
-        }
-        const indexPath = path9.join(out, "index.ts");
-        const indexFormatted = await (0, import_validation_core18.formatCode)(
-          buildHeader8(opts.outputHeader) + this.defaultIndex(this.analysis, opts),
-          indexPath,
-          opts.format
-        );
-        await fs6.writeFile(indexPath, indexFormatted, "utf8");
-        files.push(indexPath);
-        return files;
-      }
-      renderTable(table, opts) {
-        return renderTableSchemas(
-          table,
-          (0, import_validation_core18.resolveAffix)(opts),
-          opts?.coerceDates ?? "input",
-          void 0,
-          !!opts?.applyDefaults,
-          !!opts?.duplicateFinder,
-          {},
-          (0, import_validation_core18.buildBrandPlan)(this.analysis.tables, opts?.branded)
-        );
-      }
-      defaultIndex(analysis, opts) {
-        const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX2;
-        return analysis.tables.map(
-          (t) => `export * from '${(0, import_validation_core18.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
-        ).join("\n") + "\n";
-      }
-    };
-    index_default8 = EffectGenerator;
-  }
-});
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/cli.ts
-var import_analyzer4 = require("@drzl/analyzer");
+var import_analyzer3 = require("@drzl/analyzer");
 var import_chokidar = __toESM(require("chokidar"), 1);
 var import_commander = require("commander");
 var path8 = __toESM(require("path"), 1);
@@ -5677,14 +1404,20 @@ var GENERATORS = [
   },
   {
     kind: "trpc",
-    // An optional dependency, like seven others below. A package that has never been published
-    // cannot publish through npm's trusted-publisher OIDC flow, so its first version has to go out
-    // by hand, and naming it as a hard dependency of the CLI in the same release breaks
-    // `npm i @drzl/cli` for everyone until it exists. A missing optional dependency is skipped by
-    // the installer rather than failing it, which is why these really can be absent on an ordinary
-    // install, and why `loadGenerator` tells absence apart from failure.
+    // This one and seven others were `optionalDependencies` until every one of them had been
+    // published: a package that has never existed cannot publish through npm's trusted-publisher
+    // OIDC flow, so its first version goes out by hand, and naming it as a hard dependency in the
+    // same release breaks `npm i @drzl/cli` for everyone until it does exist. An optional
+    // dependency is skipped by the installer instead, which made that release safe.
+    //
+    // The side effect was invisible and lasted longer than the reason: tsup externalises
+    // `dependencies` and `peerDependencies` and bundles everything else, so those eight travelled
+    // inside `dist` while the other six were resolved from `node_modules`. All fourteen are on the
+    // registry now and all fourteen are `dependencies`, which is what makes every one of them a
+    // package that can genuinely be absent, and `loadGenerator` tell absence apart from failure
+    // for every kind rather than for six of them.
     specifier: "@drzl/generator-trpc",
-    load: () => Promise.resolve().then(() => (init_dist(), dist_exports)),
+    load: () => import("@drzl/generator-trpc"),
     construct: (m, analysis) => new m.TRPCGenerator(analysis),
     outputDir: (g, cfg) => trpcOutDir(g, cfg),
     options: (g, cfg, ctx) => trpcOptions(g, cfg, ctx.servicesDir)
@@ -5692,7 +1425,7 @@ var GENERATORS = [
   {
     kind: "hono",
     specifier: "@drzl/generator-hono",
-    load: () => Promise.resolve().then(() => (init_dist2(), dist_exports2)),
+    load: () => import("@drzl/generator-hono"),
     construct: (m, analysis) => new m.HonoGenerator(analysis),
     outputDir: (g, cfg) => honoOutDir(g, cfg),
     options: (g, cfg) => honoOptions(g, cfg)
@@ -5700,7 +1433,7 @@ var GENERATORS = [
   {
     kind: "express",
     specifier: "@drzl/generator-express",
-    load: () => Promise.resolve().then(() => (init_dist3(), dist_exports3)),
+    load: () => import("@drzl/generator-express"),
     construct: (m, analysis) => new m.ExpressGenerator(analysis),
     outputDir: (g, cfg) => expressOutDir(g, cfg),
     options: (g, cfg) => expressOptions(g, cfg)
@@ -5708,7 +1441,7 @@ var GENERATORS = [
   {
     kind: "fastify",
     specifier: "@drzl/generator-fastify",
-    load: () => Promise.resolve().then(() => (init_dist5(), dist_exports5)),
+    load: () => import("@drzl/generator-fastify"),
     construct: (m, analysis) => new m.FastifyGenerator(analysis),
     outputDir: (g, cfg) => fastifyOutDir(g, cfg),
     options: (g, cfg) => fastifyOptions(g, cfg)
@@ -5716,7 +1449,7 @@ var GENERATORS = [
   {
     kind: "nestjs",
     specifier: "@drzl/generator-nestjs",
-    load: () => Promise.resolve().then(() => (init_dist6(), dist_exports6)),
+    load: () => import("@drzl/generator-nestjs"),
     construct: (m, analysis) => new m.NestJSGenerator(analysis),
     outputDir: (g, cfg) => nestjsOutDir(g, cfg),
     options: (g, cfg) => nestjsOptions(g, cfg)
@@ -5724,7 +1457,7 @@ var GENERATORS = [
   {
     kind: "graphql",
     specifier: "@drzl/generator-graphql",
-    load: () => Promise.resolve().then(() => (init_dist7(), dist_exports7)),
+    load: () => import("@drzl/generator-graphql"),
     construct: (m, analysis) => new m.GraphQLGenerator(analysis),
     outputDir: (g, cfg) => graphqlOutDir(g, cfg),
     options: (g, cfg) => graphqlOptions(g, cfg)
@@ -5778,7 +1511,7 @@ var GENERATORS = [
   {
     kind: "effect",
     specifier: "@drzl/generator-effect",
-    load: () => Promise.resolve().then(() => (init_dist8(), dist_exports8)),
+    load: () => import("@drzl/generator-effect"),
     construct: (m, analysis) => new m.EffectGenerator(analysis),
     outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS.effect,
     options: (g, cfg, ctx) => validationOptions(g, cfg, ctx.outDir, { schemaTypes: true })
@@ -5786,7 +1519,7 @@ var GENERATORS = [
   {
     kind: "json-schema",
     specifier: "@drzl/generator-json-schema",
-    load: () => Promise.resolve().then(() => (init_dist4(), dist_exports4)),
+    load: () => import("@drzl/generator-json-schema"),
     construct: (m, analysis) => new m.JsonSchemaGenerator(analysis),
     outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS["json-schema"],
     options: (g, cfg, ctx) => jsonSchemaOptions(g, cfg, ctx.outDir)
@@ -5968,10 +1701,10 @@ function nothingToGenerate(opts) {
 }
 
 // src/column-filter.ts
-var import_validation_core20 = require("@drzl/validation-core");
+var import_validation_core3 = require("@drzl/validation-core");
 
 // src/doctor.ts
-var import_validation_core19 = require("@drzl/validation-core");
+var import_validation_core2 = require("@drzl/validation-core");
 var import_chalk2 = require("chalk");
 var PLAIN = new import_chalk2.Chalk({ level: 0 });
 var HANDLED_CODES = /* @__PURE__ */ new Set(["DRZL_ANL_UNKNOWN_COLUMN"]);
@@ -6036,7 +1769,7 @@ function checkFindings(table) {
     const label = k.name ? `"${k.name}"` : "an unnamed constraint";
     const raw = k.expression ?? "";
     const expr = raw.trim() ? raw : "(empty)";
-    const parsed = (0, import_validation_core19.parseCheck)(raw, k.name);
+    const parsed = (0, import_validation_core2.parseCheck)(raw, k.name);
     if (!parsed.ok) {
       out.push({
         kind: "check-declined",
@@ -6061,7 +1794,7 @@ function checkFindings(table) {
     }
     for (const l of parsed.lengths ?? []) {
       const col = byName.get(l.column);
-      if (!col || (0, import_validation_core19.lengthMeasure)(col, l)) continue;
+      if (!col || (0, import_validation_core2.lengthMeasure)(col, l)) continue;
       out.push({
         kind: "check-uncountable",
         level: "warn",
@@ -6270,7 +2003,7 @@ function renderDoctorReport(report, style = PLAIN) {
 
 // src/column-filter.ts
 function checkedColumns(expression, name) {
-  const parsed = (0, import_validation_core20.parseCheck)(expression, name);
+  const parsed = (0, import_validation_core3.parseCheck)(expression, name);
   if (!parsed.ok) return [];
   return [...new Set(namedColumns(parsed).map((n) => n.column))];
 }
@@ -6362,8 +2095,8 @@ function filterColumns(tables, spec) {
 }
 
 // src/explain.ts
-var import_analyzer2 = require("@drzl/analyzer");
-var import_validation_core21 = require("@drzl/validation-core");
+var import_analyzer = require("@drzl/analyzer");
+var import_validation_core4 = require("@drzl/validation-core");
 var import_chalk3 = require("chalk");
 var PLAIN2 = new import_chalk3.Chalk({ level: 0 });
 function namesOf(table) {
@@ -6555,8 +2288,8 @@ function gapsFor(table, constraints, issues) {
 }
 function explainTable(analysis, match, options = {}) {
   const table = match.table;
-  const qualified = (0, import_analyzer2.qualifiedTableName)(table);
-  const constraints = (0, import_validation_core21.tableConstraints)(table).constraints;
+  const qualified = (0, import_analyzer.qualifiedTableName)(table);
+  const constraints = (0, import_validation_core4.tableConstraints)(table).constraints;
   const capped = new Set(
     constraints.filter((c) => c.kind === "maxLength" || c.kind === "maxBytes").flatMap((c) => c.columns)
   );
@@ -6588,11 +2321,11 @@ function explainTable(analysis, match, options = {}) {
     })
   }));
   const relations = analysis.relations.filter((r) => r.from === qualified || r.to === qualified || r.via === qualified).map((r) => ({ ...r, outgoing: r.from === qualified }));
-  const keyColumns8 = table.columns.filter((c) => primaryKeyColumns.has(c.name));
+  const keyColumns = table.columns.filter((c) => primaryKeyColumns.has(c.name));
   const primaryKey = table.primaryKey?.columns.length ? {
     ...table.primaryKey.name ? { name: table.primaryKey.name } : {},
     columns: [...table.primaryKey.columns],
-    generated: keyColumns8.length > 0 && keyColumns8.every((c) => c.isGenerated || c.hasDefault)
+    generated: keyColumns.length > 0 && keyColumns.every((c) => c.isGenerated || c.hasDefault)
   } : null;
   const removed = options.keptColumns ? table.columns.map((c) => c.name).filter((name) => !options.keptColumns.includes(name)) : [];
   return {
@@ -6619,7 +2352,7 @@ function explainTable(analysis, match, options = {}) {
     foreignKeys: (table.foreignKeys ?? []).map((fk) => ({
       ...fk.name ? { name: fk.name } : {},
       columns: [...fk.columns],
-      references: { table: (0, import_analyzer2.qualifiedForeignTable)(fk), columns: [...fk.foreignColumns] },
+      references: { table: (0, import_analyzer.qualifiedForeignTable)(fk), columns: [...fk.foreignColumns] },
       ...fk.onDelete ? { onDelete: fk.onDelete } : {},
       ...fk.onUpdate ? { onUpdate: fk.onUpdate } : {}
     })),
@@ -6633,10 +2366,10 @@ function summarize(analysis) {
     name: table.name,
     tsName: table.tsName,
     ...table.schema ? { schema: table.schema } : {},
-    qualified: (0, import_analyzer2.qualifiedTableName)(table),
+    qualified: (0, import_analyzer.qualifiedTableName)(table),
     columns: table.columns.length,
     checks: table.checks?.length ?? 0,
-    gaps: gapsFor(table, (0, import_validation_core21.tableConstraints)(table).constraints, analysis.issues).length
+    gaps: gapsFor(table, (0, import_validation_core4.tableConstraints)(table).constraints, analysis.issues).length
   }));
 }
 var WIDTH = 80;
@@ -6685,14 +2418,14 @@ function renderExplanation(explanation, context, style = PLAIN2) {
   const out = [];
   const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
   out.push(style.bold(explanation.qualified) + style.dim(`  ${context.schema}`));
-  const identity2 = [
+  const identity = [
     context.dialect,
     `table "${explanation.name}"`,
     `export "${explanation.tsName}"`,
     plural(explanation.columns.length, "column")
   ];
-  if (explanation.readOnly) identity2.push("read-only, so no insert or update schema is emitted");
-  out.push(style.dim("  " + identity2.join(", ")));
+  if (explanation.readOnly) identity.push("read-only, so no insert or update schema is emitted");
+  out.push(style.dim("  " + identity.join(", ")));
   if (!explanation.matchedExactly) {
     out.push(style.dim(`  matched on ${MATCH_LABELS[explanation.matchedOn]}, ignoring case`));
   }
@@ -7075,7 +2808,7 @@ var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
 async function snapshotDir(dir) {
   const out = /* @__PURE__ */ new Map();
-  async function walk2(current) {
+  async function walk(current) {
     let entries;
     try {
       entries = await import_node_fs.promises.readdir(current, { withFileTypes: true });
@@ -7084,11 +2817,11 @@ async function snapshotDir(dir) {
     }
     for (const e of entries) {
       const full = import_node_path.default.join(current, e.name);
-      if (e.isDirectory()) await walk2(full);
+      if (e.isDirectory()) await walk(full);
       else out.set(import_node_path.default.relative(dir, full), await import_node_fs.promises.readFile(full, "utf8"));
     }
   }
-  await walk2(dir);
+  await walk(dir);
   return out;
 }
 async function snapshotAll(dirs) {
@@ -7450,7 +3183,7 @@ function createRebuildScheduler(options) {
 }
 
 // src/init.ts
-var import_analyzer3 = require("@drzl/analyzer");
+var import_analyzer2 = require("@drzl/analyzer");
 var fs5 = __toESM(require("fs"), 1);
 var path5 = __toESM(require("path"), 1);
 var INIT_GENERATOR_CHOICES = [
@@ -7489,7 +3222,7 @@ function schemaCandidates() {
 async function classifySchemaCandidate(target) {
   let analysis;
   try {
-    analysis = await new import_analyzer3.SchemaAnalyzer(target).analyze({
+    analysis = await new import_analyzer2.SchemaAnalyzer(target).analyze({
       includeRelations: false,
       validateConstraints: false
     });
@@ -7692,7 +3425,7 @@ function normalizeGenerators(kinds) {
   for (const k of kinds) {
     if (!known.has(k)) {
       throw new Error(
-        `drzl init: "${k}" is not a generator init can scaffold. Choose from ${[...known].join(", ")}. Every other kind is documented in drzl.config; the route generators are optional dependencies and may not be installed.`
+        `drzl init: "${k}" is not a generator init can scaffold. Choose from ${[...known].join(", ")}. Every other kind is installed and works; add it to drzl.config by hand, following the entry for it in the docs.`
       );
     }
   }
@@ -7952,7 +3685,7 @@ withOutputFlags(
 ).action(async (schema, opts) => {
   const out = outputFor(opts);
   try {
-    const analyzer = new import_analyzer4.SchemaAnalyzer(schema);
+    const analyzer = new import_analyzer3.SchemaAnalyzer(schema);
     const spinner = out.spinner("Analyzing schema...");
     const start = Date.now();
     const res = await analyzer.analyze({
@@ -8003,7 +3736,7 @@ withOutputFlags(
         process.exit(EXIT_FAILED);
         return;
       }
-      const analyzer = new import_analyzer4.SchemaAnalyzer(target);
+      const analyzer = new import_analyzer3.SchemaAnalyzer(target);
       const analysis = await analyzer.analyze({
         includeRelations: true,
         validateConstraints: true
@@ -8080,7 +3813,7 @@ withOutputFlags(
     }
     if (source.note) out.note(out.errStyle.gray(source.note));
     const spinner = out.spinner("Reading the schema...");
-    const analysis = await new import_analyzer4.SchemaAnalyzer(source.schema).analyze({
+    const analysis = await new import_analyzer3.SchemaAnalyzer(source.schema).analyze({
       // Both on, for the reason `doctor` turns both on: this command's job is to say everything
       // that is known, and a relation that appears only under a flag is one a reader would be
       // told is absent.
@@ -8111,7 +3844,7 @@ withOutputFlags(
     let keptTables;
     let keptColumns;
     if (cfg) {
-      keptTables = filterTables(analysis.tables, cfg).map((t) => (0, import_analyzer4.qualifiedTableName)(t));
+      keptTables = filterTables(analysis.tables, cfg).map((t) => (0, import_analyzer3.qualifiedTableName)(t));
       try {
         const narrowed = filterColumns(
           [match.table],
@@ -8206,7 +3939,7 @@ withOutputFlags(
           )
         );
       }
-      const analyzer = new import_analyzer4.SchemaAnalyzer(source.schema);
+      const analyzer = new import_analyzer3.SchemaAnalyzer(source.schema);
       const spinner = out.spinner("Analyzing...");
       const t0 = Date.now();
       const analysis = await analyzer.analyze({
@@ -8421,7 +4154,7 @@ withOutputFlags(
   const out = outputFor(opts);
   out.warn(deprecationNotice("generate:orpc", "orpc", schema, cmd));
   try {
-    const analyzer = new import_analyzer4.SchemaAnalyzer(schema);
+    const analyzer = new import_analyzer3.SchemaAnalyzer(schema);
     const analysis = await analyzer.analyze({
       includeRelations: !!opts.includeRelations,
       validateConstraints: true
@@ -8464,7 +4197,7 @@ withOutputFlags(
   const out = outputFor(opts);
   out.warn(deprecationNotice("generate:trpc", "trpc", schema, cmd));
   try {
-    const analyzer = new import_analyzer4.SchemaAnalyzer(schema);
+    const analyzer = new import_analyzer3.SchemaAnalyzer(schema);
     const analysis = await analyzer.analyze({
       includeRelations: !!opts.includeRelations,
       validateConstraints: true
@@ -8645,7 +4378,7 @@ program.command("watch").description("Watch schema and regenerate on changes").o
         });
       }
       for (const w of source.warnings) out.warn(w);
-      const analyzer = new import_analyzer4.SchemaAnalyzer(source.schema);
+      const analyzer = new import_analyzer3.SchemaAnalyzer(source.schema);
       const analysis = await analyzer.analyze({
         includeRelations: cfg.analyzer.includeRelations,
         validateConstraints: cfg.analyzer.validateConstraints,