@drzl/cli 4.18.0 → 4.21.0

package/dist/cli.cjs

@@ -261,7 +261,7 @@ ${entries}
   const decided = [...declared, body].join("\n\n");
   const imports = [];
   if (useShared) {
-    const sharedAffix = (0, import_validation_core3.resolveAffix)({
+    const sharedAffix = (0, import_validation_core4.resolveAffix)({
       affix: opts.validation?.affix,
       schemaSuffix: opts.validation?.schemaSuffix
     });
@@ -271,21 +271,21 @@ ${entries}
       ["select", selectName]
     ].filter(([, local]) => decided.includes(local));
     if (wanted.length) {
-      const spec = (0, import_validation_core3.resolveConfiguredImport)(
+      const spec = (0, import_validation_core4.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);
+        const exported = (0, import_validation_core4.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)(
+    `import { ${[builder, "router"].sort().join(", ")} } from '${(0, import_validation_core4.importSpecifier)(
       `./${BASE_MODULE}.ts`,
       opts.importExtension
     )}';`
@@ -334,7 +334,7 @@ function relationProcedures(table, lib, selectSchemaName, taken, service) {
   return out;
 }
 function renderBarrel(routers, ctx, path6, opts) {
-  const baseSpec = (0, import_validation_core3.importSpecifier)(`./${BASE_MODULE}.ts`, opts.importExtension);
+  const baseSpec = (0, import_validation_core4.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}';
@@ -352,7 +352,7 @@ export type AppRouter = typeof appRouter;
 ${reExports}`;
   }
   const entries = routers.map(({ filePath, exportName, table }) => ({
-    rel: (0, import_validation_core3.importSpecifier)(
+    rel: (0, import_validation_core4.importSpecifier)(
       "./" + path6.relative(ctx.out, filePath).replace(/\\/g, "/"),
       opts.importExtension
     ),
@@ -393,7 +393,7 @@ function routerExportName(table, naming) {
 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);
+  return (0, import_validation_core4.importSpecifier)(`${dir}/${singularize(table.tsName)}Service.ts`, opts.importExtension);
 }
 function relativePosix(from, to) {
   const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -413,11 +413,11 @@ function buildHeader(h) {
   ];
   return lines.join("\n") + "\n\n";
 }
-var import_validation_core3, TRPC_MAJOR, q, LIB_IMPORTS, LIB_USAGE, LIBS, cap, singularize, isIdent, BASE_MODULE, TRPCGenerator, index_default;
+var import_validation_core4, 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_core3 = require("@drzl/validation-core");
+    import_validation_core4 = require("@drzl/validation-core");
     TRPC_MAJOR = 11;
     q = (v) => JSON.stringify(v);
     LIB_IMPORTS = {
@@ -510,7 +510,7 @@ ${body}
         await fs3.mkdir(out, { recursive: true });
         const files = [];
         const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core3.formatCode)(
+          const formatted = await (0, import_validation_core4.formatCode)(
             buildHeader(opts.outputHeader) + content,
             filePath,
             opts.format
@@ -606,14 +606,14 @@ function baseSchema(c, mode, target, checks, sets, lengths) {
     case "string": {
       const out = { type: "string" };
       if (c.format === "uuid") out.format = UUID_FORMAT;
-      else if (c.format && import_validation_core5.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core5.COLUMN_FORMATS[c.format];
+      else if (c.format && import_validation_core6.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core6.COLUMN_FORMATS[c.format];
       if (c.maxLength !== void 0) out.maxLength = c.maxLength;
       applyByteCap(out, c);
       applyLengths(out, c, lengths);
       return out;
     }
     case "number": {
-      const out = { type: (0, import_validation_core5.isIntegerColumn)(c) ? "integer" : "number" };
+      const out = { type: (0, import_validation_core6.isIntegerColumn)(c) ? "integer" : "number" };
       if (!c.arrayDimensions) applyNumericBounds(out, c, checks, target);
       return out;
     }
@@ -750,7 +750,7 @@ function tableSchema(table, cols, mode, target, applyDefaults, parsed) {
   };
 }
 function collect(table) {
-  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core5.parseCheck)(k.expression, k.name));
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core6.parseCheck)(k.expression, k.name));
   return {
     checks: parsed.flatMap((p) => p.ok ? p.checks : []),
     sets: parsed.flatMap((p) => p.ok ? p.sets ?? [] : []),
@@ -764,9 +764,9 @@ function tableSchemas(table, opts = {}) {
   const parsed = collect(table);
   const build2 = (cols, mode) => tableSchema(table, cols, mode, target, !!opts.applyDefaults, parsed);
   return {
-    insert: build2((0, import_validation_core5.insertColumns)(table), "insert"),
-    update: build2((0, import_validation_core5.updateColumns)(table), "update"),
-    select: build2((0, import_validation_core5.selectColumns)(table), "select")
+    insert: build2((0, import_validation_core6.insertColumns)(table), "insert"),
+    update: build2((0, import_validation_core6.updateColumns)(table), "update"),
+    select: build2((0, import_validation_core6.selectColumns)(table), "select")
   };
 }
 function componentsDocument(tables, opts = {}) {
@@ -793,6 +793,7 @@ function foreignKeysOf(table) {
   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]
   }));
 }
@@ -818,11 +819,11 @@ function build(tables, opts) {
     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 "${table.name}". An operationId is the method name a client generator derives, and the specification requires it to be unique across the document.`
+        `@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, table.name);
-    return { operationId: id, tags: [table.name], ...rest };
+    operationIds.set(id, (0, import_analyzer.qualifiedTableName)(table));
+    return { operationId: id, tags: [(0, import_analyzer.qualifiedTableName)(table)], ...rest };
   };
   const built = tables.map((table) => ({
     table,
@@ -840,7 +841,10 @@ function build(tables, opts) {
     if (table.readOnly) {
       notes.push("It refuses every write, so only reads are described.");
     }
-    tags.push({ name: table.name, description: [`Table "${table.name}".`, ...notes].join(" ") });
+    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 = {
@@ -856,7 +860,7 @@ function build(tables, opts) {
       ...jsonBody(ref(ERROR_SCHEMA))
     });
     const collection = `/${segment}`;
-    claim(collection, table.tsName, table.name);
+    claim(collection, table.tsName, (0, import_analyzer.qualifiedTableName)(table));
     const item = {
       get: operation(`list${T}`, table, {
         summary: `List every ${table.name} row.`,
@@ -885,7 +889,7 @@ function build(tables, opts) {
     paths[collection] = item;
     if (!key) continue;
     const itemPath = `${collection}/${key.map((c) => `{${c.name}}`).join("/")}`;
-    claim(itemPath, table.tsName, table.name);
+    claim(itemPath, table.tsName, (0, import_analyzer.qualifiedTableName)(table));
     const parameters = key.map((c) => ({
       name: c.name,
       in: "path",
@@ -944,14 +948,18 @@ function build(tables, opts) {
     for (const child of built) {
       if (child.table === table) continue;
       const matching = foreignKeysOf(child.table).filter(
-        (fk) => fk.foreignTable === table.name && fk.foreignColumns.length === key.length && fk.foreignColumns.every((c, i) => c === key[i].name)
+        (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}`,
-        `${table.name} -> ${child.table.name}`
+        `${(0, import_analyzer.qualifiedTableName)(table)} -> ${(0, import_analyzer.qualifiedTableName)(child.table)}`
       );
       paths[subPath] = {
         parameters,
@@ -995,9 +1003,9 @@ function openApiDocument(tables, opts = {}) {
 function renderTableModule(table, affix, target, applyDefaults) {
   const T = table.tsName;
   const schemas = tableSchemas(table, { target, applyDefaults });
-  const decl = (mode) => `export const ${(0, import_validation_core4.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
+  const decl = (mode) => `export const ${(0, import_validation_core5.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
 
-export type ${(0, import_validation_core4.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core4.schemaName)(mode, T, affix)};`;
+export type ${(0, import_validation_core5.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core5.schemaName)(mode, T, affix)};`;
   return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
 }
 function resolveDocument(opt) {
@@ -1013,12 +1021,13 @@ function buildHeader2(h) {
 
 `;
 }
-var import_validation_core4, import_validation_core5, DRAFT, UUID_FORMAT, base64, ERROR_SCHEMA, componentName, ref, pascal, modesFor, resourceSegment, jsonBody, errorSchema, DEFAULT_FILE_SUFFIX, JsonSchemaGenerator, index_default2;
+var import_validation_core5, import_analyzer, import_validation_core6, DRAFT, UUID_FORMAT, base64, ERROR_SCHEMA, componentName, ref, pascal, modesFor, resourceSegment, jsonBody, errorSchema, DEFAULT_FILE_SUFFIX, JsonSchemaGenerator, index_default2;
 var init_dist2 = __esm({
   "../generator-json-schema/dist/index.js"() {
     "use strict";
-    import_validation_core4 = require("@drzl/validation-core");
     import_validation_core5 = require("@drzl/validation-core");
+    import_analyzer = require("@drzl/analyzer");
+    import_validation_core6 = require("@drzl/validation-core");
     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" };
@@ -1031,7 +1040,7 @@ var init_dist2 = __esm({
       ...table.readOnly || !key ? [] : ["update"],
       "select"
     ];
-    resourceSegment = (table) => encodeURIComponent(table.name);
+    resourceSegment = (table) => table.schema ? `${encodeURIComponent(table.schema)}/${encodeURIComponent(table.name)}` : encodeURIComponent(table.name);
     jsonBody = (schema) => ({ content: { "application/json": { schema } } });
     errorSchema = () => ({
       title: "error",
@@ -1056,14 +1065,14 @@ var init_dist2 = __esm({
         const out = path6.resolve(process.cwd(), opts.outDir);
         const files = [];
         await fs3.mkdir(out, { recursive: true });
-        const affix = (0, import_validation_core4.resolveAffix)(opts);
+        const affix = (0, import_validation_core5.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 = path6.join(out, (0, import_validation_core4.moduleFileName)(table.tsName, fileSuffix));
+          const filePath = path6.join(out, (0, import_validation_core5.moduleFileName)(table.tsName, fileSuffix));
           const code = renderTableModule(table, affix, target, !!opts.applyDefaults);
-          const formatted = await (0, import_validation_core4.formatCode)(
+          const formatted = await (0, import_validation_core5.formatCode)(
             buildHeader2(opts.outputHeader) + code,
             filePath,
             opts.format
@@ -1081,7 +1090,7 @@ var init_dist2 = __esm({
 `;
           await fs3.writeFile(
             componentsPath,
-            await (0, import_validation_core4.formatCode)(buildHeader2(opts.outputHeader) + code, componentsPath, opts.format),
+            await (0, import_validation_core5.formatCode)(buildHeader2(opts.outputHeader) + code, componentsPath, opts.format),
             "utf8"
           );
           files.push(componentsPath);
@@ -1102,7 +1111,7 @@ var init_dist2 = __esm({
 `;
             await fs3.writeFile(
               tsPath,
-              await (0, import_validation_core4.formatCode)(buildHeader2(opts.outputHeader) + code, tsPath, opts.format),
+              await (0, import_validation_core5.formatCode)(buildHeader2(opts.outputHeader) + code, tsPath, opts.format),
               "utf8"
             );
             files.push(tsPath);
@@ -1116,9 +1125,9 @@ var init_dist2 = __esm({
         const ext = opts.importExtension === "none" ? "" : ".js";
         const indexPath = path6.join(out, "index.ts");
         const index = this.analysis.tables.map(
-          (t) => `export * from '${(0, import_validation_core4.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
+          (t) => `export * from '${(0, import_validation_core5.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_core4.formatCode)(
+        const indexFormatted = await (0, import_validation_core5.formatCode)(
           buildHeader2(opts.outputHeader) + index,
           indexPath,
           opts.format
@@ -1130,7 +1139,7 @@ var init_dist2 = __esm({
       renderTable(table, opts) {
         return renderTableModule(
           table,
-          (0, import_validation_core4.resolveAffix)(opts),
+          (0, import_validation_core5.resolveAffix)(opts),
           opts?.target ?? "draft-2020-12",
           !!opts?.applyDefaults
         );
@@ -1140,8 +1149,574 @@ var init_dist2 = __esm({
   }
 });
 
+// ../generator-effect/dist/index.js
+var dist_exports3 = {};
+__export(dist_exports3, {
+  EffectGenerator: () => EffectGenerator,
+  default: () => index_default3
+});
+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_core7.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_core7.COERCIBLE_DATE_STRING)}))`,
+    filter((0, import_validation_core7.parsesToADate)("new Date(v)"), "a date the runtime can parse")
+  ]);
+  const fromNumber = piped(`${NS}.Number`, [
+    filter((0, import_validation_core7.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_core7.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_core7.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) {
+  if (c.arrayDimensions || c.shape) return [];
+  return lengths.filter((k) => k.column === c.name).map(
+    (k) => filter(
+      `${import_validation_core7.CODEPOINT_LENGTH} ${OPS[k.operator]} ${k.value}`,
+      `${k.name ? `${k.name}: ` : ""}length(${c.name}) ${k.operator} ${k.value}`
+    )
+  );
+}
+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 folded = foldedIntoBounds(c, checks);
+  return checks.filter((k) => k.column === c.name && !folded.has(k)).map((k) => {
+    const literal = k.kind === "string" ? JSON.stringify(k.value) : k.value;
+    return filter(
+      `v ${OPS[k.operator]} ${literal}`,
+      `${k.name ? `${k.name}: ` : ""}${c.name} ${k.operator} ${k.value}`
+    );
+  });
+}
+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 shaped;
+  const set = sets.find((x) => x.column === c.name);
+  if (set) {
+    const values = set.values.map((v) => set.kind === "string" ? JSON.stringify(v) : 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) {
+    return `${NS}.Literal(${eq.kind === "string" ? JSON.stringify(eq.value) : 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_core7.COLUMN_FORMATS[c.format] ? [`${NS}.pattern(new RegExp(${JSON.stringify(import_validation_core7.COLUMN_FORMATS[c.format])}))`] : [];
+      return piped(base, [...pattern, ...capSteps(c, mode), ...rest]);
+    }
+    case "number": {
+      const base = (0, import_validation_core7.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, allColumns) {
+  return allColumns || 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 field2 = renderField(
+      c,
+      mode,
+      coerceDates,
+      checks,
+      sets,
+      lengths,
+      cardinalities,
+      applyDefaults,
+      ref2,
+      brands?.plan.brandOf(brands.tsName, c.name)
+    );
+    return `  ${JSON.stringify(c.name)}: ${field2},`;
+  }).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_core7.parseCheck)(k.expression, k.name));
+  return {
+    checks: parsed.flatMap((p) => p.ok ? p.checks : []),
+    sets: parsed.flatMap((p) => p.ok ? p.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_core7.insertColumns)(node.table) : (0, import_validation_core7.selectColumns)(node.table);
+  return (0, import_validation_core7.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_core7.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_core7.nestedSchemaName)(mode, table.tsName, affix);
+    const tname = (0, import_validation_core7.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_core7.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_core7.insertColumns)(table);
+  const updateCols = (0, import_validation_core7.updateColumns)(table);
+  const selectCols = (0, import_validation_core7.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_core7.schemaName)(mode, T, affix);
+    const tname = (0, import_validation_core7.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_core7.renderDuplicateFinder)(table, `findDuplicate${T}`, (0, import_validation_core7.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_core7.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}
+` : "";
+  return `import * as ${NS} from 'effect/Schema';
+${schemaImport}${needsJson ? `
+${JSON_PREAMBLE}` : ""}
+${blocks.join("\n\n")}
+${brandCode}${nestedCode}${duplicates}`;
+}
+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";
+}
+var import_validation_core7, DEFAULT_FILE_SUFFIX2, STANDARD_PREFIX, NS, OPS, JSON_CONST, JSON_PREAMBLE, UNKNOWN_EXPR, EffectGenerator, index_default3;
+var init_dist3 = __esm({
+  "../generator-effect/dist/index.js"() {
+    "use strict";
+    import_validation_core7 = 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 fs3 = await import("fs/promises");
+        const path6 = await import("path");
+        const out = path6.resolve(process.cwd(), opts.outDir);
+        const files = [];
+        await fs3.mkdir(out, { recursive: true });
+        const affix = (0, import_validation_core7.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_core7.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_core7.resolveNestedDepth)(opts.nestedDepth, (m) => console.warn(m)) : 0;
+        const brands = (0, import_validation_core7.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 = path6.join(out, (0, import_validation_core7.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_core7.formatCode)(
+            buildHeader3(opts.outputHeader) + code,
+            filePath,
+            opts.format
+          );
+          await fs3.writeFile(filePath, formatted, "utf8");
+          files.push(filePath);
+        }
+        const indexPath = path6.join(out, "index.ts");
+        const indexFormatted = await (0, import_validation_core7.formatCode)(
+          buildHeader3(opts.outputHeader) + this.defaultIndex(this.analysis, opts),
+          indexPath,
+          opts.format
+        );
+        await fs3.writeFile(indexPath, indexFormatted, "utf8");
+        files.push(indexPath);
+        return files;
+      }
+      renderTable(table, opts) {
+        return renderTableSchemas(
+          table,
+          (0, import_validation_core7.resolveAffix)(opts),
+          opts?.coerceDates ?? "input",
+          void 0,
+          !!opts?.applyDefaults,
+          !!opts?.duplicateFinder,
+          {},
+          (0, import_validation_core7.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_core7.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
+        ).join("\n") + "\n";
+      }
+    };
+    index_default3 = EffectGenerator;
+  }
+});
+
 // src/cli.ts
-var import_analyzer = require("@drzl/analyzer");
+var import_analyzer2 = require("@drzl/analyzer");
 var import_generator_orpc = require("@drzl/generator-orpc");
 var import_chalk3 = __toESM(require("chalk"), 1);
 var import_chokidar = __toESM(require("chokidar"), 1);
@@ -1165,6 +1740,11 @@ function validationOptions(g, cfg, outDir, caps = {}) {
     duplicateFinder: g.duplicateFinder,
     nestedSchemas: g.nestedSchemas,
     nestedDepth: g.nestedDepth,
+    // Every validation generator can express a brand, including TypeBox, which has no brand
+    // helper and gets one from `TUnsafe` instead. So this needs no capability flag: an option
+    // that reached only four of the five would be the class of defect this file exists to
+    // remove.
+    branded: g.branded,
     // Only where the generator can act on them, so an unsupported option is absent rather than
     // present and ignored.
     ...caps.schemaTypes ? {
@@ -1172,7 +1752,9 @@ function validationOptions(g, cfg, outDir, caps = {}) {
       schemaPath: cfg.schema,
       typedJson: g.typedJson,
       typedColumns: g.typedColumns
-    } : {}
+    } : {},
+    ...caps.standardSchema ? { standardSchema: g.standardSchema } : {},
+    ...caps.meta ? { meta: g.meta } : {}
   };
 }
 
@@ -1196,6 +1778,47 @@ var fs = __toESM(require("fs"), 1);
 var import_node_module = require("module");
 var path = __toESM(require("path"), 1);
 var import_zod = require("zod");
+
+// src/patterns.ts
+function patternToRegExp(pattern) {
+  return new RegExp(
+    "^" + pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$"
+  );
+}
+function matchesAny(patterns, name) {
+  return patterns.some((p) => patternToRegExp(p).test(name));
+}
+var DEFAULT_SCHEMA_ALIAS = "public";
+function tableAliases(table) {
+  return [table.name, `${table.schema ?? DEFAULT_SCHEMA_ALIAS}.${table.name}`];
+}
+function matchesTable(patterns, table) {
+  return tableAliases(table).some((alias) => matchesAny(patterns, alias));
+}
+function displayTableName(table) {
+  return table.schema ? `${table.schema}.${table.name}` : table.name;
+}
+function addressableName(table) {
+  return `${table.schema ?? DEFAULT_SCHEMA_ALIAS}.${table.name}`;
+}
+function hasNamedSchemas(tables) {
+  return tables.some((t) => t.schema);
+}
+function ambiguousPatternWarnings(patterns, tables, option) {
+  const out = [];
+  for (const pattern of patterns) {
+    if (pattern.includes(".")) continue;
+    const matched = tables.filter((t) => matchesTable([pattern], t));
+    const schemas = new Set(matched.map((t) => t.schema ?? DEFAULT_SCHEMA_ALIAS));
+    if (schemas.size < 2) continue;
+    out.push(
+      `drzl config: ${option} pattern ${JSON.stringify(pattern)} matches tables in more than one schema, and every one of them is affected: ${matched.map(addressableName).sort().join(", ")}. Write the schema to mean one of them, for example ${JSON.stringify(addressableName(matched[0]))}.`
+    );
+  }
+  return out;
+}
+
+// src/config.ts
 var NamingSchema = import_zod.z.object({
   routerSuffix: import_zod.z.string().default("Router"),
   procedureCase: import_zod.z.enum(["camel", "kebab", "snake"]).default("camel")
@@ -1229,7 +1852,17 @@ var AffixSchema = import_zod.z.object({
 }).strict();
 var ImportExtensionSchema = import_zod.z.enum(import_validation_core.IMPORT_EXTENSIONS);
 var GeneratorSchema = import_zod.z.object({
-  kind: import_zod.z.enum(["orpc", "trpc", "service", "zod", "valibot", "arktype", "typebox", "json-schema"]),
+  kind: import_zod.z.enum([
+    "orpc",
+    "trpc",
+    "service",
+    "zod",
+    "valibot",
+    "arktype",
+    "typebox",
+    "effect",
+    "json-schema"
+  ]),
   /**
    * Overrides the top-level `importExtension` for this generator alone, for a project whose
    * generated directories are compiled by different tsconfigs.
@@ -1265,6 +1898,36 @@ var GeneratorSchema = import_zod.z.object({
    * fact about the table rather than the row. This checks the half that needs no database.
    */
   duplicateFinder: import_zod.z.boolean().optional(),
+  /**
+   * zod only. Attach the facts the analyzer knows and a zod schema cannot state, as `.meta()` on
+   * every field and every table schema: the declared SQL type, the primary key, the unique
+   * constraints, whether the database generates or defaults the value, and the CHECK constraints,
+   * including the ones DRZL declined to enforce.
+   *
+   * `z.toJSONSchema` copies these through, so they are also how an OpenAPI document built from the
+   * emitted schemas gets the declared width back: DRZL enforces one as a `.refine()`, and
+   * `toJSONSchema` drops every refinement in silence.
+   *
+   * `true` is the shorthand for `{ enabled: true }`. `{ description: true }` additionally writes a
+   * `description`, which is what an OpenAPI viewer renders to a human.
+   */
+  meta: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({ enabled: import_zod.z.boolean().optional(), description: import_zod.z.boolean().optional() }).strict()
+  ]).optional(),
+  /**
+   * TypeBox only. Give every emitted schema a `~standard` key, so it can be handed to a tRPC or
+   * oRPC route.
+   *
+   * TypeBox is the one validator DRZL emits that carries none of its own: measured on 0.34.52, a
+   * bare `Type.Object()` has no `~standard` and the package exports nothing matching
+   * `/standard/i`. zod, valibot and arktype all put one on every schema they build, so the option
+   * does nothing for them and is not passed through.
+   *
+   * The property is non-enumerable, so the schema stays a TypeBox schema in every respect that was
+   * already observable, including the JSON Schema `JSON.stringify` produces.
+   */
+  standardSchema: import_zod.z.boolean().optional(),
   /**
    * Emit `NestedInsert<Table>` and `NestedSelect<Table>` beside the flat schemas: the table plus
    * one key per relation, so `{ ...user, posts: [...] }` can be validated whole.
@@ -1281,6 +1944,29 @@ var GeneratorSchema = import_zod.z.object({
    * it is also what terminates a cycle: `users -> posts -> users` stops here.
    */
   nestedDepth: import_zod.z.number().int().optional(),
+  /**
+   * Give every primary key, and every foreign key pointing at one, a nominal type, so a
+   * `users.id` cannot be passed where a `posts.id` is wanted.
+   *
+   * Type level only, in all five validators. Measured on zod 4.4.3, `.brand()` returns the same
+   * schema object it was called on and the parsed value of `1` is `1`, so nothing about what a
+   * schema accepts changes and no bytes are added to the bundle. TypeBox has no brand of its own
+   * and gets a `TUnsafe` cast, which leaves the schema object identical.
+   *
+   * Off by default: it changes the inferred type of every consumer of the select schemas, which
+   * is the point, but it is a change to existing call sites rather than an addition.
+   *
+   * `true` is the shorthand for `{ enabled: true }`. `{ foreignKeys: false }` brands only the
+   * keys themselves, and `{ aliases: false }` stops the `export type UsersId = ...` lines.
+   */
+  branded: import_zod.z.union([
+    import_zod.z.boolean(),
+    import_zod.z.object({
+      enabled: import_zod.z.boolean().optional(),
+      foreignKeys: import_zod.z.boolean().optional(),
+      aliases: import_zod.z.boolean().optional()
+    }).strict()
+  ]).optional(),
   naming: NamingSchema.optional(),
   outputHeader: import_zod.z.object({
     enabled: import_zod.z.boolean().default(true).optional(),
@@ -1375,6 +2061,10 @@ var GeneratorSchema = import_zod.z.object({
   // template options
   templateOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional()
 });
+var ColumnRulesSchema = import_zod.z.object({
+  omit: import_zod.z.array(import_zod.z.string()).optional(),
+  pick: import_zod.z.array(import_zod.z.string()).optional()
+}).strict();
 var AnalyzerSchema = import_zod.z.object({
   includeRelations: import_zod.z.boolean().default(true),
   validateConstraints: import_zod.z.boolean().default(true),
@@ -1401,6 +2091,37 @@ var ConfigSchema = import_zod.z.object({
    */
   include: import_zod.z.array(import_zod.z.string()).optional(),
   exclude: import_zod.z.array(import_zod.z.string()).optional(),
+  /**
+   * Which columns of those tables to generate for, keyed by table.
+   *
+   * `include`/`exclude` is all or nothing per table, and the column that should not be in a
+   * generated schema is usually sitting in a table you do want: `passwordHash` on `users`, an
+   * internal note beside the public fields, a `tenantId` the server sets from the session and a
+   * request body must not carry. Editing the emitted file is not an answer, because the next
+   * `drzl generate` overwrites it.
+   *
+   * ```ts
+   * columns: {
+   *   users: { omit: ['passwordHash'] },
+   *   'app_*': { omit: ['deleted_at'] },
+   * }
+   * ```
+   *
+   * The key is a table pattern in the same language `include`/`exclude` uses: the database table
+   * name, anchored, with `*` as the only metacharacter. Column patterns are the same language
+   * again. Every matching entry applies, in the order written; within one entry `pick` narrows
+   * first and `omit` then removes, so `omit` wins, exactly as `exclude` wins over `include`.
+   *
+   * Applies to every mode and every generator at once, because it narrows the analysis rather
+   * than any one generator's output. A column cannot be kept in `select` and dropped from
+   * `insert`: see the docs for why that form was not taken on.
+   *
+   * A pattern that matches nothing is an error rather than a no-op, because a typo in `omit`
+   * that silently does nothing leaves the column exactly where it was while reading like a fix.
+   * Dropping a primary key column is an error too; dropping a NOT NULL column with no default is
+   * a warning.
+   */
+  columns: import_zod.z.record(import_zod.z.string(), ColumnRulesSchema).optional(),
   /**
    * How every relative specifier drzl invents spells its extension, for every generator.
    * A generator may override it. Defaults to `js`, which is the only form that resolves
@@ -1563,6 +2284,7 @@ function computeGeneratorOutputDirs(cfg, cwd = process.cwd()) {
     if (g.kind === "valibot") dirs.add(abs(g.path ?? "src/validators/valibot"));
     if (g.kind === "arktype") dirs.add(abs(g.path ?? "src/validators/arktype"));
     if (g.kind === "typebox") dirs.add(abs(g.path ?? "src/validators/typebox"));
+    if (g.kind === "effect") dirs.add(abs(g.path ?? "src/validators/effect"));
     if (g.kind === "json-schema") dirs.add(abs(g.path ?? "src/validators/json-schema"));
   }
   return [...dirs];
@@ -1593,15 +2315,17 @@ function resolveTemplateDirsSync(cfg, cwd = process.cwd()) {
   return Array.from(new Set(results));
 }
 function filterTables(tables, opts) {
-  const toRegExp = (pattern) => new RegExp(
-    "^" + pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$"
-  );
-  const matches = (patterns, name) => patterns.some((p) => toRegExp(p).test(name));
   let out = tables;
-  if (opts.include?.length) out = out.filter((t) => matches(opts.include, t.name));
-  if (opts.exclude?.length) out = out.filter((t) => !matches(opts.exclude, t.name));
+  if (opts.include?.length) out = out.filter((t) => matchesTable(opts.include, t));
+  if (opts.exclude?.length) out = out.filter((t) => !matchesTable(opts.exclude, t));
   return out;
 }
+function tableFilterWarnings(tables, opts) {
+  return [
+    ...ambiguousPatternWarnings(opts.include ?? [], tables, "include"),
+    ...ambiguousPatternWarnings(opts.exclude ?? [], tables, "exclude")
+  ];
+}
 function computeWatchTargets(cfg, cwd = process.cwd()) {
   const abs = (p) => path.resolve(cwd, p);
   const schemaAbs = abs(cfg.schema);
@@ -1635,6 +2359,9 @@ function trpcOptions(g, cfg, servicesDir) {
   };
 }
 
+// src/column-filter.ts
+var import_validation_core3 = require("@drzl/validation-core");
+
 // src/doctor.ts
 var import_validation_core2 = require("@drzl/validation-core");
 var import_chalk = __toESM(require("chalk"), 1);
@@ -1893,6 +2620,99 @@ function renderDoctorReport(report) {
   return out.join("\n");
 }
 
+// src/column-filter.ts
+function checkedColumns(expression, name) {
+  const parsed = (0, import_validation_core3.parseCheck)(expression, name);
+  if (!parsed.ok) return [];
+  return [...new Set(namedColumns(parsed).map((n) => n.column))];
+}
+function filterColumns(tables, spec) {
+  const entries = Object.entries(spec ?? {});
+  if (!entries.length) return { tables, warnings: [] };
+  const errors = [];
+  const warnings = [];
+  const nameForConfig = hasNamedSchemas(tables) ? addressableName : displayTableName;
+  for (const [tablePattern, rules] of entries) {
+    const matched = tables.filter((t) => matchesTable([tablePattern], t));
+    if (!matched.length) {
+      errors.push(
+        `columns[${JSON.stringify(tablePattern)}] matches no table. The schema declares: ${tables.map(nameForConfig).join(", ") || "(no tables)"}.`
+      );
+      continue;
+    }
+    const available = [...new Set(matched.flatMap((t) => t.columns.map((c) => c.name)))];
+    for (const which of ["pick", "omit"]) {
+      for (const pattern of rules[which] ?? []) {
+        if (available.some((name) => matchesAny([pattern], name))) continue;
+        errors.push(
+          `columns[${JSON.stringify(tablePattern)}].${which} names ${JSON.stringify(pattern)}, which matches no column of ${matched.map(nameForConfig).join(", ")}. Available: ${available.join(", ")}.`
+        );
+      }
+    }
+  }
+  warnings.push(
+    ...ambiguousPatternWarnings(
+      entries.map(([p]) => p),
+      tables,
+      "columns"
+    )
+  );
+  const out = tables.map((table) => {
+    const mine = entries.filter(([pattern]) => matchesTable([pattern], table));
+    if (!mine.length) return table;
+    let keep = table.columns;
+    for (const [, rules] of mine) {
+      if (rules.pick?.length) keep = keep.filter((c) => matchesAny(rules.pick, c.name));
+      if (rules.omit?.length) keep = keep.filter((c) => !matchesAny(rules.omit, c.name));
+    }
+    if (keep.length === table.columns.length) return table;
+    const kept = new Set(keep.map((c) => c.name));
+    const dropped = table.columns.filter((c) => !kept.has(c.name));
+    if (!keep.length) {
+      errors.push(
+        `columns leaves table "${displayTableName(table)}" with no columns at all. An empty schema describes no row, so this is never a narrower API. Exclude the table instead, with the top-level "exclude" option.`
+      );
+      return table;
+    }
+    const lostKey = (table.primaryKey?.columns ?? []).filter((n) => !kept.has(n));
+    if (lostKey.length) {
+      errors.push(
+        `columns drops ${lostKey.map((n) => JSON.stringify(n)).join(", ")} from table "${displayTableName(table)}", which is part of its primary key (${table.primaryKey?.columns.join(", ")}). The generated getById, update and delete address rows by that key, so the emitted schemas would describe a row nothing can address. Keep the key, or leave the whole table out with the top-level "exclude" option.`
+      );
+      return table;
+    }
+    for (const c of dropped) {
+      if (c.nullable || c.hasDefault || c.isGenerated || table.readOnly) continue;
+      warnings.push(
+        `drzl config: the "columns" option drops "${c.name}" from table "${displayTableName(table)}", and the database requires it: NOT NULL with no default. The emitted insert schema therefore describes a payload that is not a complete row, so whatever calls db.insert has to supply "${c.name}" itself.`
+      );
+    }
+    for (const k of table.checks ?? []) {
+      const lost = checkedColumns(k.expression, k.name).filter(
+        (n) => !kept.has(n) && table.columns.some((c) => c.name === n)
+      );
+      if (!lost.length) continue;
+      warnings.push(
+        `drzl config: CHECK ${k.name ? `"${k.name}"` : "(unnamed)"} on table "${displayTableName(table)}" names ${lost.map((n) => JSON.stringify(n)).join(", ")}, which the "columns" option drops, so nothing DRZL emits enforces it. Your database still does.`
+      );
+    }
+    return {
+      ...table,
+      columns: keep,
+      unique: (table.unique ?? []).filter((k) => k.columns.every((n) => kept.has(n))),
+      indexes: (table.indexes ?? []).filter((i) => i.columns.every((n) => kept.has(n))),
+      ...table.foreignKeys ? { foreignKeys: table.foreignKeys.filter((f) => f.columns.every((n) => kept.has(n))) } : {}
+    };
+  });
+  if (errors.length) {
+    throw new Error(
+      `drzl config: the "columns" option cannot be honoured.
+` + errors.map((e) => `  - ${e}`).join("\n")
+    );
+  }
+  return { tables: out, warnings };
+}
+
 // src/drift.ts
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
@@ -1979,7 +2799,7 @@ var shownThisProcess = false;
 var tips = [
   "Pair DRZL watch mode with drizzle-kit to keep schema & API synced.",
   "Templatize your ORPC routers to roll out new endpoints safely.",
-  "Need typed validators? Enable the zod, valibot, arktype, or typebox generators.",
+  "Need typed validators? Enable the zod, valibot, arktype, typebox, or effect generators.",
   "Need JSON Schema or OpenAPI? The json-schema generator emits both, with no runtime dependency.",
   "Use output headers to track generated files and trim noisy diffs."
 ];
@@ -2093,7 +2913,7 @@ Need a template, adapter, or generator DRZL doesn't ship yet?
 );
 program.command("analyze").argument("<schema>", "path to drizzle schema (TS)").option("--relations", "include relations", true).option("--validate", "validate constraints", true).option("--out <file>", "write analysis JSON to file").option("--json", "print JSON to stdout (overrides --out)", false).action(async (schema, opts) => {
   try {
-    const analyzer = new import_analyzer.SchemaAnalyzer(schema);
+    const analyzer = new import_analyzer2.SchemaAnalyzer(schema);
     const spinner = !opts.json ? (0, import_ora.default)("Analyzing schema...").start() : null;
     const start = Date.now();
     const res = await analyzer.analyze({
@@ -2141,7 +2961,7 @@ program.command("doctor").description("Report what DRZL cannot type or enforce i
       process.exit(1);
       return;
     }
-    const analyzer = new import_analyzer.SchemaAnalyzer(target);
+    const analyzer = new import_analyzer2.SchemaAnalyzer(target);
     const analysis = await analyzer.analyze({
       includeRelations: true,
       validateConstraints: true
@@ -2180,7 +3000,7 @@ program.command("generate").description("Run configured generators (drzl.config.
       process.exit(2);
       return;
     }
-    const analyzer = new import_analyzer.SchemaAnalyzer(cfg.schema);
+    const analyzer = new import_analyzer2.SchemaAnalyzer(cfg.schema);
     const spinner = (0, import_ora.default)("Analyzing...").start();
     const t0 = Date.now();
     const analysis = await analyzer.analyze({
@@ -2188,8 +3008,11 @@ program.command("generate").description("Run configured generators (drzl.config.
       validateConstraints: cfg.analyzer.validateConstraints,
       includeHeuristicRelations: cfg.analyzer.includeHeuristicRelations
     });
-    analysis.tables = filterTables(analysis.tables, cfg);
     spinner.succeed(`Analysis complete in ${Date.now() - t0}ms`);
+    const narrowed = filterColumns(analysis.tables, cfg.columns);
+    const filterWarnings = tableFilterWarnings(narrowed.tables, cfg);
+    analysis.tables = filterTables(narrowed.tables, cfg);
+    for (const w of [...narrowed.warnings, ...filterWarnings]) console.warn(import_chalk3.default.yellow(w));
     reportWideColumns(analysis.issues);
     const driftDirs = computeGeneratorOutputDirs(cfg);
     const driftBefore = opts.check ? await snapshotAll(driftDirs) : null;
@@ -2280,7 +3103,7 @@ program.command("generate").description("Run configured generators (drzl.config.
           const gen = new ZodGenerator(analysis);
           const target = g.path ?? "src/validators/zod";
           const files = await gen.generate(
-            validationOptions(g, cfg, target, { schemaTypes: true })
+            validationOptions(g, cfg, target, { schemaTypes: true, meta: true })
           );
           progress.stop();
           (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (zod): ${files.length} files`));
@@ -2354,7 +3177,10 @@ program.command("generate").description("Run configured generators (drzl.config.
           const gen = new TypeBoxGenerator(analysis);
           const target = g.path ?? "src/validators/typebox";
           const files = await gen.generate(
-            validationOptions(g, cfg, target, { schemaTypes: true })
+            validationOptions(g, cfg, target, {
+              schemaTypes: true,
+              standardSchema: true
+            })
           );
           progress.stop();
           (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (typebox): ${files.length} files`));
@@ -2364,6 +3190,25 @@ program.command("generate").description("Run configured generators (drzl.config.
           reportGeneratorFailure(g.kind, e);
           process.exit(1);
         }
+      } else if (g.kind === "effect") {
+        try {
+          const { EffectGenerator: EffectGenerator2 } = await loadGenerator(
+            "@drzl/generator-effect",
+            () => Promise.resolve().then(() => (init_dist3(), dist_exports3))
+          );
+          const gen = new EffectGenerator2(analysis);
+          const target = g.path ?? "src/validators/effect";
+          const files = await gen.generate(
+            validationOptions(g, cfg, target, { schemaTypes: true })
+          );
+          progress.stop();
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (effect): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
+        } catch (e) {
+          progress.stop();
+          reportGeneratorFailure(g.kind, e);
+          process.exit(1);
+        }
       }
     }
     if (driftBefore) {
@@ -2403,7 +3248,7 @@ Generated output is out of date (${drift.length} file(s)):`));
 });
 program.command("generate:orpc").argument("<schema>", "path to drizzle schema (TS)").option("-o, --outDir <dir>", "output directory", "src/api").option("--template <name>", "template name", "standard").option("--includeRelations", "include relation endpoints").action(async (schema, opts) => {
   try {
-    const analyzer = new import_analyzer.SchemaAnalyzer(schema);
+    const analyzer = new import_analyzer2.SchemaAnalyzer(schema);
     const analysis = await analyzer.analyze({
       includeRelations: !!opts.includeRelations,
       validateConstraints: true
@@ -2423,7 +3268,7 @@ program.command("generate:orpc").argument("<schema>", "path to drizzle schema (T
 });
 program.command("generate:trpc").argument("<schema>", "path to drizzle schema (TS)").option("-o, --outDir <dir>", "output directory", "src/api").option("--template <name>", "standard | service", "standard").option("--includeRelations", "include relation endpoints").option("--servicesDir <dir>", "where the service generator writes", "src/services").action(async (schema, opts) => {
   try {
-    const analyzer = new import_analyzer.SchemaAnalyzer(schema);
+    const analyzer = new import_analyzer2.SchemaAnalyzer(schema);
     const analysis = await analyzer.analyze({
       includeRelations: !!opts.includeRelations,
       validateConstraints: true
@@ -2525,13 +3370,17 @@ program.command("watch").description("Watch schema and regenerate on changes").o
           })
         );
       }
-      const analyzer = new import_analyzer.SchemaAnalyzer(cfg.schema);
+      const analyzer = new import_analyzer2.SchemaAnalyzer(cfg.schema);
       const analysis = await analyzer.analyze({
         includeRelations: cfg.analyzer.includeRelations,
         validateConstraints: cfg.analyzer.validateConstraints,
         includeHeuristicRelations: cfg.analyzer.includeHeuristicRelations
       });
-      analysis.tables = filterTables(analysis.tables, cfg);
+      const narrowed = filterColumns(analysis.tables, cfg.columns);
+      const filterWarnings = tableFilterWarnings(narrowed.tables, cfg);
+      analysis.tables = filterTables(narrowed.tables, cfg);
+      if (!opts.json)
+        for (const w of [...narrowed.warnings, ...filterWarnings]) console.warn(import_chalk3.default.yellow(w));
       if (!opts.json) reportWideColumns(analysis.issues);
       if (opts.pipeline === "analyze") {
         if (opts.json) {
@@ -2630,7 +3479,7 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             const gen = new ZodGenerator(analysis);
             const target = g.path ?? "src/validators/zod";
             const files = await gen.generate(
-              validationOptions(g, cfg, target, { schemaTypes: true })
+              validationOptions(g, cfg, target, { schemaTypes: true, meta: true })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
               import_chalk3.default.green(`Generated (zod): ${files.length} files`),
@@ -2690,7 +3539,10 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             const gen = new TypeBoxGenerator(analysis);
             const target = g.path ?? "src/validators/typebox";
             const files = await gen.generate(
-              validationOptions(g, cfg, target, { schemaTypes: true })
+              validationOptions(g, cfg, target, {
+                schemaTypes: true,
+                standardSchema: true
+              })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
               import_chalk3.default.green(`Generated (typebox): ${files.length} files`),
@@ -2701,6 +3553,26 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             reportGeneratorFailure(g.kind, e);
             return;
           }
+        } else if (g.kind === "effect") {
+          try {
+            const { EffectGenerator: EffectGenerator2 } = await loadGenerator(
+              "@drzl/generator-effect",
+              () => Promise.resolve().then(() => (init_dist3(), dist_exports3))
+            );
+            const gen = new EffectGenerator2(analysis);
+            const target = g.path ?? "src/validators/effect";
+            const files = await gen.generate(
+              validationOptions(g, cfg, target, { schemaTypes: true })
+            );
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk3.default.green(`Generated (effect): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            reportGeneratorFailure(g.kind, e);
+            return;
+          }
         } else if (g.kind === "json-schema") {
           try {
             const { JsonSchemaGenerator: JsonSchemaGenerator2 } = await loadGenerator(