@drzl/cli 4.17.0 → 4.19.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_core2.resolveAffix)({
+    const sharedAffix = (0, import_validation_core3.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_core2.resolveConfiguredImport)(
+      const spec = (0, import_validation_core3.resolveConfiguredImport)(
         opts.validation.importPath,
         ctx.out,
         process.cwd(),
         opts.importExtension
       );
       const names = wanted.map(([mode, local]) => {
-        const exported = (0, import_validation_core2.schemaName)(mode, table.tsName, sharedAffix);
+        const exported = (0, import_validation_core3.schemaName)(mode, table.tsName, sharedAffix);
         return exported === local ? local : `${exported} as ${local}`;
       }).join(", ");
       imports.push(`import { ${names} } from '${spec}';`);
     }
   }
   imports.push(
-    `import { ${[builder, "router"].sort().join(", ")} } from '${(0, import_validation_core2.importSpecifier)(
+    `import { ${[builder, "router"].sort().join(", ")} } from '${(0, import_validation_core3.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_core2.importSpecifier)(`./${BASE_MODULE}.ts`, opts.importExtension);
+  const baseSpec = (0, import_validation_core3.importSpecifier)(`./${BASE_MODULE}.ts`, opts.importExtension);
   const reExports = `export { createCallerFactory, publicProcedure, router } from '${baseSpec}';
 ` + (opts.databaseInjection?.enabled === true ? `export { dbProcedure } from '${baseSpec}';
 ` : "") + `export type { Context } from '${baseSpec}';
@@ -352,7 +352,7 @@ export type AppRouter = typeof appRouter;
 ${reExports}`;
   }
   const entries = routers.map(({ filePath, exportName, table }) => ({
-    rel: (0, import_validation_core2.importSpecifier)(
+    rel: (0, import_validation_core3.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_core2.importSpecifier)(`${dir}/${singularize(table.tsName)}Service.ts`, opts.importExtension);
+  return (0, import_validation_core3.importSpecifier)(`${dir}/${singularize(table.tsName)}Service.ts`, opts.importExtension);
 }
 function relativePosix(from, to) {
   const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -413,11 +413,11 @@ function buildHeader(h) {
   ];
   return lines.join("\n") + "\n\n";
 }
-var import_validation_core2, TRPC_MAJOR, q, LIB_IMPORTS, LIB_USAGE, LIBS, cap, singularize, isIdent, BASE_MODULE, TRPCGenerator, index_default;
+var import_validation_core3, TRPC_MAJOR, q, LIB_IMPORTS, LIB_USAGE, LIBS, cap, singularize, isIdent, BASE_MODULE, TRPCGenerator, index_default;
 var init_dist = __esm({
   "../generator-trpc/dist/index.js"() {
     "use strict";
-    import_validation_core2 = require("@drzl/validation-core");
+    import_validation_core3 = require("@drzl/validation-core");
     TRPC_MAJOR = 11;
     q = (v) => JSON.stringify(v);
     LIB_IMPORTS = {
@@ -510,7 +510,7 @@ ${body}
         await fs3.mkdir(out, { recursive: true });
         const files = [];
         const write = async (filePath, content) => {
-          const formatted = await (0, import_validation_core2.formatCode)(
+          const formatted = await (0, import_validation_core3.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_core4.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core4.COLUMN_FORMATS[c.format];
+      else if (c.format && import_validation_core5.COLUMN_FORMATS[c.format]) out.pattern = import_validation_core5.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_core4.isIntegerColumn)(c) ? "integer" : "number" };
+      const out = { type: (0, import_validation_core5.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_core4.parseCheck)(k.expression, k.name));
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core5.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_core4.insertColumns)(table), "insert"),
-    update: build2((0, import_validation_core4.updateColumns)(table), "update"),
-    select: build2((0, import_validation_core4.selectColumns)(table), "select")
+    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")
   };
 }
 function componentsDocument(tables, opts = {}) {
@@ -995,9 +995,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_core3.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
+  const decl = (mode) => `export const ${(0, import_validation_core4.schemaName)(mode, T, affix)} = ${JSON.stringify(schemas[mode], null, 2)} as const;
 
-export type ${(0, import_validation_core3.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core3.schemaName)(mode, T, affix)};`;
+export type ${(0, import_validation_core4.typeName)(mode, T, affix)} = typeof ${(0, import_validation_core4.schemaName)(mode, T, affix)};`;
   return [decl("insert"), decl("update"), decl("select")].join("\n\n") + "\n";
 }
 function resolveDocument(opt) {
@@ -1013,12 +1013,12 @@ function buildHeader2(h) {
 
 `;
 }
-var import_validation_core3, import_validation_core4, DRAFT, UUID_FORMAT, base64, ERROR_SCHEMA, componentName, ref, pascal, modesFor, resourceSegment, jsonBody, errorSchema, DEFAULT_FILE_SUFFIX, JsonSchemaGenerator, index_default2;
+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 init_dist2 = __esm({
   "../generator-json-schema/dist/index.js"() {
     "use strict";
-    import_validation_core3 = require("@drzl/validation-core");
     import_validation_core4 = require("@drzl/validation-core");
+    import_validation_core5 = 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" };
@@ -1056,14 +1056,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_core3.resolveAffix)(opts);
+        const affix = (0, import_validation_core4.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_core3.moduleFileName)(table.tsName, fileSuffix));
+          const filePath = path6.join(out, (0, import_validation_core4.moduleFileName)(table.tsName, fileSuffix));
           const code = renderTableModule(table, affix, target, !!opts.applyDefaults);
-          const formatted = await (0, import_validation_core3.formatCode)(
+          const formatted = await (0, import_validation_core4.formatCode)(
             buildHeader2(opts.outputHeader) + code,
             filePath,
             opts.format
@@ -1081,7 +1081,7 @@ var init_dist2 = __esm({
 `;
           await fs3.writeFile(
             componentsPath,
-            await (0, import_validation_core3.formatCode)(buildHeader2(opts.outputHeader) + code, componentsPath, opts.format),
+            await (0, import_validation_core4.formatCode)(buildHeader2(opts.outputHeader) + code, componentsPath, opts.format),
             "utf8"
           );
           files.push(componentsPath);
@@ -1102,7 +1102,7 @@ var init_dist2 = __esm({
 `;
             await fs3.writeFile(
               tsPath,
-              await (0, import_validation_core3.formatCode)(buildHeader2(opts.outputHeader) + code, tsPath, opts.format),
+              await (0, import_validation_core4.formatCode)(buildHeader2(opts.outputHeader) + code, tsPath, opts.format),
               "utf8"
             );
             files.push(tsPath);
@@ -1116,9 +1116,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_core3.moduleSpecifier)(t.tsName, fileSuffix, opts.importExtension)}';`
+          (t) => `export * from '${(0, import_validation_core4.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_core3.formatCode)(
+        const indexFormatted = await (0, import_validation_core4.formatCode)(
           buildHeader2(opts.outputHeader) + index,
           indexPath,
           opts.format
@@ -1130,7 +1130,7 @@ var init_dist2 = __esm({
       renderTable(table, opts) {
         return renderTableModule(
           table,
-          (0, import_validation_core3.resolveAffix)(opts),
+          (0, import_validation_core4.resolveAffix)(opts),
           opts?.target ?? "draft-2020-12",
           !!opts?.applyDefaults
         );
@@ -1140,10 +1140,551 @@ var init_dist2 = __esm({
   }
 });
 
+// ../generator-effect/dist/index.js
+var dist_exports3 = {};
+__export(dist_exports3, {
+  EffectGenerator: () => EffectGenerator,
+  default: () => index_default3
+});
+function filter(expr, description) {
+  return `${NS}.filter((v) => ${expr}, { description: ${JSON.stringify(description)} })`;
+}
+function piped(base, steps) {
+  return steps.length ? `${base}.pipe(${steps.join(", ")})` : base;
+}
+function isUnknownExpr(expr) {
+  return expr === UNKNOWN_EXPR;
+}
+function withNarrowedType(expr, ref2) {
+  return `${expr} as unknown as ${NS}.Schema<${ref2}>`;
+}
+function numericBounds(c, checks) {
+  let lo = c.min !== void 0 ? { fn: "greaterThanOrEqualTo", value: c.min } : void 0;
+  let hi = c.max !== void 0 ? { fn: "lessThanOrEqualTo", value: c.max } : void 0;
+  for (const k of checks.filter((x) => x.column === c.name && x.kind === "number")) {
+    if (k.operator === ">=") lo = { fn: "greaterThanOrEqualTo", value: k.value };
+    else if (k.operator === ">") lo = { fn: "greaterThan", value: k.value };
+    else if (k.operator === "<=") hi = { fn: "lessThanOrEqualTo", value: k.value };
+    else if (k.operator === "<") hi = { fn: "lessThan", value: k.value };
+  }
+  return [lo, hi].filter(Boolean).map((x) => `${NS}.${x.fn}(${x.value})`);
+}
+function foldedIntoBounds(c, checks) {
+  if (c.arrayDimensions || c.shape) return /* @__PURE__ */ new Set();
+  if (c.tsType !== "number" && c.tsType !== "bigint") return /* @__PURE__ */ new Set();
+  return new Set(
+    checks.filter(
+      (k) => k.column === c.name && k.kind === "number" && k.operator !== "=" && k.operator !== "<>"
+    )
+  );
+}
+function nonFiniteBranches(c) {
+  const { nan, infinity } = (0, import_validation_core6.nonFiniteAccepted)(c);
+  return [
+    ...nan ? [`${NS}.Number.pipe(${filter("Number.isNaN(v)", "NaN, which this column stores")})`] : [],
+    ...infinity ? [`${NS}.Literal(Infinity, -Infinity)`] : []
+  ];
+}
+function withNonFinite(c, base) {
+  const branches = nonFiniteBranches(c);
+  return branches.length ? `${NS}.Union(${base}, ${branches.join(", ")})` : base;
+}
+function dateExpr(mode, coerceDates) {
+  const plain = `${NS}.ValidDateFromSelf`;
+  if (coerceDates === "none") return plain;
+  const fromString = piped(`${NS}.String`, [
+    `${NS}.pattern(new RegExp(${JSON.stringify(import_validation_core6.COERCIBLE_DATE_STRING)}))`,
+    filter((0, import_validation_core6.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")
+  ]);
+  const union = `${NS}.Union(${plain}, ${fromString}, ${fromNumber})`;
+  if (coerceDates === "all") return union;
+  return mode === "select" ? plain : union;
+}
+function capSteps(c, mode) {
+  const steps = [];
+  if (c.shape?.kind === "byteString") {
+    const n = c.shape.length;
+    if (!n) return steps;
+    return mode === "select" ? [filter(`${import_validation_core6.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`)
+    );
+  }
+  if (c.maxBytes) {
+    steps.push(
+      filter(`new TextEncoder().encode(v).length <= ${c.maxBytes}`, `at most ${c.maxBytes} bytes`)
+    );
+  }
+  return steps;
+}
+function lengthSteps(c, lengths) {
+  if (c.arrayDimensions || c.shape) return [];
+  return lengths.filter((k) => k.column === c.name).map(
+    (k) => filter(
+      `${import_validation_core6.CODEPOINT_LENGTH} ${OPS[k.operator]} ${k.value}`,
+      `${k.name ? `${k.name}: ` : ""}length(${c.name}) ${k.operator} ${k.value}`
+    )
+  );
+}
+function cardinalitySteps(c, cardinalities) {
+  if (!c.arrayDimensions) return [];
+  return cardinalities.filter((k) => k.column === c.name).map(
+    (k) => filter(
+      `v.length ${OPS[k.operator]} ${k.value}`,
+      `${k.name ? `${k.name}: ` : ""}cardinality(${c.name}) ${k.operator} ${k.value}`
+    )
+  );
+}
+function checkSteps(c, checks) {
+  if (c.arrayDimensions || c.shape) return [];
+  const folded = foldedIntoBounds(c, checks);
+  return checks.filter((k) => k.column === c.name && !folded.has(k)).map((k) => {
+    const literal = k.kind === "string" ? JSON.stringify(k.value) : k.value;
+    return filter(
+      `v ${OPS[k.operator]} ${literal}`,
+      `${k.name ? `${k.name}: ` : ""}${c.name} ${k.operator} ${k.value}`
+    );
+  });
+}
+function hasNoRuntimeType(c) {
+  return c.tsType === "any" || c.shape?.kind === "custom" || c.shape?.kind === "json";
+}
+function shapeExpr(c, mode, replaced = false) {
+  const s = c.shape;
+  if (!s) return void 0;
+  switch (s.kind) {
+    case "json":
+      return replaced ? UNKNOWN_EXPR : JSON_CONST;
+    case "custom":
+      return UNKNOWN_EXPR;
+    case "buffer":
+      return `${NS}.Uint8ArrayFromSelf`;
+    case "tuple":
+      return `${NS}.Tuple(${Array.from({ length: s.length }, () => `${NS}.Number`).join(", ")})`;
+    case "numberObject":
+      return `${NS}.Struct({ ${s.fields.map((f) => `${f}: ${NS}.Number`).join(", ")} })`;
+    case "numberVector":
+      return piped(
+        `${NS}.Array(${NS}.Number)`,
+        s.length ? [filter(`v.length === ${s.length}`, `exactly ${s.length} elements`)] : []
+      );
+    case "bitstring":
+      return piped(`${NS}.String`, [
+        `${NS}.pattern(/^[01]*$/)`,
+        ...s.length ? [
+          s.exact ? filter(`v.length === ${s.length}`, `exactly ${s.length} binary digits`) : filter(`v.length <= ${s.length}`, `at most ${s.length} binary digits`)
+        ] : []
+      ]);
+    case "byteString":
+      return piped(`${NS}.String`, capSteps(c, mode));
+  }
+}
+function exprForColumn(c, mode, coerceDates, checks, sets, lengths, replaced) {
+  const shaped = shapeExpr(c, mode, replaced);
+  if (shaped) return shaped;
+  const set = sets.find((x) => x.column === c.name);
+  if (set) {
+    const values = set.values.map((v) => set.kind === "string" ? JSON.stringify(v) : v);
+    return `${NS}.Literal(${values.join(", ")})`;
+  }
+  if (c.arrayDimensions) checks = [];
+  if (c.enumValues && c.enumValues.length) {
+    return `${NS}.Literal(${c.enumValues.map((v) => JSON.stringify(v)).join(", ")})`;
+  }
+  const eq = checks.find((k) => k.column === c.name && k.operator === "=");
+  if (eq && !c.shape) {
+    return `${NS}.Literal(${eq.kind === "string" ? JSON.stringify(eq.value) : eq.value})`;
+  }
+  const rest = [...checkSteps(c, checks), ...lengthSteps(c, lengths)];
+  switch (c.tsType) {
+    case "string": {
+      const base = c.format === "uuid" ? `${NS}.UUID` : `${NS}.String`;
+      const pattern = c.format && c.format !== "uuid" && import_validation_core6.COLUMN_FORMATS[c.format] ? [`${NS}.pattern(new RegExp(${JSON.stringify(import_validation_core6.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`;
+      return withNonFinite(c, piped(base, [...numericBounds(c, checks), ...rest]));
+    }
+    case "bigint":
+      return piped(`${NS}.BigIntFromSelf`, [
+        ...c.min !== void 0 ? [`${NS}.greaterThanOrEqualToBigInt(${c.min}n)`] : [],
+        ...c.max !== void 0 ? [`${NS}.lessThanOrEqualToBigInt(${c.max}n)`] : [],
+        ...rest
+      ]);
+    case "boolean":
+      return `${NS}.Boolean`;
+    case "Date":
+      return dateExpr(mode, coerceDates);
+    case "Uint8Array":
+      return `${NS}.Uint8ArrayFromSelf`;
+    case "any":
+      return UNKNOWN_EXPR;
+    default:
+      return UNKNOWN_EXPR;
+  }
+}
+function renderField(c, mode, coerceDates, checks, sets, lengths, cardinalities, applyDefault, narrowRef) {
+  let expr = exprForColumn(
+    c,
+    mode,
+    coerceDates,
+    checks,
+    sets,
+    lengths,
+    !!narrowRef && hasNoRuntimeType(c)
+  );
+  const dims = c.arrayDimensions ?? 0;
+  for (let i = 0; i < dims; i++) {
+    expr = `${NS}.Array(${expr})`;
+    if (i === dims - 1) expr = piped(expr, cardinalitySteps(c, cardinalities));
+  }
+  if (c.nullable && !isUnknownExpr(expr)) expr = `${NS}.NullOr(${expr})`;
+  if (narrowRef) expr = withNarrowedType(expr, narrowRef);
+  if (mode === "select") return expr;
+  const wantsDefault = mode === "insert" && applyDefault && c.defaultValue !== void 0;
+  if (wantsDefault) {
+    return `${NS}.optionalWith(${expr}, { default: () => ${JSON.stringify(c.defaultValue)} })`;
+  }
+  if (mode === "update" || c.nullable || c.hasDefault) return `${NS}.optional(${expr})`;
+  return expr;
+}
+function wantsRef(c, allColumns) {
+  return allColumns || hasNoRuntimeType(c);
+}
+function renderObjectShape(cols, mode, coerceDates, checks, sets, lengths, cardinalities, typedJson, applyDefaults) {
+  return cols.map((c) => {
+    const ref2 = typedJson && wantsRef(c, !!typedJson.allColumns) ? `(typeof ${typedJson.table}.$infer${typedJson.mode === "insert" ? "Insert" : "Select"})[${JSON.stringify(c.name)}]` : void 0;
+    const field2 = renderField(
+      c,
+      mode,
+      coerceDates,
+      checks,
+      sets,
+      lengths,
+      cardinalities,
+      applyDefaults,
+      ref2
+    );
+    return `  ${JSON.stringify(c.name)}: ${field2},`;
+  }).join("\n");
+}
+function rowSteps(rows, cols) {
+  const present = new Set(cols.map((c) => c.name));
+  return rows.filter((r) => present.has(r.left) && present.has(r.right)).map((r) => {
+    const l = `o[${JSON.stringify(r.left)}]`;
+    const rt = `o[${JSON.stringify(r.right)}]`;
+    const msg = `${r.name ? `${r.name}: ` : ""}${r.left} ${r.operator} ${r.right}`;
+    return `${NS}.filter((o) => ${l} == null || ${rt} == null || ${l} ${OPS[r.operator]} ${rt}, { description: ${JSON.stringify(msg)} })`;
+  });
+}
+function indentBlock(code, by = "  ") {
+  return code.split("\n").map((line) => line ? by + line : line).join("\n");
+}
+function parsedChecksFor(table) {
+  const parsed = (table.checks ?? []).map((k) => (0, import_validation_core6.parseCheck)(k.expression, k.name));
+  return {
+    checks: parsed.flatMap((p) => p.ok ? p.checks : []),
+    sets: parsed.flatMap((p) => p.ok ? p.sets ?? [] : []),
+    rows: parsed.flatMap((p) => p.ok ? p.rows ?? [] : []),
+    lengths: parsed.flatMap((p) => p.ok ? p.lengths ?? [] : []),
+    cardinalities: parsed.flatMap((p) => p.ok ? p.cardinalities ?? [] : [])
+  };
+}
+function nestedNodeCols(node, mode) {
+  const all = mode === "insert" ? (0, import_validation_core6.insertColumns)(node.table) : (0, import_validation_core6.selectColumns)(node.table);
+  return (0, import_validation_core6.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) {
+  const cols = nestedNodeCols(node, mode);
+  const { checks, sets, rows, lengths, cardinalities } = parsedChecksFor(node.table);
+  const tj = typedJson ? { table: node.table.tsName, mode, allColumns: typedJson.allColumns } : void 0;
+  const fields = renderObjectShape(
+    cols,
+    mode,
+    coerceDates,
+    checks,
+    sets,
+    lengths,
+    cardinalities,
+    tj,
+    applyDefaults
+  );
+  const arms = node.arms.map((arm) => {
+    const notes = (0, import_validation_core6.nestedArmNotes)(arm).map((n) => `  // ${n}
+`).join("");
+    const child = renderNestedObject(arm.child, mode, coerceDates, typedJson, applyDefaults);
+    const inner = arm.single ? `${NS}.NullOr(
+${indentBlock(indentBlock(child))}
+  )` : `${NS}.Array(
+${indentBlock(indentBlock(child))}
+  )`;
+    return `${notes}  ${JSON.stringify(arm.key)}: ${NS}.optional(${inner}),`;
+  });
+  const body = [fields, ...arms].filter(Boolean).join("\n");
+  return piped(`${NS}.Struct({
+${body}
+})`, rowSteps(rows, cols));
+}
+function renderNestedSchemas(table, affix, coerceDates, typedJson, applyDefaults, plans) {
+  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);
+    out.push(
+      `export const ${name} = ${expr};
+
+export type ${tname} = ${NS}.Schema.Type<typeof ${name}>;
+
+export const ${STANDARD_PREFIX}${name} = ${NS}.standardSchemaV1(${name});`
+    );
+  }
+  return out.length ? `
+${out.join("\n\n")}
+` : "";
+}
+function nestedPlansFor(table, analysis, depth) {
+  const out = {};
+  for (const mode of ["insert", "select"]) {
+    if (mode === "insert" && table.readOnly) continue;
+    const plan = (0, import_validation_core6.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 = {}) {
+  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 { checks, sets, rows, lengths, cardinalities } = parsedChecksFor(table);
+  const tj = typedJson ? { table: T, allColumns: typedJson.allColumns } : void 0;
+  const modes = [
+    ["insert", insertCols],
+    ["update", updateCols],
+    ["select", selectCols]
+  ];
+  const blocks = modes.map(([mode, cols]) => {
+    const name = (0, import_validation_core6.schemaName)(mode, T, affix);
+    const tname = (0, import_validation_core6.typeName)(mode, T, affix);
+    const body = renderObjectShape(
+      cols,
+      mode,
+      coerceDates,
+      checks,
+      sets,
+      lengths,
+      cardinalities,
+      // The update schema references the insert-side inferred types: both describe a value going
+      // in, and `$inferSelect` would name the post-default type for a column a write may omit.
+      tj ? { ...tj, mode: mode === "select" ? "select" : "insert" } : void 0,
+      applyDefaults
+    );
+    const expr = piped(`${NS}.Struct({
+${body}
+})`, rowSteps(rows, cols));
+    return `export const ${name} = ${expr};
+
+export type ${tname} = ${NS}.Schema.Type<typeof ${name}>;
+
+export const ${STANDARD_PREFIX}${name} = ${NS}.standardSchemaV1(${name});`;
+  });
+  const nestedByTable = ["insert", "select"].flatMap((m) => {
+    const plan = nested[m];
+    return plan ? nestedNodes(plan).map((n) => [n.table.tsName, nestedNodeCols(n, m)]) : [];
+  });
+  const nestedCols = nestedByTable.flatMap(([, cs]) => cs);
+  const referenced = /* @__PURE__ */ new Set();
+  if (typedJson) {
+    const all = !!typedJson.allColumns;
+    if ([...insertCols, ...updateCols, ...selectCols].some((c) => wantsRef(c, all))) {
+      referenced.add(T);
+    }
+    for (const [name, cs] of nestedByTable) {
+      if (cs.some((c) => wantsRef(c, all))) referenced.add(name);
+    }
+  }
+  const schemaImport = referenced.size ? `import type { ${[...referenced].join(", ")} } from '${typedJson.schemaSpecifier}';
+` : "";
+  const needsJson = !typedJson && [...insertCols, ...updateCols, ...selectCols, ...nestedCols].some(
+    (c) => c.shape?.kind === "json"
+  );
+  const finder = wantsDuplicateFinder ? (0, import_validation_core6.renderDuplicateFinder)(table, `findDuplicate${T}`, (0, import_validation_core6.typeName)("insert", T, affix)) : void 0;
+  const duplicates = finder ? `
+${finder}
+` : "";
+  const nestedCode = renderNestedSchemas(
+    table,
+    affix,
+    coerceDates,
+    typedJson,
+    applyDefaults,
+    nested
+  );
+  return `import * as ${NS} from 'effect/Schema';
+${schemaImport}${needsJson ? `
+${JSON_PREAMBLE}` : ""}
+${blocks.join("\n\n")}
+${nestedCode}${duplicates}`;
+}
+function buildHeader3(h) {
+  if (h && h.enabled === false) return "";
+  const text = h?.text?.trim();
+  const lines = text ? text.split(/\r?\n/).map((l) => `// ${l}`) : [
+    "// Generated by DRZL (@drzl/*)",
+    "// Generated output is granted to you under your project's license.",
+    "// You may use, copy, modify, and distribute without attribution."
+  ];
+  return lines.join("\n") + "\n\n";
+}
+var import_validation_core6, 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");
+    DEFAULT_FILE_SUFFIX2 = ".effect.ts";
+    STANDARD_PREFIX = "Standard";
+    NS = "Schema";
+    OPS = {
+      ">=": ">=",
+      ">": ">",
+      "<=": "<=",
+      "<": "<",
+      "=": "===",
+      "<>": "!=="
+    };
+    JSON_CONST = "DrzlJsonValue";
+    JSON_PREAMBLE = `type ${JSON_CONST}Type =
+  | string
+  | number
+  | boolean
+  | null
+  | readonly ${JSON_CONST}Type[]
+  | { readonly [key: string]: ${JSON_CONST}Type };
+
+const ${JSON_CONST}: ${NS}.Schema<${JSON_CONST}Type, unknown> = ${NS}.suspend(() =>
+  ${NS}.Union(
+    ${NS}.String,
+    ${NS}.Finite,
+    ${NS}.Boolean,
+    ${NS}.Null,
+    ${NS}.Array(${JSON_CONST}),
+    // The plain-object test comes before the record, not after it. \`Schema.Record\` rebuilds its
+    // output, so a check placed after it inspects that new object and reports every input as
+    // plain. A Date sailed through: it has no own enumerable keys, so the record accepted it and
+    // rebuilt it as \`{}\`.
+    ${NS}.Unknown.pipe(
+      ${NS}.filter(
+        (o) => {
+          if (typeof o !== 'object' || o === null || Array.isArray(o)) return false;
+          const p = Object.getPrototypeOf(o);
+          return p === Object.prototype || p === null;
+        },
+        { description: 'a plain object' }
+      ),
+      ${NS}.compose(${NS}.Record({ key: ${NS}.String, value: ${JSON_CONST} }), { strict: false })
+    )
+  )
+);
+`;
+    UNKNOWN_EXPR = `${NS}.Unknown`;
+    EffectGenerator = class {
+      constructor(analysis) {
+        this.analysis = analysis;
+        this.library = "effect";
+      }
+      async generate(opts) {
+        const fs3 = await import("fs/promises");
+        const path6 = await import("path");
+        const out = path6.resolve(process.cwd(), opts.outDir);
+        const files = [];
+        await fs3.mkdir(out, { recursive: true });
+        const affix = (0, import_validation_core6.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)(
+            opts.schemaPath,
+            out,
+            process.cwd(),
+            opts.importExtension
+          ),
+          allColumns: !!opts.typedColumns
+        } : void 0;
+        if (wantsTypes && !opts.schemaPath) {
+          console.warn(
+            "[drzl] typedJson was requested but the schema path is unknown, so json columns keep their wide type."
+          );
+        }
+        const nestedDepth = opts.nestedSchemas ? (0, import_validation_core6.resolveNestedDepth)(opts.nestedDepth, (m) => console.warn(m)) : 0;
+        for (const table of this.analysis.tables) {
+          const filePath = path6.join(out, (0, import_validation_core6.moduleFileName)(table.tsName, fileSuffix));
+          const code = renderTableSchemas(
+            table,
+            affix,
+            coerceDates,
+            typedJson,
+            !!opts.applyDefaults,
+            !!opts?.duplicateFinder,
+            opts.nestedSchemas ? nestedPlansFor(table, this.analysis, nestedDepth) : {}
+          );
+          const formatted = await (0, import_validation_core6.formatCode)(
+            buildHeader3(opts.outputHeader) + code,
+            filePath,
+            opts.format
+          );
+          await fs3.writeFile(filePath, formatted, "utf8");
+          files.push(filePath);
+        }
+        const indexPath = path6.join(out, "index.ts");
+        const indexFormatted = await (0, import_validation_core6.formatCode)(
+          buildHeader3(opts.outputHeader) + this.defaultIndex(this.analysis, opts),
+          indexPath,
+          opts.format
+        );
+        await fs3.writeFile(indexPath, indexFormatted, "utf8");
+        files.push(indexPath);
+        return files;
+      }
+      renderTable(table, opts) {
+        return renderTableSchemas(
+          table,
+          (0, import_validation_core6.resolveAffix)(opts),
+          opts?.coerceDates ?? "input",
+          void 0,
+          !!opts?.applyDefaults,
+          !!opts?.duplicateFinder
+        );
+      }
+      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)}';`
+        ).join("\n") + "\n";
+      }
+    };
+    index_default3 = EffectGenerator;
+  }
+});
+
 // src/cli.ts
 var import_analyzer = require("@drzl/analyzer");
 var import_generator_orpc = require("@drzl/generator-orpc");
-var import_chalk2 = __toESM(require("chalk"), 1);
+var import_chalk3 = __toESM(require("chalk"), 1);
 var import_chokidar = __toESM(require("chokidar"), 1);
 var import_cli_progress = __toESM(require("cli-progress"), 1);
 var import_commander = require("commander");
@@ -1229,7 +1770,17 @@ var AffixSchema = import_zod.z.object({
 }).strict();
 var ImportExtensionSchema = import_zod.z.enum(import_validation_core.IMPORT_EXTENSIONS);
 var GeneratorSchema = import_zod.z.object({
-  kind: import_zod.z.enum(["orpc", "trpc", "service", "zod", "valibot", "arktype", "typebox", "json-schema"]),
+  kind: import_zod.z.enum([
+    "orpc",
+    "trpc",
+    "service",
+    "zod",
+    "valibot",
+    "arktype",
+    "typebox",
+    "effect",
+    "json-schema"
+  ]),
   /**
    * Overrides the top-level `importExtension` for this generator alone, for a project whose
    * generated directories are compiled by different tsconfigs.
@@ -1563,6 +2114,7 @@ function computeGeneratorOutputDirs(cfg, cwd = process.cwd()) {
     if (g.kind === "valibot") dirs.add(abs(g.path ?? "src/validators/valibot"));
     if (g.kind === "arktype") dirs.add(abs(g.path ?? "src/validators/arktype"));
     if (g.kind === "typebox") dirs.add(abs(g.path ?? "src/validators/typebox"));
+    if (g.kind === "effect") dirs.add(abs(g.path ?? "src/validators/effect"));
     if (g.kind === "json-schema") dirs.add(abs(g.path ?? "src/validators/json-schema"));
   }
   return [...dirs];
@@ -1635,6 +2187,264 @@ function trpcOptions(g, cfg, servicesDir) {
   };
 }
 
+// src/doctor.ts
+var import_validation_core2 = require("@drzl/validation-core");
+var import_chalk = __toESM(require("chalk"), 1);
+var HANDLED_CODES = /* @__PURE__ */ new Set(["DRZL_ANL_UNKNOWN_COLUMN"]);
+function splitPath(path6) {
+  if (!path6) return {};
+  const dot = path6.lastIndexOf(".");
+  if (dot <= 0) return { table: path6 };
+  return { table: path6.slice(0, dot), column: path6.slice(dot + 1) };
+}
+function namedColumns(parsed) {
+  const out = [];
+  for (const c of parsed.checks) out.push({ column: c.column, scalar: true });
+  for (const s of parsed.sets ?? []) out.push({ column: s.column, scalar: true });
+  for (const l of parsed.lengths ?? []) out.push({ column: l.column, scalar: false });
+  for (const c of parsed.cardinalities ?? []) out.push({ column: c.column, scalar: false });
+  for (const r of parsed.rows ?? []) {
+    out.push({ column: r.left, scalar: false });
+    out.push({ column: r.right, scalar: false });
+  }
+  return out;
+}
+function describeShape(c) {
+  if (c.arrayDimensions) return "an array";
+  switch (c.shape?.kind) {
+    case "json":
+      return "a JSON";
+    case "buffer":
+      return "a binary";
+    case "tuple":
+    case "numberObject":
+      return "a structured";
+    case "numberVector":
+      return "a vector";
+    case "bitstring":
+      return "a bit-string";
+    case "byteString":
+      return "a byte-string";
+    case "custom":
+      return "a customType";
+    default:
+      return "a structured";
+  }
+}
+function checkFindings(table) {
+  const out = [];
+  const byName = new Map(table.columns.map((c) => [c.name, c]));
+  for (const k of table.checks ?? []) {
+    const label = k.name ? `"${k.name}"` : "an unnamed constraint";
+    const raw = k.expression ?? "";
+    const expr = raw.trim() ? raw : "(empty)";
+    const parsed = (0, import_validation_core2.parseCheck)(raw, k.name);
+    if (!parsed.ok) {
+      out.push({
+        kind: "check-declined",
+        level: "warn",
+        table: table.tsName,
+        constraint: k.name,
+        message: `CHECK ${label} on "${table.tsName}" is not translated: ${parsed.reason}. Expression: ${expr}`,
+        hint: "Only constraints whose meaning is unambiguous are translated, because a validator enforcing a guess rejects rows the database accepts. Your database still enforces this one; nothing DRZL emits does."
+      });
+      continue;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const { column, scalar } of namedColumns(parsed)) {
+      if (seen.has(column)) continue;
+      seen.add(column);
+      const col = byName.get(column);
+      if (!col) {
+        out.push({
+          kind: "check-unknown-column",
+          level: "warn",
+          table: table.tsName,
+          column,
+          constraint: k.name,
+          message: `CHECK ${label} on "${table.tsName}" names "${column}", which is not a column of that table, so nothing enforces it. Expression: ${expr}`,
+          hint: "A constraint is attached to the field it names. Check the spelling, or move a constraint spanning two tables out of the schema."
+        });
+        continue;
+      }
+      if (scalar && (col.arrayDimensions || col.shape)) {
+        out.push({
+          kind: "check-not-scalar",
+          level: "warn",
+          table: table.tsName,
+          column,
+          constraint: k.name,
+          message: `CHECK ${label} on "${table.tsName}" compares ${describeShape(col)} column "${column}" against a scalar literal, which does not describe it, so it is not translated. Expression: ${expr}`,
+          hint: "On an array column only cardinality(col) is read, since it is the one comparison that is about the array rather than about an element."
+        });
+      }
+    }
+  }
+  return out;
+}
+function primaryKeyFindings(table) {
+  if (table.readOnly) return [];
+  const pk = table.primaryKey?.columns ?? [];
+  if (!pk.length) {
+    const hasId = table.columns.some((c) => c.name === "id");
+    return [
+      {
+        kind: "no-primary-key",
+        level: "warn",
+        table: table.tsName,
+        message: hasId ? `Table "${table.tsName}" declares no primary key. The service and router generators fall back to a column named "id", which this table happens to have, so they work by coincidence.` : `Table "${table.tsName}" declares no primary key. The service and router generators fall back to a column named "id", which this table does not have, so the generated service will not compile.`,
+        hint: "Declare a primary key, or leave this table out with the config table filter."
+      }
+    ];
+  }
+  if (pk.length > 1) {
+    return [
+      {
+        kind: "partial-primary-key",
+        level: "warn",
+        table: table.tsName,
+        message: `Table "${table.tsName}" has a composite primary key (${pk.join(", ")}). The service and router generators key getById, update and delete on "${pk[0]}" alone, so those operations match on part of the key.`,
+        hint: "Treat the generated service as a starting point for this table and widen the key by hand."
+      }
+    ];
+  }
+  return [];
+}
+function buildDoctorReport(analysis, schemaPath) {
+  const findings = [];
+  const errors = analysis.issues.filter((i) => i.level === "error");
+  for (const i of errors) {
+    findings.push({
+      kind: "analyzer",
+      level: "error",
+      ...splitPath(i.path),
+      message: i.message,
+      hint: i.hint
+    });
+  }
+  for (const i of analysis.issues) {
+    if (i.code !== "DRZL_ANL_UNKNOWN_COLUMN") continue;
+    findings.push({
+      kind: "unknown-column",
+      level: "warn",
+      ...splitPath(i.path),
+      message: i.message,
+      hint: i.hint
+    });
+  }
+  for (const t of analysis.tables) findings.push(...checkFindings(t));
+  for (const t of analysis.tables) findings.push(...primaryKeyFindings(t));
+  for (const i of analysis.issues) {
+    if (i.level === "error" || HANDLED_CODES.has(i.code)) continue;
+    findings.push({
+      kind: "analyzer",
+      level: "warn",
+      ...splitPath(i.path),
+      message: i.message,
+      hint: i.hint
+    });
+  }
+  const columns = analysis.tables.reduce((n, t) => n + t.columns.length, 0);
+  const checks = analysis.tables.reduce((n, t) => n + (t.checks?.length ?? 0), 0);
+  return {
+    schema: schemaPath,
+    dialect: analysis.dialect,
+    ok: findings.length === 0,
+    counts: { tables: analysis.tables.length, columns, checks, findings: findings.length },
+    findings
+  };
+}
+var SECTIONS = [
+  {
+    kinds: ["unknown-column"],
+    title: "Columns DRZL cannot type",
+    why: "These get a validator that accepts any value."
+  },
+  {
+    kinds: ["check-declined", "check-unknown-column", "check-not-scalar"],
+    title: "CHECK constraints DRZL does not enforce",
+    why: "Your database still enforces these. Nothing DRZL generates does."
+  },
+  {
+    kinds: ["no-primary-key", "partial-primary-key"],
+    title: "Primary keys the generators cannot use",
+    why: "The generated getById, update and delete are keyed on one column."
+  },
+  {
+    kinds: ["analyzer"],
+    title: "Other findings",
+    why: "Reported by the analyzer while reading the schema."
+  }
+];
+function wrap(text, indent, first = indent, width = 96) {
+  const lines = [];
+  let line = "";
+  for (const word of text.split(/\s+/)) {
+    if (line && `${line} ${word}`.length + indent.length > width) {
+      lines.push(line);
+      line = word;
+    } else {
+      line = line ? `${line} ${word}` : word;
+    }
+  }
+  if (line) lines.push(line);
+  return lines.map((l, i) => (i === 0 ? first : indent) + l).join("\n");
+}
+function renderDoctorReport(report) {
+  const out = [];
+  const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
+  out.push(import_chalk.default.bold(`DRZL doctor  ${report.schema}`));
+  out.push(
+    import_chalk.default.dim(
+      `${report.dialect}, ${plural(report.counts.tables, "table")}, ${plural(report.counts.columns, "column")}, ${plural(report.counts.checks, "CHECK constraint")}`
+    )
+  );
+  out.push("");
+  if (report.ok) {
+    out.push(import_chalk.default.green("Nothing to report."));
+    out.push(import_chalk.default.dim("  Every column has a type DRZL can describe."));
+    out.push(import_chalk.default.dim("  Every CHECK constraint is translated into the generated validators."));
+    out.push(import_chalk.default.dim("  Every table has a primary key the generators can use."));
+    return out.join("\n");
+  }
+  const fatal = report.findings.filter((f) => f.level === "error");
+  if (fatal.length) {
+    out.push(import_chalk.default.red("DRZL could not read this schema"));
+    out.push(import_chalk.default.dim("  Nothing else could be checked."));
+    out.push("");
+    for (const f of fatal) {
+      out.push(wrap(f.message, "    ", `  ${import_chalk.default.dim("-")} `));
+      if (f.hint) out.push(import_chalk.default.dim(wrap(f.hint, "    ")));
+    }
+    out.push("");
+  }
+  for (const section of SECTIONS) {
+    const mine = report.findings.filter(
+      (f) => f.level !== "error" && section.kinds.includes(f.kind)
+    );
+    if (!mine.length) continue;
+    out.push(import_chalk.default.yellow(`${section.title}  (${mine.length})`));
+    out.push(import_chalk.default.dim(`  ${section.why}`));
+    out.push("");
+    const groups = /* @__PURE__ */ new Map();
+    for (const f of mine) {
+      const key = f.hint ?? "";
+      groups.set(key, [...groups.get(key) ?? [], f]);
+    }
+    for (const [hint, items] of groups) {
+      for (const f of items) out.push(wrap(f.message, "    ", `  ${import_chalk.default.dim("-")} `));
+      if (hint) out.push(import_chalk.default.dim(wrap(hint, "    ")));
+      out.push("");
+    }
+  }
+  out.push(
+    import_chalk.default.bold(`${plural(report.counts.findings, "finding")} in ${report.schema}.`) + import_chalk.default.dim(
+      fatal.length ? " Fix the error above and run this again." : " None of these stop DRZL generating; they are what it will not check for you."
+    )
+  );
+  return out.join("\n");
+}
+
 // src/drift.ts
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"), 1);
@@ -1711,7 +2521,7 @@ async function loadGenerator(specifier, load) {
 }
 
 // src/sponsor.ts
-var import_chalk = __toESM(require("chalk"), 1);
+var import_chalk2 = __toESM(require("chalk"), 1);
 var import_node_fs2 = require("fs");
 var import_node_path2 = __toESM(require("path"), 1);
 var CACHE_DIR = import_node_path2.default.join(process.cwd(), "node_modules", ".cache", "@drzl");
@@ -1721,13 +2531,13 @@ var shownThisProcess = false;
 var tips = [
   "Pair DRZL watch mode with drizzle-kit to keep schema & API synced.",
   "Templatize your ORPC routers to roll out new endpoints safely.",
-  "Need typed validators? Enable the zod, valibot, arktype, or typebox generators.",
+  "Need typed validators? Enable the zod, valibot, arktype, typebox, or effect generators.",
   "Need JSON Schema or OpenAPI? The json-schema generator emits both, with no runtime dependency.",
   "Use output headers to track generated files and trim noisy diffs."
 ];
-var green = (msg) => import_chalk.default.hex("#6ee7b7")(msg);
-var cyan = (msg) => import_chalk.default.cyan(msg);
-var gray = (msg) => import_chalk.default.gray(msg);
+var green = (msg) => import_chalk2.default.hex("#6ee7b7")(msg);
+var cyan = (msg) => import_chalk2.default.cyan(msg);
+var gray = (msg) => import_chalk2.default.gray(msg);
 function maybeShowSponsorMessage({
   reason = "generate",
   minIntervalMs = DEFAULT_INTERVAL_MS,
@@ -1816,13 +2626,13 @@ var CLI_VERSION = readCliVersion();
 function reportGeneratorFailure(kind, e) {
   if (e instanceof GeneratorNotInstalledError) {
     console.error(
-      import_chalk2.default.red(`The ${kind} generator is not installed.`),
-      import_chalk2.default.yellow(`
+      import_chalk3.default.red(`The ${kind} generator is not installed.`),
+      import_chalk3.default.yellow(`
 Install with: npm install ${e.specifier}`)
     );
     return;
   }
-  console.error(import_chalk2.default.red(`The ${kind} generator failed:`), e?.message ?? e);
+  console.error(import_chalk3.default.red(`The ${kind} generator failed:`), e?.message ?? e);
 }
 var program = new import_commander.Command();
 program.name("drzl").description("DRZL - Drizzle Developer Toolkit").version(CLI_VERSION);
@@ -1849,9 +2659,9 @@ program.command("analyze").argument("<schema>", "path to drizzle schema (TS)").o
     } else if (opts.out) {
       const fs3 = await import("fs/promises");
       await fs3.writeFile(opts.out, json, "utf8");
-      spinner?.succeed(import_chalk2.default.green(`Analysis written to ${opts.out} in ${ms}ms`));
+      spinner?.succeed(import_chalk3.default.green(`Analysis written to ${opts.out} in ${ms}ms`));
     } else {
-      spinner?.succeed(import_chalk2.default.green(`Analyzed in ${ms}ms`));
+      spinner?.succeed(import_chalk3.default.green(`Analyzed in ${ms}ms`));
       console.log(json);
     }
     process.exit(res.issues.some((i) => i.level === "error") ? 2 : 0);
@@ -1861,7 +2671,48 @@ program.command("analyze").argument("<schema>", "path to drizzle schema (TS)").o
       console.log(JSON.stringify({ event: "error", code: "DRZL_CLI_ANALYZE", message: msg }));
     else
       console.error(
-        import_chalk2.default.red("Analyze failed (DRZL_CLI_ANALYZE):"),
+        import_chalk3.default.red("Analyze failed (DRZL_CLI_ANALYZE):"),
+        msg,
+        "\nTip: run with --json for structured output."
+      );
+    process.exit(1);
+  }
+});
+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("--json", "print the report as JSON instead of prose", false).option("--strict", "exit 2 when anything is reported", false).action(async (schema, opts) => {
+  try {
+    let target = schema;
+    if (!target) {
+      const cfg = await loadConfig(opts.config);
+      target = cfg?.schema;
+    }
+    if (!target) {
+      const msg = "No schema given. Pass a path, or run from a directory with a drzl.config.";
+      if (opts.json)
+        console.log(JSON.stringify({ event: "error", code: "DRZL_CLI_DOCTOR", message: msg }));
+      else console.error(import_chalk3.default.red("Doctor failed (DRZL_CLI_DOCTOR):"), msg);
+      process.exit(1);
+      return;
+    }
+    const analyzer = new import_analyzer.SchemaAnalyzer(target);
+    const analysis = await analyzer.analyze({
+      includeRelations: true,
+      validateConstraints: true
+    });
+    const report = buildDoctorReport(analysis, target);
+    if (opts.json) console.log(JSON.stringify(report, null, 2));
+    else console.log(renderDoctorReport(report));
+    if (report.findings.some((f) => f.level === "error")) {
+      process.exit(1);
+      return;
+    }
+    process.exit(opts.strict && report.findings.length ? 2 : 0);
+  } catch (e) {
+    const msg = e?.message ?? String(e);
+    if (opts.json)
+      console.log(JSON.stringify({ event: "error", code: "DRZL_CLI_DOCTOR", message: msg }));
+    else
+      console.error(
+        import_chalk3.default.red("Doctor failed (DRZL_CLI_DOCTOR):"),
         msg,
         "\nTip: run with --json for structured output."
       );
@@ -1876,7 +2727,7 @@ program.command("generate").description("Run configured generators (drzl.config.
     const cfg = await loadConfig(opts.config);
     if (!cfg) {
       console.error(
-        import_chalk2.default.red("No config found (DRZL_CFG_001). Create drzl.config.ts or pass --config.")
+        import_chalk3.default.red("No config found (DRZL_CFG_001). Create drzl.config.ts or pass --config.")
       );
       process.exit(2);
       return;
@@ -1921,8 +2772,8 @@ program.command("generate").description("Run configured generators (drzl.config.
           onProgress: ({ index }) => progress.update(index)
         });
         progress.stop();
-        (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (${g.kind}): ${files.length} files`));
-        files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+        (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (${g.kind}): ${files.length} files`));
+        files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
       } else if (g.kind === "trpc") {
         try {
           const { TRPCGenerator: TRPCGenerator2 } = await loadGenerator(
@@ -1935,8 +2786,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             onProgress: ({ index }) => progress.update(index)
           });
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (trpc): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (trpc): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1965,8 +2816,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             databaseInjection: g.databaseInjection
           });
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (service): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (service): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -1984,8 +2835,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: true })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (zod): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (zod): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -2003,8 +2854,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: true })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (valibot): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (valibot): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -2022,8 +2873,8 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: false })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (arktype): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (arktype): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -2039,8 +2890,8 @@ program.command("generate").description("Run configured generators (drzl.config.
           const target = g.path ?? "src/validators/json-schema";
           const files = await gen.generate(jsonSchemaOptions(g, cfg, target));
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (json-schema): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (json-schema): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -2058,8 +2909,27 @@ program.command("generate").description("Run configured generators (drzl.config.
             validationOptions(g, cfg, target, { schemaTypes: true })
           );
           progress.stop();
-          (0, import_ora.default)().succeed(import_chalk2.default.green(`Generated (typebox): ${files.length} files`));
-          files.forEach((f) => console.log("  -", import_chalk2.default.cyan(f)));
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (typebox): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
+        } catch (e) {
+          progress.stop();
+          reportGeneratorFailure(g.kind, e);
+          process.exit(1);
+        }
+      } else if (g.kind === "effect") {
+        try {
+          const { EffectGenerator: EffectGenerator2 } = await loadGenerator(
+            "@drzl/generator-effect",
+            () => Promise.resolve().then(() => (init_dist3(), dist_exports3))
+          );
+          const gen = new EffectGenerator2(analysis);
+          const target = g.path ?? "src/validators/effect";
+          const files = await gen.generate(
+            validationOptions(g, cfg, target, { schemaTypes: true })
+          );
+          progress.stop();
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (effect): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
         } catch (e) {
           progress.stop();
           reportGeneratorFailure(g.kind, e);
@@ -2072,22 +2942,22 @@ program.command("generate").description("Run configured generators (drzl.config.
       const drift = diffSnapshots(driftBefore, after);
       await restoreSnapshot(driftBefore, after);
       if (drift.length) {
-        console.error(import_chalk2.default.red(`
+        console.error(import_chalk3.default.red(`
 Generated output is out of date (${drift.length} file(s)):`));
         for (const d of drift) {
           const mark = d.status === "added" ? "+" : d.status === "removed" ? "-" : "~";
           console.error(
-            `  ${mark} ${import_chalk2.default.yellow(d.status.padEnd(8))} ${path5.relative(process.cwd(), d.file)}`
+            `  ${mark} ${import_chalk3.default.yellow(d.status.padEnd(8))} ${path5.relative(process.cwd(), d.file)}`
           );
         }
         console.error(
-          import_chalk2.default.dim(
+          import_chalk3.default.dim(
             "\nRun `drzl generate` and commit the result. Nothing was written by this check."
           )
         );
         process.exit(1);
       }
-      console.log(import_chalk2.default.green("Generated output is up to date."));
+      console.log(import_chalk3.default.green("Generated output is up to date."));
       return;
     }
     if (cfg.generators.length) {
@@ -2095,7 +2965,7 @@ Generated output is out of date (${drift.length} file(s)):`));
     }
   } catch (e) {
     console.error(
-      import_chalk2.default.red("Generate failed (DRZL_GEN_001):"),
+      import_chalk3.default.red("Generate failed (DRZL_GEN_001):"),
       e?.message ?? e,
       "\nTip: check your drzl.config.ts and template path."
     );
@@ -2115,10 +2985,10 @@ program.command("generate:orpc").argument("<schema>", "path to drizzle schema (T
       template: opts.template,
       includeRelations: !!opts.includeRelations
     });
-    console.log(import_chalk2.default.green(`Generated:`), files.map((f) => import_chalk2.default.cyan(f)).join(", "));
+    console.log(import_chalk3.default.green(`Generated:`), files.map((f) => import_chalk3.default.cyan(f)).join(", "));
     maybeShowSponsorMessage({ reason: "generate:orpc" });
   } catch (e) {
-    console.error(import_chalk2.default.red("Generate orpc failed:"), e?.message ?? e);
+    console.error(import_chalk3.default.red("Generate orpc failed:"), e?.message ?? e);
     process.exit(1);
   }
 });
@@ -2142,7 +3012,7 @@ program.command("generate:trpc").argument("<schema>", "path to drizzle schema (T
       // cannot become the branch that forgets it.
       servicesDir: opts.servicesDir
     });
-    console.log(import_chalk2.default.green(`Generated:`), files.map((f) => import_chalk2.default.cyan(f)).join(", "));
+    console.log(import_chalk3.default.green(`Generated:`), files.map((f) => import_chalk3.default.cyan(f)).join(", "));
     maybeShowSponsorMessage({ reason: "generate:trpc" });
   } catch (e) {
     reportGeneratorFailure("trpc", e);
@@ -2152,7 +3022,7 @@ program.command("generate:trpc").argument("<schema>", "path to drizzle schema (T
 program.command("watch").description("Watch schema and regenerate on changes").option("-c, --config <path>", "path to drzl.config").option("--pipeline <name>", "all | analyze | generate-orpc | generate-trpc", "all").option("--debounce <ms>", "debounce ms", "200").option("--json", "emit JSON logs", false).option("--poll", "force polling (helps WSL/Docker/remote FS)", false).action(async (opts) => {
   let cfg = await loadConfig(opts.config);
   if (!cfg) {
-    console.error(import_chalk2.default.red("No config found. Create drzl.config.ts or pass --config."));
+    console.error(import_chalk3.default.red("No config found. Create drzl.config.ts or pass --config."));
     process.exit(2);
     return;
   }
@@ -2244,7 +3114,7 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             })
           );
         } else {
-          console.log(import_chalk2.default.green("Analyze complete."));
+          console.log(import_chalk3.default.green("Analyze complete."));
         }
         return;
       }
@@ -2274,8 +3144,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             servicesDir
           });
           opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-            import_chalk2.default.green(`Generated (${g.kind}):`),
-            files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+            import_chalk3.default.green(`Generated (${g.kind}):`),
+            files.map((f) => import_chalk3.default.cyan(f)).join(", ")
           );
           newFiles.push(...files);
         } else if (g.kind === "trpc") {
@@ -2287,8 +3157,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             const gen = new TRPCGenerator2(analysis);
             const { files } = await gen.generate(trpcOptions(g, cfg, servicesDir));
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (trpc): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (trpc): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2314,8 +3184,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               databaseInjection: g.databaseInjection
             });
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (service): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (service): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2334,8 +3204,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: true })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (zod): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (zod): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2354,8 +3224,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: true })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (valibot): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (valibot): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2374,8 +3244,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: false })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (arktype): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (arktype): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2394,8 +3264,28 @@ program.command("watch").description("Watch schema and regenerate on changes").o
               validationOptions(g, cfg, target, { schemaTypes: true })
             );
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (typebox): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (typebox): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            reportGeneratorFailure(g.kind, e);
+            return;
+          }
+        } else if (g.kind === "effect") {
+          try {
+            const { EffectGenerator: EffectGenerator2 } = await loadGenerator(
+              "@drzl/generator-effect",
+              () => Promise.resolve().then(() => (init_dist3(), dist_exports3))
+            );
+            const gen = new EffectGenerator2(analysis);
+            const target = g.path ?? "src/validators/effect";
+            const files = await gen.generate(
+              validationOptions(g, cfg, target, { schemaTypes: true })
+            );
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk3.default.green(`Generated (effect): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2412,8 +3302,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             const target = g.path ?? "src/validators/json-schema";
             const files = await gen.generate(jsonSchemaOptions(g, cfg, target));
             opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
-              import_chalk2.default.green(`Generated (json-schema): ${files.length} files`),
-              files.map((f) => import_chalk2.default.cyan(f)).join(", ")
+              import_chalk3.default.green(`Generated (json-schema): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
             );
             newFiles.push(...files);
           } catch (e) {
@@ -2425,8 +3315,8 @@ program.command("watch").description("Watch schema and regenerate on changes").o
       const added = newFiles.filter((f) => !lastFiles.includes(f));
       const removed = lastFiles.filter((f) => !newFiles.includes(f));
       opts.json ? console.log(JSON.stringify({ event: "diff", added, removed })) : (() => {
-        if (added.length) console.log(import_chalk2.default.blue(`Added: ${added.join(", ")}`));
-        if (removed.length) console.log(import_chalk2.default.yellow(`Removed: ${removed.join(", ")}`));
+        if (added.length) console.log(import_chalk3.default.blue(`Added: ${added.join(", ")}`));
+        if (removed.length) console.log(import_chalk3.default.yellow(`Removed: ${removed.join(", ")}`));
       })();
       if (newFiles.length && !opts.json) {
         const reason = opts.pipeline && opts.pipeline !== "all" ? `watch:${opts.pipeline}` : "watch";
@@ -2434,7 +3324,7 @@ program.command("watch").description("Watch schema and regenerate on changes").o
       }
       lastFiles = newFiles;
     } catch (e) {
-      opts.json ? console.log(JSON.stringify({ event: "error", message: String(e?.message ?? e) })) : console.error(import_chalk2.default.red("Watch pipeline failed:"), e?.message ?? e);
+      opts.json ? console.log(JSON.stringify({ event: "error", message: String(e?.message ?? e) })) : console.error(import_chalk3.default.red("Watch pipeline failed:"), e?.message ?? e);
     }
   };
   const debounced = Number(opts.debounce) || 200;
@@ -2459,12 +3349,12 @@ program.command("watch").description("Watch schema and regenerate on changes").o
     );
   } else {
     console.log(
-      import_chalk2.default.gray(
+      import_chalk3.default.gray(
         "Watching:\n  " + Array.from(currentTargets).map((p) => path5.relative(process.cwd(), p)).join("\n  ")
       )
     );
   }
-  watcher.on("add", (p) => trigger(p)).on("change", (p) => trigger(p)).on("unlink", (p) => trigger(p)).on("error", (err) => console.error(import_chalk2.default.red("Watcher error:"), err));
+  watcher.on("add", (p) => trigger(p)).on("change", (p) => trigger(p)).on("unlink", (p) => trigger(p)).on("error", (err) => console.error(import_chalk3.default.red("Watcher error:"), err));
   await run();
 });
 program.command("init").description("Scaffold a drzl.config.ts").option("-y, --yes", "accept defaults").action(async (_opts) => {
@@ -2484,9 +3374,9 @@ program.command("init").description("Scaffold a drzl.config.ts").option("-y, --y
 `;
   try {
     await fs3.writeFile(target, template, { flag: "wx" });
-    console.log(import_chalk2.default.green(`Created ${target}`));
+    console.log(import_chalk3.default.green(`Created ${target}`));
   } catch (e) {
-    console.error(import_chalk2.default.red("Init failed:"), e?.message ?? e);
+    console.error(import_chalk3.default.red("Init failed:"), e?.message ?? e);
     process.exit(1);
   }
 });
@@ -2494,13 +3384,14 @@ function reportWideColumns(issues) {
   const wide = issues.filter((i) => i.code === "DRZL_ANL_UNKNOWN_COLUMN");
   if (!wide.length) return;
   console.warn(
-    import_chalk2.default.yellow(`
+    import_chalk3.default.yellow(`
 ${wide.length} column${wide.length === 1 ? "" : "s"} could not be typed:`)
   );
-  for (const i of wide.slice(0, 10)) console.warn(import_chalk2.default.gray(`  - ${i.message}`));
-  if (wide.length > 10) console.warn(import_chalk2.default.gray(`  ... and ${wide.length - 10} more`));
+  for (const i of wide.slice(0, 10)) console.warn(import_chalk3.default.gray(`  - ${i.message}`));
+  if (wide.length > 10) console.warn(import_chalk3.default.gray(`  ... and ${wide.length - 10} more`));
   const hints = [...new Set(wide.map((i) => i.hint).filter(Boolean))];
-  for (const h of hints) console.warn(import_chalk2.default.gray(`  ${h}`));
+  for (const h of hints) console.warn(import_chalk3.default.gray(`  ${h}`));
+  console.warn(import_chalk3.default.gray("  Run `drzl doctor` for the full report."));
 }
 program.parseAsync(process.argv);
 //# sourceMappingURL=cli.cjs.map