@drzl/cli 4.19.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
         );
@@ -1179,7 +1188,7 @@ function foldedIntoBounds(c, checks) {
   );
 }
 function nonFiniteBranches(c) {
-  const { nan, infinity } = (0, import_validation_core6.nonFiniteAccepted)(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)`] : []
@@ -1193,11 +1202,11 @@ 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_core6.COERCIBLE_DATE_STRING)}))`,
-    filter((0, import_validation_core6.parsesToADate)("new Date(v)"), "a date the runtime can parse")
+    `${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_core6.parsesToADate)("new Date(v)"), "a date the runtime can parse")
+    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;
@@ -1208,11 +1217,11 @@ function capSteps(c, mode) {
   if (c.shape?.kind === "byteString") {
     const n = c.shape.length;
     if (!n) return steps;
-    return mode === "select" ? [filter(`${import_validation_core6.CODEPOINT_LENGTH} <= ${n}`, `at most ${n} characters`)] : [filter(`new TextEncoder().encode(v).length <= ${n}`, `at most ${n} bytes`)];
+    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_core6.CODEPOINT_LENGTH} <= ${c.maxLength}`, `at most ${c.maxLength} characters`)
+      filter(`${import_validation_core7.CODEPOINT_LENGTH} <= ${c.maxLength}`, `at most ${c.maxLength} characters`)
     );
   }
   if (c.maxBytes) {
@@ -1226,7 +1235,7 @@ function lengthSteps(c, lengths) {
   if (c.arrayDimensions || c.shape) return [];
   return lengths.filter((k) => k.column === c.name).map(
     (k) => filter(
-      `${import_validation_core6.CODEPOINT_LENGTH} ${OPS[k.operator]} ${k.value}`,
+      `${import_validation_core7.CODEPOINT_LENGTH} ${OPS[k.operator]} ${k.value}`,
       `${k.name ? `${k.name}: ` : ""}length(${c.name}) ${k.operator} ${k.value}`
     )
   );
@@ -1304,11 +1313,11 @@ function exprForColumn(c, mode, coerceDates, checks, sets, lengths, replaced) {
   switch (c.tsType) {
     case "string": {
       const base = c.format === "uuid" ? `${NS}.UUID` : `${NS}.String`;
-      const pattern = c.format && c.format !== "uuid" && import_validation_core6.COLUMN_FORMATS[c.format] ? [`${NS}.pattern(new RegExp(${JSON.stringify(import_validation_core6.COLUMN_FORMATS[c.format])}))`] : [];
+      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_core6.isIntegerColumn)(c) ? `${NS}.Int` : `${NS}.Finite`;
+      const base = (0, import_validation_core7.isIntegerColumn)(c) ? `${NS}.Int` : `${NS}.Finite`;
       return withNonFinite(c, piped(base, [...numericBounds(c, checks), ...rest]));
     }
     case "bigint":
@@ -1329,7 +1338,7 @@ function exprForColumn(c, mode, coerceDates, checks, sets, lengths, replaced) {
       return UNKNOWN_EXPR;
   }
 }
-function renderField(c, mode, coerceDates, checks, sets, lengths, cardinalities, applyDefault, narrowRef) {
+function renderField(c, mode, coerceDates, checks, sets, lengths, cardinalities, applyDefault, narrowRef, brand) {
   let expr = exprForColumn(
     c,
     mode,
@@ -1344,8 +1353,9 @@ function renderField(c, mode, coerceDates, checks, sets, lengths, cardinalities,
     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) expr = withNarrowedType(expr, narrowRef);
+  if (narrowRef && !brand) expr = withNarrowedType(expr, narrowRef);
   if (mode === "select") return expr;
   const wantsDefault = mode === "insert" && applyDefault && c.defaultValue !== void 0;
   if (wantsDefault) {
@@ -1357,7 +1367,7 @@ function renderField(c, mode, coerceDates, checks, sets, lengths, cardinalities,
 function wantsRef(c, allColumns) {
   return allColumns || hasNoRuntimeType(c);
 }
-function renderObjectShape(cols, mode, coerceDates, checks, sets, lengths, cardinalities, typedJson, applyDefaults) {
+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(
@@ -1369,7 +1379,8 @@ function renderObjectShape(cols, mode, coerceDates, checks, sets, lengths, cardi
       lengths,
       cardinalities,
       applyDefaults,
-      ref2
+      ref2,
+      brands?.plan.brandOf(brands.tsName, c.name)
     );
     return `  ${JSON.stringify(c.name)}: ${field2},`;
   }).join("\n");
@@ -1387,7 +1398,7 @@ 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_core6.parseCheck)(k.expression, k.name));
+  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 ?? [] : []),
@@ -1397,15 +1408,15 @@ function parsedChecksFor(table) {
   };
 }
 function nestedNodeCols(node, mode) {
-  const all = mode === "insert" ? (0, import_validation_core6.insertColumns)(node.table) : (0, import_validation_core6.selectColumns)(node.table);
-  return (0, import_validation_core6.nestedNodeColumns)(all, node);
+  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) {
+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;
@@ -1418,12 +1429,20 @@ function renderNestedObject(node, mode, coerceDates, typedJson, applyDefaults) {
     lengths,
     cardinalities,
     tj,
-    applyDefaults
+    applyDefaults,
+    brands ? { plan: brands, tsName: node.table.tsName } : void 0
   );
   const arms = node.arms.map((arm) => {
-    const notes = (0, import_validation_core6.nestedArmNotes)(arm).map((n) => `  // ${n}
+    const notes = (0, import_validation_core7.nestedArmNotes)(arm).map((n) => `  // ${n}
 `).join("");
-    const child = renderNestedObject(arm.child, mode, coerceDates, typedJson, applyDefaults);
+    const child = renderNestedObject(
+      arm.child,
+      mode,
+      coerceDates,
+      typedJson,
+      applyDefaults,
+      brands
+    );
     const inner = arm.single ? `${NS}.NullOr(
 ${indentBlock(indentBlock(child))}
   )` : `${NS}.Array(
@@ -1436,14 +1455,14 @@ ${indentBlock(indentBlock(child))}
 ${body}
 })`, rowSteps(rows, cols));
 }
-function renderNestedSchemas(table, affix, coerceDates, typedJson, applyDefaults, plans) {
+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_core6.nestedSchemaName)(mode, table.tsName, affix);
-    const tname = (0, import_validation_core6.nestedTypeName)(mode, table.tsName, affix);
-    const expr = renderNestedObject(plan, mode, coerceDates, typedJson, applyDefaults);
+    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};
 
@@ -1460,16 +1479,16 @@ function nestedPlansFor(table, analysis, depth) {
   const out = {};
   for (const mode of ["insert", "select"]) {
     if (mode === "insert" && table.readOnly) continue;
-    const plan = (0, import_validation_core6.buildNestedPlan)(table, analysis.tables, analysis.relations ?? [], mode, depth);
+    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 = {}) {
+function renderTableSchemas(table, affix, coerceDates, typedJson, applyDefaults = false, wantsDuplicateFinder = false, nested = {}, brands) {
   const T = table.tsName;
-  const insertCols = (0, import_validation_core6.insertColumns)(table);
-  const updateCols = (0, import_validation_core6.updateColumns)(table);
-  const selectCols = (0, import_validation_core6.selectColumns)(table);
+  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 = [
@@ -1478,8 +1497,8 @@ function renderTableSchemas(table, affix, coerceDates, typedJson, applyDefaults
     ["select", selectCols]
   ];
   const blocks = modes.map(([mode, cols]) => {
-    const name = (0, import_validation_core6.schemaName)(mode, T, affix);
-    const tname = (0, import_validation_core6.typeName)(mode, T, affix);
+    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,
@@ -1491,7 +1510,8 @@ function renderTableSchemas(table, affix, coerceDates, typedJson, applyDefaults
       // 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
+      applyDefaults,
+      brands ? { plan: brands, tsName: T } : void 0
     );
     const expr = piped(`${NS}.Struct({
 ${body}
@@ -1522,7 +1542,7 @@ export const ${STANDARD_PREFIX}${name} = ${NS}.standardSchemaV1(${name});`;
   const needsJson = !typedJson && [...insertCols, ...updateCols, ...selectCols, ...nestedCols].some(
     (c) => c.shape?.kind === "json"
   );
-  const finder = wantsDuplicateFinder ? (0, import_validation_core6.renderDuplicateFinder)(table, `findDuplicate${T}`, (0, import_validation_core6.typeName)("insert", T, affix)) : void 0;
+  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}
 ` : "";
@@ -1532,13 +1552,22 @@ ${finder}
     coerceDates,
     typedJson,
     applyDefaults,
-    nested
+    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")}
-${nestedCode}${duplicates}`;
+${brandCode}${nestedCode}${duplicates}`;
 }
 function buildHeader3(h) {
   if (h && h.enabled === false) return "";
@@ -1550,11 +1579,11 @@ function buildHeader3(h) {
   ];
   return lines.join("\n") + "\n\n";
 }
-var import_validation_core6, DEFAULT_FILE_SUFFIX2, STANDARD_PREFIX, NS, OPS, JSON_CONST, JSON_PREAMBLE, UNKNOWN_EXPR, EffectGenerator, index_default3;
+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_core6 = require("@drzl/validation-core");
+    import_validation_core7 = require("@drzl/validation-core");
     DEFAULT_FILE_SUFFIX2 = ".effect.ts";
     STANDARD_PREFIX = "Standard";
     NS = "Schema";
@@ -1612,12 +1641,12 @@ const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(()
         const out = path6.resolve(process.cwd(), opts.outDir);
         const files = [];
         await fs3.mkdir(out, { recursive: true });
-        const affix = (0, import_validation_core6.resolveAffix)(opts);
+        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_core6.resolveConfiguredImport)(
+          schemaSpecifier: (0, import_validation_core7.resolveConfiguredImport)(
             opts.schemaPath,
             out,
             process.cwd(),
@@ -1630,9 +1659,11 @@ const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(()
             "[drzl] typedJson was requested but the schema path is unknown, so json columns keep their wide type."
           );
         }
-        const nestedDepth = opts.nestedSchemas ? (0, import_validation_core6.resolveNestedDepth)(opts.nestedDepth, (m) => console.warn(m)) : 0;
+        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_core6.moduleFileName)(table.tsName, fileSuffix));
+          const filePath = path6.join(out, (0, import_validation_core7.moduleFileName)(table.tsName, fileSuffix));
           const code = renderTableSchemas(
             table,
             affix,
@@ -1640,9 +1671,10 @@ const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(()
             typedJson,
             !!opts.applyDefaults,
             !!opts?.duplicateFinder,
-            opts.nestedSchemas ? nestedPlansFor(table, this.analysis, nestedDepth) : {}
+            opts.nestedSchemas ? nestedPlansFor(table, this.analysis, nestedDepth) : {},
+            brands
           );
-          const formatted = await (0, import_validation_core6.formatCode)(
+          const formatted = await (0, import_validation_core7.formatCode)(
             buildHeader3(opts.outputHeader) + code,
             filePath,
             opts.format
@@ -1651,7 +1683,7 @@ const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(()
           files.push(filePath);
         }
         const indexPath = path6.join(out, "index.ts");
-        const indexFormatted = await (0, import_validation_core6.formatCode)(
+        const indexFormatted = await (0, import_validation_core7.formatCode)(
           buildHeader3(opts.outputHeader) + this.defaultIndex(this.analysis, opts),
           indexPath,
           opts.format
@@ -1663,17 +1695,19 @@ const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(()
       renderTable(table, opts) {
         return renderTableSchemas(
           table,
-          (0, import_validation_core6.resolveAffix)(opts),
+          (0, import_validation_core7.resolveAffix)(opts),
           opts?.coerceDates ?? "input",
           void 0,
           !!opts?.applyDefaults,
-          !!opts?.duplicateFinder
+          !!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_core6.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
+          (t) => `export * from '${(0, import_validation_core7.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
         ).join("\n") + "\n";
       }
     };
@@ -1682,7 +1716,7 @@ const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(()
 });
 
 // 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);
@@ -1706,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 ? {
@@ -1713,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 } : {}
   };
 }
 
@@ -1737,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")
@@ -1816,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.
@@ -1832,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(),
@@ -1926,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),
@@ -1952,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
@@ -2145,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);
@@ -2187,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);
@@ -2445,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);
@@ -2645,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({
@@ -2693,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
@@ -2732,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({
@@ -2740,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;
@@ -2832,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`));
@@ -2906,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`));
@@ -2974,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
@@ -2994,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
@@ -3096,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) {
@@ -3201,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`),
@@ -3261,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`),