@drzl/cli 4.36.0 → 4.38.0

package/dist/cli.cjs

@@ -515,8 +515,11 @@ var GeneratorKindSchema = import_zod.z.enum([
   "next",
   "tanstack-start",
   "ts-rest",
+  "openapi-fetch",
+  "forms",
   "seed",
   "fast-check",
+  "pothos",
   "service",
   "zod",
   "valibot",
@@ -561,6 +564,13 @@ var GeneratorSchema = import_zod.z.object({
   contractName: import_zod.z.string().optional(),
   /** The identifier the assembled Elysia app is exported as. `elysia` only, defaults to `'app'`. */
   appName: import_zod.z.string().optional(),
+  /**
+   * The factory the emitted client exports. `openapi-fetch` only, defaults to `'createApiClient'`.
+   *
+   * A factory rather than a constructed client, because a client carries a `baseUrl` and a `fetch`
+   * and neither is a fact about a Drizzle schema.
+   */
+  clientName: import_zod.z.string().optional(),
   /** How many rows each generated seed function returns by default. `seed` only, defaults to 10. */
   count: import_zod.z.number().int().positive().optional(),
   /**
@@ -670,7 +680,24 @@ var GeneratorSchema = import_zod.z.object({
    */
   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()
+    import_zod.z.object({
+      enabled: import_zod.z.boolean().optional(),
+      description: import_zod.z.boolean().optional(),
+      /**
+       * Also give each schema an `id`, which registers it in zod's registry under that name.
+       *
+       * `z.toJSONSchema` then emits `$ref: '#/$defs/<id>'` wherever one schema references
+       * another instead of inlining a copy, and `z.toJSONSchema(z.globalRegistry)` returns a
+       * `{ schemas: { <id>: ... } }` bundle, which is what makes a generated document
+       * self-describing.
+       *
+       * Off by default because it is the one metadata key with a failure mode. Measured on zod
+       * 4.4.3, two schemas sharing an id make a registry dump silently drop one of them, with
+       * no warning. The id is built from the qualified table name, so an analysis cannot
+       * produce two the same.
+       */
+      registryIds: 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
@@ -743,7 +770,28 @@ var GeneratorSchema = import_zod.z.object({
    * in JSON Schema, it is ignored, so emitting the wrong dialect produces a document that
    * validates and then accepts the values the constraints exist to reject.
    */
-  target: import_zod.z.enum(["draft-2020-12", "openapi-3.1", "openapi-3.0"]).optional(),
+  /**
+   * The `forms` generator reads the same key with its own values: which form library to emit for,
+   * defaulting to `react-hook-form`. One key, two kinds, as `document` already is for
+   * `json-schema` and `openapi-fetch`. A value from the wrong set on the wrong kind is reported
+   * by that generator rather than accepted, since neither shares a value with the other.
+   */
+  target: import_zod.z.enum([
+    "draft-2020-12",
+    "openapi-3.1",
+    "openapi-3.0",
+    "react-hook-form",
+    "tanstack-form",
+    "both"
+  ]).optional(),
+  /**
+   * Which operations get a resolver. `forms` only, defaults to insert and update.
+   *
+   * `select` is offered because a filter form is a form, but it is off by default: a select
+   * schema describes a row that came out of the database, so validating user input against it
+   * asks for the generated columns a form never supplies.
+   */
+  modes: import_zod.z.array(import_zod.z.enum(["insert", "update", "select"])).optional(),
   /** Also emit `components.ts` for the `json-schema` generator, ready for an OpenAPI document. */
   components: import_zod.z.boolean().optional(),
   /**
@@ -753,6 +801,11 @@ var GeneratorSchema = import_zod.z.object({
    * `true` is the short form. The object form carries the three things a Drizzle schema genuinely
    * cannot say: what the API is called, where it is served, and which status code that particular
    * server answers a request that fails its schema with.
+   *
+   * **The `openapi-fetch` generator reads the same key**, and the two have to be given the same
+   * value where both are configured. They are separate generators and nothing checks one against
+   * the other, so different options produce a client that describes a different API from the
+   * document beside it. The one that bites is `validationStatus`, which lands in both outputs.
    */
   document: import_zod.z.union([
     import_zod.z.boolean(),
@@ -987,7 +1040,9 @@ var ROUTER_KINDS = /* @__PURE__ */ new Set([
   "h3",
   "effect-http",
   "ts-rest",
-  "elysia"
+  "elysia",
+  "openapi-fetch",
+  "forms"
 ]);
 var INJECTION_KINDS = /* @__PURE__ */ new Set(["orpc", "trpc"]);
 function trpcOutDir(g, cfg) {
@@ -1029,6 +1084,12 @@ function effectHttpOutDir(g, cfg) {
 function tsRestOutDir(g, cfg) {
   return g.path ?? cfg.outDir;
 }
+function openApiFetchOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
+function formsOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
 function elysiaOutDir(g, cfg) {
   return g.path ?? cfg.outDir;
 }
@@ -1038,6 +1099,9 @@ function seedOutDir(g, cfg) {
 function fastCheckOutDir(g, cfg) {
   return g.path ?? cfg.outDir;
 }
+function pothosOutDir(g, cfg) {
+  return g.path ?? cfg.outDir;
+}
 function sharedSchemaNames(opts) {
   const resolved = (0, import_validation_core.resolveAffix)(opts);
   return import_validation_core.NAME_MODES.map((mode) => (0, import_validation_core.schemaName)(mode, import_validation_core.AFFIX_PROBE_TABLE, resolved));
@@ -1354,8 +1418,11 @@ function computeGeneratorOutputDirs(cfg, cwd = process.cwd()) {
     if (g.kind === "effect-http") dirs.add(abs(effectHttpOutDir(g, cfg)));
     if (g.kind === "ts-rest") dirs.add(abs(tsRestOutDir(g, cfg)));
     if (g.kind === "elysia") dirs.add(abs(elysiaOutDir(g, cfg)));
+    if (g.kind === "openapi-fetch") dirs.add(abs(openApiFetchOutDir(g, cfg)));
+    if (g.kind === "forms") dirs.add(abs(formsOutDir(g, cfg)));
     if (g.kind === "seed") dirs.add(abs(seedOutDir(g, cfg)));
     if (g.kind === "fast-check") dirs.add(abs(fastCheckOutDir(g, cfg)));
+    if (g.kind === "pothos") dirs.add(abs(pothosOutDir(g, cfg)));
     if (g.kind === "service") dirs.add(abs(g.path ?? "src/services"));
     if (g.kind === "zod") dirs.add(abs(g.path ?? "src/validators/zod"));
     if (g.kind === "valibot") dirs.add(abs(g.path ?? "src/validators/valibot"));
@@ -1608,20 +1675,81 @@ function tsRestOptions(g, cfg) {
   };
 }
 
-// src/elysia-options.ts
+// src/openapi-fetch-options.ts
 var VALIDATOR_DEFAULT_DIRS3 = {
+  zod: "src/validators/zod",
+  valibot: "src/validators/valibot",
+  arktype: "src/validators/arktype"
+};
+function projectRelative3(p) {
+  return p.startsWith("./") ? p.slice(2) : p;
+}
+function openApiFetchOptions(g, cfg) {
+  const configured = g.validation?.library ?? "zod";
+  const library = configured === "typebox" ? "zod" : configured;
+  const siblings = cfg.generators.filter((s) => s.kind === library);
+  const derived = siblings.length === 1 ? projectRelative3(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS3[library]) : void 0;
+  return {
+    outputDir: openApiFetchOutDir(g, cfg),
+    clientName: g.clientName,
+    document: g.document,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    importExtension: g.importExtension,
+    validation: {
+      ...g.validation,
+      library,
+      useShared: true,
+      importPath: g.validation?.importPath ?? derived
+    }
+  };
+}
+
+// src/forms-options.ts
+var VALIDATOR_DEFAULT_DIRS4 = {
+  zod: "src/validators/zod",
+  valibot: "src/validators/valibot",
+  arktype: "src/validators/arktype",
+  typebox: "src/validators/typebox",
+  effect: "src/validators/effect"
+};
+function projectRelative4(p) {
+  return p.startsWith("./") ? p.slice(2) : p;
+}
+function formsOptions(g, cfg) {
+  const library = g.validation?.library ?? "zod";
+  const siblings = cfg.generators.filter((s) => s.kind === library);
+  const derived = siblings.length === 1 ? projectRelative4(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS4[library]) : void 0;
+  return {
+    outputDir: formsOutDir(g, cfg),
+    target: g.target,
+    modes: g.modes,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    importExtension: g.importExtension,
+    validation: {
+      ...g.validation,
+      library,
+      useShared: true,
+      importPath: g.validation?.importPath ?? derived
+    }
+  };
+}
+
+// src/elysia-options.ts
+var VALIDATOR_DEFAULT_DIRS5 = {
   zod: "src/validators/zod",
   valibot: "src/validators/valibot",
   arktype: "src/validators/arktype",
   typebox: "src/validators/typebox"
 };
-function projectRelative3(p) {
+function projectRelative5(p) {
   return p.startsWith("./") ? p.slice(2) : p;
 }
 function elysiaOptions(g, cfg) {
   const library = g.validation?.library ?? "zod";
   const siblings = cfg.generators.filter((s) => s.kind === library);
-  const derived = siblings.length === 1 ? projectRelative3(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS3[library]) : void 0;
+  const derived = siblings.length === 1 ? projectRelative5(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS5[library]) : void 0;
   return {
     outputDir: elysiaOutDir(g, cfg),
     appName: g.appName,
@@ -1662,20 +1790,31 @@ function fastCheckOptions(g, cfg) {
   };
 }
 
+// src/pothos-options.ts
+function pothosOptions(g, cfg) {
+  return {
+    outputDir: pothosOutDir(g, cfg),
+    naming: g.naming,
+    outputHeader: g.outputHeader,
+    format: g.format,
+    importExtension: g.importExtension
+  };
+}
+
 // src/h3-options.ts
-var VALIDATOR_DEFAULT_DIRS4 = {
+var VALIDATOR_DEFAULT_DIRS6 = {
   zod: "src/validators/zod",
   valibot: "src/validators/valibot",
   arktype: "src/validators/arktype"
 };
-function projectRelative4(p) {
+function projectRelative6(p) {
   return p.startsWith("./") ? p.slice(2) : p;
 }
 function h3Options(g, cfg) {
   const configured = g.validation?.library ?? "zod";
   const library = configured === "typebox" ? "zod" : configured;
   const siblings = cfg.generators.filter((s) => s.kind === library);
-  const derived = siblings.length === 1 ? projectRelative4(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS4[library]) : void 0;
+  const derived = siblings.length === 1 ? projectRelative6(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS6[library]) : void 0;
   return {
     outputDir: h3OutDir(g, cfg),
     h3: g.h3,
@@ -1709,19 +1848,19 @@ function mcpOptions(g, cfg) {
 }
 
 // src/next-options.ts
-var VALIDATOR_DEFAULT_DIRS5 = {
+var VALIDATOR_DEFAULT_DIRS7 = {
   zod: "src/validators/zod",
   valibot: "src/validators/valibot",
   arktype: "src/validators/arktype"
 };
-function projectRelative5(p) {
+function projectRelative7(p) {
   return p.startsWith("./") ? p.slice(2) : p;
 }
 function nextOptions(g, cfg) {
   const configured = g.validation?.library ?? "zod";
   const library = configured === "typebox" ? "zod" : configured;
   const siblings = cfg.generators.filter((s) => s.kind === library);
-  const derived = siblings.length === 1 ? projectRelative5(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS5[library]) : void 0;
+  const derived = siblings.length === 1 ? projectRelative7(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS7[library]) : void 0;
   return {
     outputDir: nextOutDir(g, cfg),
     naming: g.naming,
@@ -1738,19 +1877,19 @@ function nextOptions(g, cfg) {
 }
 
 // src/tanstack-start-options.ts
-var VALIDATOR_DEFAULT_DIRS6 = {
+var VALIDATOR_DEFAULT_DIRS8 = {
   zod: "src/validators/zod",
   valibot: "src/validators/valibot",
   arktype: "src/validators/arktype"
 };
-function projectRelative6(p) {
+function projectRelative8(p) {
   return p.startsWith("./") ? p.slice(2) : p;
 }
 function tanstackStartOptions(g, cfg) {
   const configured = g.validation?.library ?? "zod";
   const library = configured === "typebox" ? "zod" : configured;
   const siblings = cfg.generators.filter((s) => s.kind === library);
-  const derived = siblings.length === 1 ? projectRelative6(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS6[library]) : void 0;
+  const derived = siblings.length === 1 ? projectRelative8(siblings[0].path ?? VALIDATOR_DEFAULT_DIRS8[library]) : void 0;
   return {
     outputDir: tanstackStartOutDir(g, cfg),
     naming: g.naming,
@@ -1834,7 +1973,7 @@ function trpcOptions(g, cfg, servicesDir) {
 }
 
 // src/generator-registry.ts
-var VALIDATOR_DEFAULT_DIRS7 = {
+var VALIDATOR_DEFAULT_DIRS9 = {
   zod: "src/validators/zod",
   valibot: "src/validators/valibot",
   arktype: "src/validators/arktype",
@@ -1867,10 +2006,14 @@ var GENERATORS = [
     //
     // The side effect was invisible and lasted longer than the reason: tsup externalises
     // `dependencies` and `peerDependencies` and bundles everything else, so those eight travelled
-    // inside `dist` while the other six were resolved from `node_modules`. All fourteen are on the
-    // registry now and all fourteen are `dependencies`, which is what makes every one of them a
-    // package that can genuinely be absent, and `loadGenerator` tell absence apart from failure
-    // for every kind rather than for six of them.
+    // inside `dist` while the rest were resolved from `node_modules`. Every generator package is on
+    // the registry now and every one is a `dependencies` entry, which is what makes each of them a
+    // package that can genuinely be absent, and `loadGenerator` tell absence apart from failure for
+    // every kind rather than for some of them.
+    //
+    // Counted nowhere on purpose. This paragraph twice carried a number that the next batch of
+    // generators falsified, and `packages/cli/test/generator-registry.spec.ts` asserts the property
+    // against the manifest, which is where a quantity belongs.
     specifier: "@drzl/generator-trpc",
     load: () => import("@drzl/generator-trpc"),
     construct: (m, analysis) => new m.TRPCGenerator(analysis),
@@ -1922,9 +2065,10 @@ var GENERATORS = [
     // This one and the three below spent one release each in `optionalDependencies`, because a
     // package that has never existed cannot publish through npm's trusted-publisher OIDC flow and
     // naming it as a hard dependency in the release that introduces it breaks `npm i @drzl/cli`
-    // for everyone until the first publish lands. All four are on the registry now, so all four
-    // are ordinary dependencies. `scripts/verify/stages/33-registry-deps.sh` gates both halves of
-    // that rule and is what reported the promotion was due.
+    // for everyone until the first publish lands. The six generators added after them went the
+    // same way and were promoted the same way once their first versions were published by hand.
+    // Nothing here is optional any more. `scripts/verify/stages/33-registry-deps.sh` gates both
+    // halves of that rule and is what reported each promotion was due.
     specifier: "@drzl/generator-mcp",
     load: () => import("@drzl/generator-mcp"),
     construct: (m, analysis) => new m.MCPGenerator(analysis),
@@ -1979,6 +2123,22 @@ var GENERATORS = [
     outputDir: (g, cfg) => tsRestOutDir(g, cfg),
     options: (g, cfg) => tsRestOptions(g, cfg)
   },
+  {
+    kind: "openapi-fetch",
+    specifier: "@drzl/generator-openapi-fetch",
+    load: () => import("@drzl/generator-openapi-fetch"),
+    construct: (m, analysis) => new m.OpenApiFetchGenerator(analysis),
+    outputDir: (g, cfg) => openApiFetchOutDir(g, cfg),
+    options: (g, cfg) => openApiFetchOptions(g, cfg)
+  },
+  {
+    kind: "forms",
+    specifier: "@drzl/generator-forms",
+    load: () => import("@drzl/generator-forms"),
+    construct: (m, analysis) => new m.FormsGenerator(analysis),
+    outputDir: (g, cfg) => formsOutDir(g, cfg),
+    options: (g, cfg) => formsOptions(g, cfg)
+  },
   {
     kind: "elysia",
     specifier: "@drzl/generator-elysia",
@@ -2003,6 +2163,14 @@ var GENERATORS = [
     outputDir: (g, cfg) => fastCheckOutDir(g, cfg),
     options: (g, cfg) => fastCheckOptions(g, cfg)
   },
+  {
+    kind: "pothos",
+    specifier: "@drzl/generator-pothos",
+    load: () => import("@drzl/generator-pothos"),
+    construct: (m, analysis) => new m.PothosGenerator(analysis),
+    outputDir: (g, cfg) => pothosOutDir(g, cfg),
+    options: (g, cfg) => pothosOptions(g, cfg)
+  },
   {
     kind: "service",
     specifier: "@drzl/generator-service",
@@ -2016,7 +2184,7 @@ var GENERATORS = [
     specifier: "@drzl/generator-zod",
     load: () => import("@drzl/generator-zod"),
     construct: (m, analysis) => new m.ZodGenerator(analysis),
-    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS7.zod,
+    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS9.zod,
     // `meta` is zod-only; see `GeneratorCapabilities.meta` for why it is not passed to the other
     // four rather than being passed and ignored.
     options: (g, cfg, ctx) => validationOptions(g, cfg, ctx.outDir, {
@@ -2030,7 +2198,7 @@ var GENERATORS = [
     specifier: "@drzl/generator-valibot",
     load: () => import("@drzl/generator-valibot"),
     construct: (m, analysis) => new m.ValibotGenerator(analysis),
-    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS7.valibot,
+    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS9.valibot,
     options: (g, cfg, ctx) => validationOptions(g, cfg, ctx.outDir, { schemaTypes: true, constraints: true })
   },
   {
@@ -2038,7 +2206,7 @@ var GENERATORS = [
     specifier: "@drzl/generator-arktype",
     load: () => import("@drzl/generator-arktype"),
     construct: (m, analysis) => new m.ArkTypeGenerator(analysis),
-    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS7.arktype,
+    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS9.arktype,
     options: (g, cfg, ctx) => validationOptions(g, cfg, ctx.outDir, { schemaTypes: false })
   },
   {
@@ -2046,7 +2214,7 @@ var GENERATORS = [
     specifier: "@drzl/generator-typebox",
     load: () => import("@drzl/generator-typebox"),
     construct: (m, analysis) => new m.TypeBoxGenerator(analysis),
-    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS7.typebox,
+    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS9.typebox,
     options: (g, cfg, ctx) => validationOptions(g, cfg, ctx.outDir, { schemaTypes: true, standardSchema: true })
   },
   {
@@ -2054,7 +2222,7 @@ var GENERATORS = [
     specifier: "@drzl/generator-effect",
     load: () => import("@drzl/generator-effect"),
     construct: (m, analysis) => new m.EffectGenerator(analysis),
-    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS7.effect,
+    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS9.effect,
     options: (g, cfg, ctx) => validationOptions(g, cfg, ctx.outDir, { schemaTypes: true })
   },
   {
@@ -2062,7 +2230,7 @@ var GENERATORS = [
     specifier: "@drzl/generator-json-schema",
     load: () => import("@drzl/generator-json-schema"),
     construct: (m, analysis) => new m.JsonSchemaGenerator(analysis),
-    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS7["json-schema"],
+    outputDir: (g) => g.path ?? VALIDATOR_DEFAULT_DIRS9["json-schema"],
     options: (g, cfg, ctx) => jsonSchemaOptions(g, cfg, ctx.outDir)
   }
 ];
@@ -2246,6 +2414,101 @@ var import_validation_core3 = require("@drzl/validation-core");
 
 // src/doctor.ts
 var import_validation_core2 = require("@drzl/validation-core");
+
+// src/auth-tables.ts
+var SIGNATURES = [
+  {
+    model: "account",
+    // `providerId` beside `accountId` is the distinctive pair: it is a link to an external identity
+    // provider, which an application table has no reason to model this way.
+    required: ["accountId", "providerId", "userId"],
+    supporting: ["accessToken", "refreshToken", "idToken", "password", "scope"],
+    conventionalName: "account",
+    secrets: ["accessToken", "refreshToken", "idToken", "password"]
+  },
+  {
+    model: "session",
+    required: ["token", "expiresAt", "userId"],
+    supporting: ["ipAddress", "userAgent"],
+    conventionalName: "session",
+    // A session token is a bearer credential: whoever reads it is that user until it expires.
+    secrets: ["token"]
+  },
+  {
+    model: "verification",
+    // `identifier` and `value` are deliberately generic names, which is why `expiresAt` is required
+    // too: the three together are a short-lived token store and little else.
+    required: ["identifier", "value", "expiresAt"],
+    supporting: [],
+    conventionalName: "verification",
+    secrets: ["value"]
+  },
+  {
+    model: "user",
+    required: ["email", "emailVerified"],
+    supporting: ["name", "image"],
+    conventionalName: "user",
+    secrets: []
+  }
+];
+function columnKeys(table) {
+  const out = /* @__PURE__ */ new Map();
+  for (const c of table.columns) out.set(normalise(c.name), c);
+  return out;
+}
+function normalise(name) {
+  return name.replace(/[_-]/g, "").toLowerCase();
+}
+function has(keys, name) {
+  return keys.has(normalise(name));
+}
+function actualName(table, wanted) {
+  return table.columns.find((c) => normalise(c.name) === normalise(wanted))?.name;
+}
+function matchOne(table, sig) {
+  const keys = columnKeys(table);
+  const missing = sig.required.filter((r) => !has(keys, r));
+  if (missing.length) return void 0;
+  const supporting = sig.supporting.filter((s) => has(keys, s));
+  const nameMatches = normalise(table.name) === normalise(sig.conventionalName) || normalise(table.name) === `${normalise(sig.conventionalName)}s`;
+  const confidence = supporting.length > 0 || nameMatches ? "strong" : "likely";
+  const matched = [...sig.required, ...supporting].map((c) => actualName(table, c)).filter((c) => Boolean(c));
+  const secrets = sig.secrets.map((c) => actualName(table, c)).filter((c) => Boolean(c));
+  return { table: table.name, model: sig.model, confidence, matched, secrets };
+}
+function detectAuthTables(analysis) {
+  const found = [];
+  for (const table of analysis.tables) {
+    for (const sig of SIGNATURES) {
+      const m = matchOne(table, sig);
+      if (m) {
+        found.push(m);
+        break;
+      }
+    }
+  }
+  const hasNonUser = found.some((f) => f.model !== "user");
+  return hasNonUser ? found : found.filter((f) => f.model !== "user");
+}
+function authTablesWithSecrets(matches) {
+  return matches.filter((m) => m.secrets.length > 0);
+}
+function excludeSuggestion(matches) {
+  const names = [...new Set(matches.map((m) => m.table))].sort();
+  return `exclude: [${names.map((n) => `'${n}'`).join(", ")}]`;
+}
+function authTableWarnings(analysis) {
+  const risky = authTablesWithSecrets(detectAuthTables(analysis));
+  if (!risky.length) return [];
+  const lines = risky.map(
+    (m) => `"${m.table}" looks like an authentication library's ${m.model} table and holds ${m.secrets.map((c) => `"${c}"`).join(", ")}. Generating for it publishes ${m.secrets.length === 1 ? "that column" : "those columns"}.`
+  );
+  return [
+    `drzl generate: ${lines.join(" ")} Keep ${risky.length === 1 ? "it" : "them"} out with ${excludeSuggestion(risky)}, or leave it if the route is deliberate.`
+  ];
+}
+
+// src/doctor.ts
 var import_chalk2 = require("chalk");
 var PLAIN = new import_chalk2.Chalk({ level: 0 });
 var HANDLED_CODES = /* @__PURE__ */ new Set(["DRZL_ANL_UNKNOWN_COLUMN"]);
@@ -2418,6 +2681,18 @@ function buildDoctorReport(analysis, schemaPath) {
       hint: i.hint
     });
   }
+  for (const match of detectAuthTables(analysis)) {
+    const secrets = match.secrets.length ? ` It holds ${match.secrets.map((c) => `\`${c}\``).join(", ")}, which a generated read route would return to whoever calls it.` : "";
+    findings.push({
+      kind: "auth-table",
+      // A warning rather than an error: this is a real leak and it is also a guess about someone
+      // else's schema, and a doctor that failed the build on a guess would be switched off.
+      level: "warn",
+      table: match.table,
+      message: `"${match.table}" matches the shape of an authentication library's ${match.model} table (${match.matched.join(", ")}).${secrets}`,
+      hint: `Keep it out of every generator with ${excludeSuggestion([match])}.`
+    });
+  }
   for (const i of analysis.issues) {
     if (i.code !== "DRZL_ANL_UNKNOWN_COLUMN") continue;
     findings.push({
@@ -2456,6 +2731,11 @@ var SECTIONS = [
     title: "Columns DRZL cannot type",
     why: "These get a validator that accepts any value."
   },
+  {
+    kinds: ["auth-table"],
+    title: "Tables that look like an authentication library's",
+    why: "Every generator loops over every table it finds, so these get routes too."
+  },
   {
     kinds: ["check-declined", "check-unknown-column", "check-not-scalar", "check-uncountable"],
     title: "CHECK constraints DRZL does not enforce",
@@ -3578,6 +3858,234 @@ function renderConstraintDriftSql(report) {
   return out.join("\n");
 }
 
+// src/policy-report.ts
+var import_chalk5 = require("chalk");
+var PLAIN4 = new import_chalk5.Chalk({ level: 0 });
+var COMMANDS = ["select", "insert", "update", "delete"];
+var DENIAL = {
+  select: "every read returns zero rows",
+  insert: "every insert is refused",
+  update: "every update is refused",
+  delete: "every delete is refused"
+};
+function appliesTo(policy, command) {
+  const forCmd = (policy.for ?? "all").toLowerCase();
+  return forCmd === "all" || forCmd === command;
+}
+function grants(policy, command) {
+  if (!appliesTo(policy, command)) return false;
+  if ((policy.as ?? "permissive").toLowerCase() === "restrictive") return false;
+  const hasUsing = !!policy.using;
+  const hasCheck = !!policy.withCheck;
+  const forCmd = (policy.for ?? "all").toLowerCase();
+  if (forCmd === "all") return hasUsing || hasCheck;
+  switch (command) {
+    case "select":
+    case "delete":
+      return hasUsing;
+    case "insert":
+      return hasCheck;
+    case "update":
+      return hasCheck || hasUsing;
+  }
+}
+function hasAnyExpression(policy) {
+  return !!policy.using || !!policy.withCheck;
+}
+function readTable(table) {
+  if (typeof table.rlsEnabled !== "boolean") return void 0;
+  const policies = table.policies ?? [];
+  const declaredRls = table.rlsEnabled;
+  const effective = declaredRls || policies.length > 0;
+  if (!effective) return void 0;
+  const grantMap = {};
+  for (const c of COMMANDS) grantMap[c] = policies.some((p) => grants(p, c));
+  return { table: table.name, declaredRls, effective, policies, grants: grantMap };
+}
+function buildPolicyReport(analysis, schemaPath) {
+  const tables = [];
+  const findings = [];
+  for (const table of analysis.tables) {
+    const read = readTable(table);
+    if (!read) continue;
+    tables.push(read);
+    if (COMMANDS.every((c) => !read.grants[c])) {
+      findings.push({
+        kind: "denied",
+        table: read.table,
+        detail: "row-level security is on and no permissive policy grants anything, so every read returns zero rows and every write is refused, for every role but the table's owner and any role with BYPASSRLS",
+        // Deliberately not "give it a USING": a policy written `FOR INSERT` consults only its
+        // WITH CHECK, so that advice would be wrong for exactly the declaration this report exists
+        // to catch. The per-policy findings below name the right expression for each one.
+        fix: read.policies.length ? `no policy here grants a command: ${read.policies.map((p) => `"${p.name}"`).join(", ")} ${read.policies.length === 1 ? "needs" : "need"} a USING expression, or a WITH CHECK where the command is INSERT` : "declare a policy, or drop the row-level security on this table"
+      });
+    } else {
+      for (const command of COMMANDS) {
+        if (read.grants[command]) continue;
+        const named = read.policies.filter((p) => appliesTo(p, command));
+        findings.push({
+          kind: "denied",
+          table: read.table,
+          command,
+          detail: `row-level security is on and no permissive policy grants ${command.toUpperCase()}, so ${DENIAL[command]} for every role but the table's owner and any role with BYPASSRLS`,
+          fix: named.length ? `${named.length === 1 ? "the policy" : "the policies"} ${named.map((p) => `"${p.name}"`).join(", ")} name${named.length === 1 ? "s" : ""} ${command.toUpperCase()} but grant${named.length === 1 ? "s" : ""} nothing; give ${command === "insert" ? "it a WITH CHECK" : "it a USING"} expression` : `declare a policy for ${command.toUpperCase()}, or drop the row-level security on this table`
+        });
+      }
+    }
+    for (const policy of read.policies) {
+      if (hasAnyExpression(policy)) continue;
+      findings.push({
+        kind: "grants-nothing",
+        table: read.table,
+        policy: policy.name,
+        detail: "the policy carries neither a USING nor a WITH CHECK expression, so it permits nothing and only the policies beside it decide what this table allows",
+        fix: (policy.for ?? "all").toLowerCase() === "insert" ? "give it a WITH CHECK expression, which is the only one INSERT consults" : "give it a USING expression, and a WITH CHECK too where writes need a different rule"
+      });
+    }
+  }
+  const policies = tables.reduce((n, t) => n + t.policies.length, 0);
+  return {
+    schema: schemaPath,
+    dialect: analysis.dialect,
+    ok: findings.length === 0,
+    counts: {
+      tables: analysis.tables.length,
+      withRls: tables.length,
+      policies,
+      findings: findings.length
+    },
+    tables,
+    findings,
+    ignoredByGeneratedCode: tables.map((t) => t.table)
+  };
+}
+function wrap4(text, indent, first = indent, width = 96) {
+  const words = text.split(/\s+/).filter(Boolean);
+  const lines = [];
+  let line = first;
+  let started = false;
+  for (const w of words) {
+    if (started && line.length + 1 + w.length > width) {
+      lines.push(line);
+      line = indent + w;
+    } else {
+      line = started ? `${line} ${w}` : line + w;
+      started = true;
+    }
+  }
+  if (started) lines.push(line);
+  return lines.join("\n");
+}
+function policyLine(policy) {
+  const bits = [(policy.for ?? "all").toUpperCase()];
+  if ((policy.as ?? "").toLowerCase() === "restrictive") bits.push("restrictive");
+  bits.push(policy.to?.length ? `to ${policy.to.join(", ")}` : "to public");
+  const carries = [policy.using ? "USING" : void 0, policy.withCheck ? "WITH CHECK" : void 0].filter(Boolean).join(" + ");
+  bits.push(carries || "no expression");
+  if (policy.linked) bits.push("linked");
+  return bits.join(", ");
+}
+function renderPolicyReport(report, style = PLAIN4) {
+  const chalk = style;
+  const out = [];
+  const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
+  out.push(chalk.bold(`DRZL row-level security  ${report.schema}`));
+  out.push(
+    chalk.dim(
+      `${report.dialect}, ${plural(report.counts.withRls, "table")} under RLS, ${plural(report.counts.policies, "policy").replace("policys", "policies")}`
+    )
+  );
+  out.push("");
+  if (!report.counts.withRls) {
+    out.push(chalk.green("No table in this schema uses row-level security."));
+    if (report.dialect !== "postgres" && report.dialect !== "cockroach") {
+      out.push(chalk.dim(`  ${report.dialect} has no row-level security to declare.`));
+    } else {
+      out.push(chalk.dim("  No table calls .enableRLS() and none declares a pgPolicy."));
+    }
+    return out.join("\n");
+  }
+  const denied = report.findings.filter((f) => f.kind === "denied");
+  if (denied.length) {
+    out.push(chalk.red("These tables refuse the operation your generated code performs"));
+    out.push(
+      chalk.dim(
+        wrap4(
+          "A table under row-level security permits only what a policy grants. The generated service still compiles and its return type still promises rows.",
+          "  "
+        )
+      )
+    );
+    out.push("");
+    for (const f of denied) {
+      out.push(`  ${chalk.dim("-")} ${chalk.bold(f.table)} ${chalk.dim(f.command ?? "everything")}`);
+      out.push(wrap4(f.detail, "      "));
+      if (f.fix) out.push(chalk.dim(wrap4(f.fix, "      ", "      Close it: ")));
+      out.push("");
+    }
+  }
+  const dead = report.findings.filter((f) => f.kind === "grants-nothing");
+  if (dead.length) {
+    out.push(chalk.yellow("These policies grant nothing"));
+    out.push(
+      chalk.dim(
+        wrap4(
+          "A policy with neither expression is not a permissive default. Measured against Postgres 18.3: a lone FOR INSERT policy carrying no WITH CHECK refused every insert.",
+          "  "
+        )
+      )
+    );
+    out.push("");
+    for (const f of dead) {
+      out.push(`  ${chalk.dim("-")} ${chalk.bold(f.table)}.${f.policy}`);
+      out.push(wrap4(f.detail, "      "));
+      if (f.fix) out.push(chalk.dim(wrap4(f.fix, "      ", "      Close it: ")));
+      out.push("");
+    }
+  }
+  out.push(chalk.cyan("The policies each table carries"));
+  out.push(
+    chalk.dim(
+      wrap4(
+        "Whether these apply to the role your application connects as is the one question this report cannot answer for you.",
+        "  "
+      )
+    )
+  );
+  out.push("");
+  for (const t of report.tables) {
+    const flag = t.declaredRls ? "enableRLS()" : "RLS on, implied by its policies";
+    out.push(`  ${chalk.dim("-")} ${chalk.bold(t.table)} ${chalk.dim(`(${flag})`)}`);
+    if (!t.policies.length) {
+      out.push(chalk.dim("      no policies"));
+    }
+    for (const p of t.policies) {
+      out.push(`      ${p.name}: ${chalk.dim(policyLine(p))}`);
+    }
+    const permitted = COMMANDS.filter((c) => t.grants[c]);
+    out.push(
+      chalk.dim(`      permits: ${permitted.length ? permitted.join(", ") : "nothing"}`)
+    );
+    out.push("");
+  }
+  out.push(chalk.yellow("What DRZL generates does not know about any of this"));
+  out.push(
+    chalk.dim(
+      wrap4(
+        `No generator emits policy awareness, so a generated read path describes rows the caller may not be allowed to see, and a reader of the emitted types will believe otherwise. That is true of ${plural(report.ignoredByGeneratedCode.length, "table")} here, and it is a fact about DRZL rather than a defect in your schema.`,
+        "  "
+      )
+    )
+  );
+  out.push("");
+  out.push(
+    chalk.dim(
+      `${plural(report.counts.findings, "finding")} across ${plural(report.counts.withRls, "table")} under row-level security.`
+    )
+  );
+  return out.join("\n");
+}
+
 // src/drift.ts
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
@@ -4503,7 +5011,10 @@ withOutputFlags(
   program.command("doctor").description("Report what DRZL cannot type or enforce in your schema, and why").argument("[schema]", "path to drizzle schema (TS); defaults to the schema in drzl.config").option("-c, --config <path>", "path to drzl.config, read when no schema argument is given").option("--strict", "exit 2 when anything is reported", false).option(
     "--constraints",
     "report what each side enforces that the other does not, instead of the usual findings"
-  ).option("--sql", "with --constraints, emit the statements alone, for redirecting to a migration")
+  ).option("--sql", "with --constraints, emit the statements alone, for redirecting to a migration").option(
+    "--policies",
+    "report the row-level security policies each table carries, and what they refuse"
+  )
 ).action(async (schema, opts) => {
   const out = outputFor(opts);
   {
@@ -4533,7 +5044,14 @@ withOutputFlags(
         process.exit(EXIT_FAILED);
         return;
       }
-      if (opts.constraints) {
+      if (opts.constraints && opts.policies) {
+        const msg = "--constraints and --policies are separate reports. Run one, then the other.";
+        if (opts.json) out.jsonData(jsonFailure("doctor", "DRZL_CLI_DOCTOR", msg));
+        else out.error("Doctor failed (DRZL_CLI_DOCTOR):", msg);
+        process.exit(EXIT_FAILED);
+        return;
+      }
+      if (opts.constraints || opts.policies) {
         const preflight = buildDoctorReport(analysis, schemaLabel);
         const fatal = preflight.findings.filter((f) => f.level === "error");
         if (fatal.length) {
@@ -4549,6 +5067,8 @@ withOutputFlags(
           process.exit(EXIT_FAILED);
           return;
         }
+      }
+      if (opts.constraints) {
         const drift = buildConstraintDriftReport(analysis, schemaLabel);
         const driftCode = opts.strict && drift.counts.schemaOnly ? EXIT_FINDINGS : EXIT_OK;
         if (opts.sql) {
@@ -4564,6 +5084,17 @@ withOutputFlags(
         process.exit(driftCode);
         return;
       }
+      if (opts.policies) {
+        const policies = buildPolicyReport(analysis, schemaLabel);
+        const policyCode = opts.strict && policies.counts.findings ? EXIT_FINDINGS : EXIT_OK;
+        if (opts.json)
+          out.data(
+            JSON.stringify({ command: "doctor", exitCode: policyCode, ...policies }, null, 2)
+          );
+        else out.data(renderPolicyReport(policies, out.outStyle));
+        process.exit(policyCode);
+        return;
+      }
       const report = buildDoctorReport(analysis, schemaLabel);
       const unreadable = report.findings.some((f) => f.level === "error");
       const code = unreadable ? EXIT_FAILED : opts.strict && report.findings.length ? EXIT_FINDINGS : EXIT_OK;
@@ -4784,6 +5315,7 @@ withOutputFlags(
       analysis.tables = filterTables(narrowed.tables, cfg);
       for (const w of [...narrowed.warnings, ...filterWarnings]) warn(w);
       for (const w of wideColumnWarning(analysis.issues)) warn(w);
+      for (const w of authTableWarnings(analysis)) warn(w);
       const empty = nothingToGenerate({
         schema: source.schema,
         analyzed: narrowed.tables,