@drzl/cli 4.18.0 → 4.19.0

package/dist/cli.cjs

@@ -1140,6 +1140,547 @@ 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");
@@ -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];
@@ -1979,7 +2531,7 @@ var shownThisProcess = false;
 var tips = [
   "Pair DRZL watch mode with drizzle-kit to keep schema & API synced.",
   "Templatize your ORPC routers to roll out new endpoints safely.",
-  "Need typed validators? Enable the zod, valibot, arktype, or typebox generators.",
+  "Need typed validators? Enable the zod, valibot, arktype, typebox, or effect generators.",
   "Need JSON Schema or OpenAPI? The json-schema generator emits both, with no runtime dependency.",
   "Use output headers to track generated files and trim noisy diffs."
 ];
@@ -2364,6 +2916,25 @@ program.command("generate").description("Run configured generators (drzl.config.
           reportGeneratorFailure(g.kind, e);
           process.exit(1);
         }
+      } else if (g.kind === "effect") {
+        try {
+          const { EffectGenerator: EffectGenerator2 } = await loadGenerator(
+            "@drzl/generator-effect",
+            () => Promise.resolve().then(() => (init_dist3(), dist_exports3))
+          );
+          const gen = new EffectGenerator2(analysis);
+          const target = g.path ?? "src/validators/effect";
+          const files = await gen.generate(
+            validationOptions(g, cfg, target, { schemaTypes: true })
+          );
+          progress.stop();
+          (0, import_ora.default)().succeed(import_chalk3.default.green(`Generated (effect): ${files.length} files`));
+          files.forEach((f) => console.log("  -", import_chalk3.default.cyan(f)));
+        } catch (e) {
+          progress.stop();
+          reportGeneratorFailure(g.kind, e);
+          process.exit(1);
+        }
       }
     }
     if (driftBefore) {
@@ -2701,6 +3272,26 @@ program.command("watch").description("Watch schema and regenerate on changes").o
             reportGeneratorFailure(g.kind, e);
             return;
           }
+        } else if (g.kind === "effect") {
+          try {
+            const { EffectGenerator: EffectGenerator2 } = await loadGenerator(
+              "@drzl/generator-effect",
+              () => Promise.resolve().then(() => (init_dist3(), dist_exports3))
+            );
+            const gen = new EffectGenerator2(analysis);
+            const target = g.path ?? "src/validators/effect";
+            const files = await gen.generate(
+              validationOptions(g, cfg, target, { schemaTypes: true })
+            );
+            opts.json ? console.log(JSON.stringify({ event: "generate_complete", kind: g.kind, files })) : console.log(
+              import_chalk3.default.green(`Generated (effect): ${files.length} files`),
+              files.map((f) => import_chalk3.default.cyan(f)).join(", ")
+            );
+            newFiles.push(...files);
+          } catch (e) {
+            reportGeneratorFailure(g.kind, e);
+            return;
+          }
         } else if (g.kind === "json-schema") {
           try {
             const { JsonSchemaGenerator: JsonSchemaGenerator2 } = await loadGenerator(