@drzl/cli 4.23.0 → 4.24.1

package/dist/dist-KX62ETKK.js

@@ -1,634 +0,0 @@
-// ../generator-effect/dist/index.js
-import { fileWriter } from "@drzl/validation-core";
-import {
-  buildBrandPlan,
-  buildNestedPlan,
-  formatCode,
-  nestedArmNotes,
-  nestedNodeColumns,
-  nestedSchemaName,
-  nestedTypeName,
-  resolveNestedDepth,
-  applyWirePolicy,
-  canonicalMembers,
-  canonicalNumericText,
-  comparisonWire,
-  describeSet,
-  needsNumericCanon,
-  CODEPOINT_LENGTH,
-  COERCIBLE_DATE_STRING,
-  COLUMN_FORMATS,
-  NUMERIC_CANON_NAME,
-  NUMERIC_CANON_SOURCE,
-  insertColumns,
-  isIntegerColumn,
-  lengthCheckLabel,
-  lengthMeasure,
-  measureExpression,
-  moduleFileName,
-  moduleSpecifier,
-  nonFiniteAccepted,
-  parseCheck,
-  parsesToADate,
-  renderDuplicateFinder,
-  resolveAffix,
-  resolveConfiguredImport,
-  schemaName,
-  selectColumns,
-  typeName,
-  updateColumns,
-  wireNumberLiteral
-} from "@drzl/validation-core";
-var DEFAULT_FILE_SUFFIX = ".effect.ts";
-var STANDARD_PREFIX = "Standard";
-var NS = "Schema";
-var OPS = {
-  ">=": ">=",
-  ">": ">",
-  "<=": "<=",
-  "<": "<",
-  "=": "===",
-  "<>": "!=="
-};
-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;
-}
-var JSON_CONST = "DrzlJsonValue";
-var 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 })
-    )
-  )
-);
-`;
-var UNKNOWN_EXPR = `${NS}.Unknown`;
-function isUnknownExpr(expr) {
-  return expr === UNKNOWN_EXPR;
-}
-function withNarrowedType(expr, ref) {
-  return `${expr} as unknown as ${NS}.Schema<${ref}>`;
-}
-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 } = 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(COERCIBLE_DATE_STRING)}))`,
-    filter(parsesToADate("new Date(v)"), "a date the runtime can parse")
-  ]);
-  const fromNumber = piped(`${NS}.Number`, [
-    filter(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(`${CODEPOINT_LENGTH} <= ${n}`, `at most ${n} characters`)] : [filter(`new TextEncoder().encode(v).length <= ${n}`, `at most ${n} bytes`)];
-  }
-  if (c.maxLength) {
-    steps.push(
-      filter(`${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) {
-  return lengths.filter((k) => k.column === c.name).flatMap((k) => {
-    const measure = lengthMeasure(c, k);
-    if (!measure) return [];
-    return [
-      filter(
-        `${measureExpression(measure, "v")} ${OPS[k.operator]} ${k.value}`,
-        lengthCheckLabel(k)
-      )
-    ];
-  });
-}
-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);
-  const numericWire = comparisonWire(c) === "numeric-string";
-  return checks.filter((k) => k.column === c.name && !folded.has(k)).map((k) => {
-    const label = `${k.name ? `${k.name}: ` : ""}${c.name} ${k.operator} ${k.value}`;
-    if (numericWire) {
-      if (k.operator === "=" || k.operator === "<>") {
-        const canon = JSON.stringify(canonicalNumericText(k.value));
-        const op = k.operator === "=" ? "===" : "!==";
-        return filter(`${NUMERIC_CANON_NAME}(v) ${op} ${canon}`, label);
-      }
-      return filter(`Number(v) ${OPS[k.operator]} ${k.value}`, label);
-    }
-    const literal = k.kind === "string" ? JSON.stringify(k.value) : wireNumberLiteral(c, k.value);
-    return filter(`v ${OPS[k.operator]} ${literal}`, label);
-  });
-}
-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 piped(shaped, lengthSteps(c, lengths));
-  const set = sets.find((x) => x.column === c.name);
-  if (set) {
-    if (comparisonWire(c) === "numeric-string") {
-      const members = canonicalMembers(set.values);
-      const test = members.map((m) => `canon === ${JSON.stringify(m)}`).join(" || ");
-      return piped(`${NS}.String`, [
-        filter(`((canon) => ${test})(${NUMERIC_CANON_NAME}(v))`, describeSet(set))
-      ]);
-    }
-    const values = set.values.map(
-      (v) => set.kind === "string" ? JSON.stringify(v) : wireNumberLiteral(c, 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 && comparisonWire(c) !== "numeric-string") {
-    return `${NS}.Literal(${eq.kind === "string" ? JSON.stringify(eq.value) : wireNumberLiteral(c, 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" && COLUMN_FORMATS[c.format] ? [`${NS}.pattern(new RegExp(${JSON.stringify(COLUMN_FORMATS[c.format])}))`] : [];
-      return piped(base, [...pattern, ...capSteps(c, mode), ...rest]);
-    }
-    case "number": {
-      const base = isIntegerColumn(c) ? `${NS}.Int` : `${NS}.Finite`;
-      return withNonFinite(c, piped(base, [...numericBounds(c, checks), ...rest]));
-    }
-    case "bigint":
-      return piped(`${NS}.BigIntFromSelf`, [
-        ...c.min !== void 0 ? [`${NS}.greaterThanOrEqualToBigInt(${c.min}n)`] : [],
-        ...c.max !== void 0 ? [`${NS}.lessThanOrEqualToBigInt(${c.max}n)`] : [],
-        ...rest
-      ]);
-    case "boolean":
-      return `${NS}.Boolean`;
-    case "Date":
-      return dateExpr(mode, coerceDates);
-    case "Uint8Array":
-      return `${NS}.Uint8ArrayFromSelf`;
-    case "any":
-      return UNKNOWN_EXPR;
-    default:
-      return UNKNOWN_EXPR;
-  }
-}
-function renderField(c, mode, coerceDates, checks, sets, lengths, cardinalities, applyDefault, narrowRef, brand) {
-  let expr = exprForColumn(
-    c,
-    mode,
-    coerceDates,
-    checks,
-    sets,
-    lengths,
-    !!narrowRef && hasNoRuntimeType(c)
-  );
-  const dims = c.arrayDimensions ?? 0;
-  for (let i = 0; i < dims; i++) {
-    expr = `${NS}.Array(${expr})`;
-    if (i === dims - 1) expr = piped(expr, cardinalitySteps(c, cardinalities));
-  }
-  if (brand) expr = piped(expr, [`${NS}.brand(${JSON.stringify(brand)})`]);
-  if (c.nullable && !isUnknownExpr(expr)) expr = `${NS}.NullOr(${expr})`;
-  if (narrowRef && !brand) expr = withNarrowedType(expr, narrowRef);
-  if (mode === "select") return expr;
-  const wantsDefault = mode === "insert" && applyDefault && c.defaultValue !== void 0;
-  if (wantsDefault) {
-    return `${NS}.optionalWith(${expr}, { default: () => ${JSON.stringify(c.defaultValue)} })`;
-  }
-  if (mode === "update" || c.nullable || c.hasDefault) return `${NS}.optional(${expr})`;
-  return expr;
-}
-function wantsRef(c, allColumns) {
-  return allColumns || hasNoRuntimeType(c);
-}
-function renderObjectShape(cols, mode, coerceDates, checks, sets, lengths, cardinalities, typedJson, applyDefaults, brands) {
-  return cols.map((c) => {
-    const ref = typedJson && wantsRef(c, !!typedJson.allColumns) ? `(typeof ${typedJson.table}.$infer${typedJson.mode === "insert" ? "Insert" : "Select"})[${JSON.stringify(c.name)}]` : void 0;
-    const field = renderField(
-      c,
-      mode,
-      coerceDates,
-      checks,
-      sets,
-      lengths,
-      cardinalities,
-      applyDefaults,
-      ref,
-      brands?.plan.brandOf(brands.tsName, c.name)
-    );
-    return `  ${JSON.stringify(c.name)}: ${field},`;
-  }).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) => parseCheck(k.expression, k.name));
-  const { checks, sets } = applyWirePolicy(
-    table.columns,
-    parsed.flatMap((p) => p.ok ? p.checks : []),
-    parsed.flatMap((p) => p.ok ? p.sets ?? [] : [])
-  );
-  return {
-    checks,
-    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" ? insertColumns(node.table) : selectColumns(node.table);
-  return nestedNodeColumns(all, node);
-}
-function nestedNodes(node, into = []) {
-  into.push(node);
-  for (const arm of node.arms) nestedNodes(arm.child, into);
-  return into;
-}
-function renderNestedObject(node, mode, coerceDates, typedJson, applyDefaults, brands) {
-  const cols = nestedNodeCols(node, mode);
-  const { checks, sets, rows, lengths, cardinalities } = parsedChecksFor(node.table);
-  const tj = typedJson ? { table: node.table.tsName, mode, allColumns: typedJson.allColumns } : void 0;
-  const fields = renderObjectShape(
-    cols,
-    mode,
-    coerceDates,
-    checks,
-    sets,
-    lengths,
-    cardinalities,
-    tj,
-    applyDefaults,
-    brands ? { plan: brands, tsName: node.table.tsName } : void 0
-  );
-  const arms = node.arms.map((arm) => {
-    const notes = nestedArmNotes(arm).map((n) => `  // ${n}
-`).join("");
-    const child = renderNestedObject(
-      arm.child,
-      mode,
-      coerceDates,
-      typedJson,
-      applyDefaults,
-      brands
-    );
-    const inner = arm.single ? `${NS}.NullOr(
-${indentBlock(indentBlock(child))}
-  )` : `${NS}.Array(
-${indentBlock(indentBlock(child))}
-  )`;
-    return `${notes}  ${JSON.stringify(arm.key)}: ${NS}.optional(${inner}),`;
-  });
-  const body = [fields, ...arms].filter(Boolean).join("\n");
-  return piped(`${NS}.Struct({
-${body}
-})`, rowSteps(rows, cols));
-}
-function renderNestedSchemas(table, affix, coerceDates, typedJson, applyDefaults, plans, brands) {
-  const out = [];
-  for (const mode of ["insert", "select"]) {
-    const plan = plans[mode];
-    if (!plan) continue;
-    const name = nestedSchemaName(mode, table.tsName, affix);
-    const tname = nestedTypeName(mode, table.tsName, affix);
-    const expr = renderNestedObject(plan, mode, coerceDates, typedJson, applyDefaults, brands);
-    out.push(
-      `export const ${name} = ${expr};
-
-export type ${tname} = ${NS}.Schema.Type<typeof ${name}>;
-
-export const ${STANDARD_PREFIX}${name} = ${NS}.standardSchemaV1(${name});`
-    );
-  }
-  return out.length ? `
-${out.join("\n\n")}
-` : "";
-}
-function nestedPlansFor(table, analysis, depth) {
-  const out = {};
-  for (const mode of ["insert", "select"]) {
-    if (mode === "insert" && table.readOnly) continue;
-    const plan = buildNestedPlan(table, analysis.tables, analysis.relations ?? [], mode, depth);
-    if (plan) out[mode] = plan;
-  }
-  return out;
-}
-function renderTableSchemas(table, affix, coerceDates, typedJson, applyDefaults = false, wantsDuplicateFinder = false, nested = {}, brands) {
-  const T = table.tsName;
-  const insertCols = insertColumns(table);
-  const updateCols = updateColumns(table);
-  const selectCols = 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 = schemaName(mode, T, affix);
-    const tname = typeName(mode, T, affix);
-    const body = renderObjectShape(
-      cols,
-      mode,
-      coerceDates,
-      checks,
-      sets,
-      lengths,
-      cardinalities,
-      // The update schema references the insert-side inferred types: both describe a value going
-      // in, and `$inferSelect` would name the post-default type for a column a write may omit.
-      tj ? { ...tj, mode: mode === "select" ? "select" : "insert" } : void 0,
-      applyDefaults,
-      brands ? { plan: brands, tsName: T } : void 0
-    );
-    const expr = piped(`${NS}.Struct({
-${body}
-})`, rowSteps(rows, cols));
-    return `export const ${name} = ${expr};
-
-export type ${tname} = ${NS}.Schema.Type<typeof ${name}>;
-
-export const ${STANDARD_PREFIX}${name} = ${NS}.standardSchemaV1(${name});`;
-  });
-  const nestedByTable = ["insert", "select"].flatMap((m) => {
-    const plan = nested[m];
-    return plan ? nestedNodes(plan).map((n) => [n.table.tsName, nestedNodeCols(n, m)]) : [];
-  });
-  const nestedCols = nestedByTable.flatMap(([, cs]) => cs);
-  const referenced = /* @__PURE__ */ new Set();
-  if (typedJson) {
-    const all = !!typedJson.allColumns;
-    if ([...insertCols, ...updateCols, ...selectCols].some((c) => wantsRef(c, all))) {
-      referenced.add(T);
-    }
-    for (const [name, cs] of nestedByTable) {
-      if (cs.some((c) => wantsRef(c, all))) referenced.add(name);
-    }
-  }
-  const schemaImport = referenced.size ? `import type { ${[...referenced].join(", ")} } from '${typedJson.schemaSpecifier}';
-` : "";
-  const needsJson = !typedJson && [...insertCols, ...updateCols, ...selectCols, ...nestedCols].some(
-    (c) => c.shape?.kind === "json"
-  );
-  const finder = wantsDuplicateFinder ? renderDuplicateFinder(table, `findDuplicate${T}`, typeName("insert", T, affix)) : void 0;
-  const duplicates = finder ? `
-${finder}
-` : "";
-  const nestedCode = renderNestedSchemas(
-    table,
-    affix,
-    coerceDates,
-    typedJson,
-    applyDefaults,
-    nested,
-    brands
-  );
-  const selectName = schemaName("select", T, affix);
-  const brandAliases = (brands?.aliasesFor(T) ?? []).map(
-    (a) => `/** The nominal type of ${T}.${a.column}. */
-export type ${a.alias} = ${NS}.Schema.Type<typeof ${selectName}>[${JSON.stringify(a.column)}];`
-  ).join("\n\n");
-  const brandCode = brandAliases ? `
-${brandAliases}
-` : "";
-  const involved = [
-    table,
-    ...["insert", "select"].flatMap((m) => {
-      const plan = nested[m];
-      return plan ? nestedNodes(plan).map((n) => n.table) : [];
-    })
-  ];
-  const canonPreamble = involved.some((t) => {
-    const own = parsedChecksFor(t);
-    return needsNumericCanon(t.columns, own.checks, own.sets);
-  }) ? `
-${NUMERIC_CANON_SOURCE}` : "";
-  return `import * as ${NS} from 'effect/Schema';
-${schemaImport}${needsJson ? `
-${JSON_PREAMBLE}` : ""}${canonPreamble}
-${blocks.join("\n\n")}
-${brandCode}${nestedCode}${duplicates}`;
-}
-var EffectGenerator = class {
-  constructor(analysis) {
-    this.analysis = analysis;
-    this.library = "effect";
-  }
-  async generate(opts) {
-    const fs = fileWriter(opts.fileSink);
-    const path = await import("path");
-    const out = path.resolve(process.cwd(), opts.outDir);
-    const files = [];
-    await fs.mkdir(out, { recursive: true });
-    const affix = resolveAffix(opts);
-    const coerceDates = opts.coerceDates ?? "input";
-    const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
-    const wantsTypes = opts.typedJson || opts.typedColumns;
-    const typedJson = wantsTypes && opts.schemaPath ? {
-      schemaSpecifier: 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 ? resolveNestedDepth(opts.nestedDepth, (m) => console.warn(m)) : 0;
-    const brands = buildBrandPlan(this.analysis.tables, opts.branded);
-    for (const note of brands?.notes ?? []) console.warn(`[drzl] ${note}`);
-    for (const table of this.analysis.tables) {
-      const filePath = path.join(out, moduleFileName(table.tsName, fileSuffix));
-      const code = renderTableSchemas(
-        table,
-        affix,
-        coerceDates,
-        typedJson,
-        !!opts.applyDefaults,
-        !!opts?.duplicateFinder,
-        opts.nestedSchemas ? nestedPlansFor(table, this.analysis, nestedDepth) : {},
-        brands
-      );
-      const formatted = await formatCode(
-        buildHeader(opts.outputHeader) + code,
-        filePath,
-        opts.format
-      );
-      await fs.writeFile(filePath, formatted, "utf8");
-      files.push(filePath);
-    }
-    const indexPath = path.join(out, "index.ts");
-    const indexFormatted = await formatCode(
-      buildHeader(opts.outputHeader) + this.defaultIndex(this.analysis, opts),
-      indexPath,
-      opts.format
-    );
-    await fs.writeFile(indexPath, indexFormatted, "utf8");
-    files.push(indexPath);
-    return files;
-  }
-  renderTable(table, opts) {
-    return renderTableSchemas(
-      table,
-      resolveAffix(opts),
-      opts?.coerceDates ?? "input",
-      void 0,
-      !!opts?.applyDefaults,
-      !!opts?.duplicateFinder,
-      {},
-      buildBrandPlan(this.analysis.tables, opts?.branded)
-    );
-  }
-  defaultIndex(analysis, opts) {
-    const fileSuffix = opts.fileSuffix ?? DEFAULT_FILE_SUFFIX;
-    return analysis.tables.map(
-      (t) => `export * from '${moduleSpecifier(t.tsName, fileSuffix, opts.importExtension)}';`
-    ).join("\n") + "\n";
-  }
-};
-var index_default = EffectGenerator;
-function buildHeader(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";
-}
-export {
-  EffectGenerator,
-  index_default as default
-};
-//# sourceMappingURL=dist-KX62ETKK.js.map