@sdd-method/verify-cli 0.1.0

package/dist/lib/catalogue/csv-reader.js

@@ -0,0 +1,97 @@
+// CSV reader for catalogue files.
+//
+// RFC-4180-aware: handles `"` quoting (including doubled `""` for literal
+// quotes), commas inside quoted cells, and CR/LF/CRLF line breaks. We
+// don't try to be a general CSV library — the canonical writer's output
+// is the input shape we support, plus tolerance for byte-identical
+// catalogues authored by other conforming aggregator implementations.
+//
+// Headers come from the file's first line; column order is preserved
+// for traceability but row access is by column name.
+import { readFile } from "node:fs/promises";
+export async function readCatalogueCsv(path) {
+    const text = await readFile(path, "utf-8");
+    return parseCatalogueCsv(text);
+}
+export function parseCatalogueCsv(text) {
+    const records = parseRecords(text);
+    if (records.length === 0)
+        return { columns: [], rows: [] };
+    const columns = records[0] ?? [];
+    const rows = [];
+    for (let r = 1; r < records.length; r++) {
+        const record = records[r] ?? [];
+        if (record.length === 1 && record[0] === "")
+            continue; // empty trailing line
+        const row = {};
+        for (let c = 0; c < columns.length; c++) {
+            row[columns[c] ?? ""] = record[c] ?? "";
+        }
+        rows.push(row);
+    }
+    return { columns, rows };
+}
+function parseRecords(text) {
+    const records = [];
+    let current = [];
+    let cell = "";
+    let i = 0;
+    let inQuotes = false;
+    while (i < text.length) {
+        const ch = text[i] ?? "";
+        if (inQuotes) {
+            if (ch === '"') {
+                if (text[i + 1] === '"') {
+                    // Escaped double-quote inside a quoted cell.
+                    cell += '"';
+                    i += 2;
+                    continue;
+                }
+                inQuotes = false;
+                i++;
+                continue;
+            }
+            cell += ch;
+            i++;
+            continue;
+        }
+        if (ch === '"') {
+            inQuotes = true;
+            i++;
+            continue;
+        }
+        if (ch === ",") {
+            current.push(cell);
+            cell = "";
+            i++;
+            continue;
+        }
+        if (ch === "\r") {
+            if (text[i + 1] === "\n")
+                i++;
+            current.push(cell);
+            records.push(current);
+            current = [];
+            cell = "";
+            i++;
+            continue;
+        }
+        if (ch === "\n") {
+            current.push(cell);
+            records.push(current);
+            current = [];
+            cell = "";
+            i++;
+            continue;
+        }
+        cell += ch;
+        i++;
+    }
+    // Trailing cell + record.
+    if (cell !== "" || current.length > 0) {
+        current.push(cell);
+        records.push(current);
+    }
+    return records;
+}
+//# sourceMappingURL=csv-reader.js.map

package/dist/lib/catalogue/csv-writer.js

@@ -0,0 +1,96 @@
+/**
+ * Deterministic CSV writer for catalogues.
+ *
+ * Emits headers + sorted rows per ADR 0134 builder contract:
+ *   - column order matches the canonical schema exactly,
+ *   - rows sorted by primary-key value,
+ *   - cells with embedded comma/quote/newline are RFC-4180 quoted,
+ *   - empty trailing newline (POSIX convention).
+ *
+ * Headers-only emission is supported — pass an empty rows array to write
+ * a CSV that downstream consumers can rely on the file existence of.
+ *
+ * ⚠ BUT A HEADERS-ONLY WRITE NEVER TRUNCATES A CATALOGUE THAT HAS ROWS.
+ * `conformance_finding` is written by a DIFFERENT VERB — `sdd-cli conformance
+ * --emit-finding` calls writeFindings() into the same `catalogues/` directory —
+ * and nothing in the `catalogue build` row-collection path ever sets it. So
+ * build emitted a bare header over it, unconditionally, and one verb destroyed
+ * another verb's output. Measured across one estate: every SDD that had
+ * authored a conformance finding lost it, while the gate registries went on
+ * citing those rows as CURRENT evidence for a hard-gated score.
+ *
+ * ⚠ The first cut of this comment said `c4_system_entity` was a second
+ * producerless catalogue. It is not — `build.ts` sets it directly rather than
+ * via `builders/`, and the sweep that "found" it only searched `builders/`.
+ * An adopter disproved it by counterfactual, installing the defective version
+ * and measuring that its rows survived. Stated here because the wrong version
+ * shipped in 1.29.0 and a reader deserves the correction beside the claim.
+ *
+ * The guard is keyed on the CONDITION, not on those two names, so it also
+ * catches the case nobody has hit yet: a builder that regresses to zero rows
+ * silently deleting a populated catalogue.
+ */
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+/** Data-row count of an existing catalogue file, or 0 when absent/unreadable/header-only. */
+async function existingDataRows(filePath) {
+    let text;
+    try {
+        text = await readFile(filePath, "utf-8");
+    }
+    catch {
+        return 0;
+    }
+    const lines = text.split("\n").filter((l) => l.trim() !== "");
+    return lines.length > 1 ? lines.length - 1 : 0;
+}
+export async function writeCatalogue(opts) {
+    await mkdir(opts.outDir, { recursive: true });
+    const filePath = join(opts.outDir, `${opts.catalogue.name}.csv`);
+    // Refuse to replace rows with a bare header. Emitting one is correct when the
+    // file is absent or already empty — that is the "consumers can rely on the
+    // file existing" case — and is data loss when it is not.
+    if (opts.rows.length === 0) {
+        const onDisk = await existingDataRows(filePath);
+        if (onDisk > 0) {
+            return { rowCount: onDisk, path: filePath, preserved: true, preservedRows: onDisk };
+        }
+    }
+    const text = renderCatalogueCsv(opts.catalogue, opts.rows);
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, text, "utf-8");
+    return { rowCount: opts.rows.length, path: filePath };
+}
+export function renderCatalogueCsv(catalogue, rows) {
+    const columns = catalogue.columns.map((c) => c.name);
+    const lines = [];
+    lines.push(columns.map(escapeCell).join(","));
+    const sorted = [...rows].sort((a, b) => compareCell(a[catalogue.primaryKey], b[catalogue.primaryKey]));
+    for (const row of sorted) {
+        const cells = columns.map((col) => escapeCell(formatCell(row[col])));
+        lines.push(cells.join(","));
+    }
+    // Trailing newline per POSIX convention.
+    return `${lines.join("\n")}\n`;
+}
+function formatCell(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    return String(value);
+}
+function escapeCell(value) {
+    if (value === "")
+        return "";
+    if (/[",\n\r]/.test(value)) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}
+function compareCell(a, b) {
+    const sa = a === undefined || a === null ? "" : String(a);
+    const sb = b === undefined || b === null ? "" : String(b);
+    return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+//# sourceMappingURL=csv-writer.js.map

package/dist/lib/catalogue/ddl-generator.js

@@ -0,0 +1,233 @@
+/**
+ * Schema→DDL generator — M-ADR 0205 §4.3 (engine-evolution Phase A1).
+ *
+ * Emits, from the loaded canonical schema:
+ *   (a) CREATE TABLE DDL for every declared catalogue, typed per the
+ *       schema's column types; and
+ *   (b) a deterministic list of constraint-violation queries (fk | pk |
+ *       enum) whose row semantics mirror fk-validator.ts and
+ *       enum-validator.ts EXACTLY — the Phase A2 dual-run comparison
+ *       (old path vs engine path, count AND list) depends on that
+ *       equivalence, so any semantic change here must change there too:
+ *         - fk: a required (non-nullable, non-external) FK fails when
+ *           empty; a non-empty value must resolve against the target
+ *           catalogue's primary keys unless the FK is effective-external
+ *           (declared `external`, or external for the build's profile via
+ *           `externalForProfiles`) — mirroring FkValidationOptions.
+ *         - pk: duplicate non-empty primary-key values.
+ *         - enum: a non-empty (trimmed) bound-column value outside the
+ *           bound enum's declared set. Emptiness is nullability's concern,
+ *           not the enum's, exactly as in enum-validator.ts.
+ *
+ * Determinism per M-ADR 0205 §4.2: emission order is the schema's own
+ * declaration order; every query carries a total ORDER BY.
+ *
+ * Digest coupling per §4.3 is inherited, not re-implemented: this module
+ * reads the schema through loadCanonicalSchema, and the vendored copy it
+ * loads is guarded by canonical-schema-drift.test.ts.
+ *
+ * There is NO hand-maintained DDL anywhere: an unknown column type or a
+ * binding to an unknown enum throws at generation time — loud, never a
+ * silent fallback (the known*Ids.has() lesson).
+ */
+import { PLATFORM_STAMP_COLUMN, isPlatformScopedFk } from "./fk-validator.js";
+/** Closed map from schema column types to engine column types. */
+const TYPE_MAP = {
+    string: "VARCHAR",
+    int: "INTEGER",
+    integer: "INTEGER",
+    number: "DOUBLE",
+    date: "DATE",
+    boolean: "BOOLEAN",
+};
+/** Engine type for a schema column type; throws on an unmapped type. */
+export function sqlType(catalogue, column, type) {
+    const mapped = TYPE_MAP[type];
+    if (!mapped) {
+        throw new Error(`ddl-generator: ${catalogue}.${column} declares unmapped column type "${type}" — extend TYPE_MAP deliberately, never default`);
+    }
+    return mapped;
+}
+/**
+ * The one definition of effective-external, shared with the engine
+ * validator so the three consumers (fk-validator.ts, the query generator,
+ * engine-validator.ts) cannot drift: declared `external`, or external for
+ * the build's profile via `externalForProfiles`.
+ */
+export function isEffectiveExternal(fk, options) {
+    return (fk.external ||
+        (options.profile !== undefined &&
+            (fk.externalForProfiles ?? []).includes(options.profile)));
+}
+function quote(identifier) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+        throw new Error(`ddl-generator: identifier "${identifier}" is outside the schema's naming form — refusing to interpolate it into SQL`);
+    }
+    return `"${identifier}"`;
+}
+function sqlStringLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+ * One CREATE TABLE statement per catalogue, in schema declaration order.
+ * Plain typed columns only: enforcement of PK/FK/enum semantics lives in
+ * the violation queries, whose findings-shaped output (never a load
+ * abort) is what the validators' exit contracts need.
+ */
+export function generateTableDdl(schema) {
+    return schema.catalogues.map((cat) => {
+        const cols = cat.columns
+            .map((c) => `  ${quote(c.name)} ${sqlType(cat.name, c.name, c.type)}`)
+            .join(",\n");
+        return `CREATE TABLE ${quote(cat.name)} (\n${cols}\n);`;
+    });
+}
+/**
+ * The violation-query set for a schema, mirroring the in-memory
+ * validators' semantics under the same options they take.
+ */
+export function generateConstraintQueries(schema, options = {}) {
+    const catalogueNames = new Set(schema.catalogues.map((c) => c.name));
+    const queries = [];
+    const catByName = new Map(schema.catalogues.map((c) => [c.name, c]));
+    for (const cat of schema.catalogues) {
+        queries.push(pkQuery(cat, options));
+        for (const fk of cat.foreignKeys) {
+            const [targetCat, targetCol] = fk.references.split(".");
+            if (!targetCat || !targetCol) {
+                throw new Error(`ddl-generator: malformed FK reference "${fk.references}" on ${cat.name}.${fk.column}`);
+            }
+            if (!catalogueNames.has(targetCat)) {
+                throw new Error(`ddl-generator: FK ${cat.name}.${fk.column} references unknown catalogue "${targetCat}"`);
+            }
+            if (!cat.columns.some((c) => c.name === fk.column)) {
+                throw new Error(`ddl-generator: FK column ${cat.name}.${fk.column} is not a declared column — the schema 3.1.3 vacuous-binding class`);
+            }
+            const effectiveExternal = isEffectiveExternal(fk, options);
+            // Mirrors fk-validator.ts exactly: the required-empty clause is keyed
+            // on the DECLARED external flag; the dangling clause is keyed on
+            // effective-external (unless the aggregator asks for internal
+            // treatment).
+            const checkEmpty = !fk.nullable && !fk.external;
+            const checkDangling = !effectiveExternal || options.treatExternalAsInternal === true;
+            if (!checkEmpty && !checkDangling)
+                continue;
+            const t = quote(cat.name);
+            const col = quote(fk.column);
+            const pk = quote(cat.primaryKey);
+            const clauses = [];
+            if (checkEmpty) {
+                clauses.push(`(t.${col} IS NULL OR t.${col} = '')`);
+            }
+            if (checkDangling) {
+                // M-ADR 0208 §4.4 (F-D): a platform-scoped target resolves on
+                // (platform_sdd_id, pk) — equal stamps, or either side unstamped.
+                // Mirrors fk-validator.ts's `resolved` predicate exactly.
+                const stamp = quote(PLATFORM_STAMP_COLUMN);
+                const scope = isPlatformScopedFk(cat, catByName.get(targetCat), options)
+                    ? ` AND (COALESCE(t.${stamp}, '') = '' OR COALESCE(r.${stamp}, '') = '' OR r.${stamp} = t.${stamp})`
+                    : "";
+                clauses.push(`(t.${col} IS NOT NULL AND t.${col} <> '' AND NOT EXISTS (` +
+                    `SELECT 1 FROM ${quote(targetCat)} r WHERE r.${quote(targetCol)} = t.${col}${scope}))`);
+            }
+            queries.push({
+                catalogue: cat.name,
+                kind: "fk",
+                column: fk.column,
+                target: fk.references,
+                sql: `SELECT t.${pk} AS row_pk, COALESCE(t.${col}, '') AS value FROM ${t} t ` +
+                    `WHERE ${clauses.join(" OR ")} ORDER BY row_pk, value;`,
+            });
+        }
+        for (const [column, enumRef] of Object.entries(cat.columnEnums)) {
+            const enumName = enumRef.replace(/^enums\./, "");
+            const enumDef = schema.enums[enumName];
+            if (!enumDef) {
+                throw new Error(`ddl-generator: ${cat.name}.${column} binds unknown enum "${enumRef}" — a binding that names no enum must not validate as vacuously true`);
+            }
+            if (!cat.columns.some((c) => c.name === column)) {
+                throw new Error(`ddl-generator: ${cat.name}.${column} binds a column the catalogue does not declare — the schema 3.1.3 vacuous-binding class`);
+            }
+            const allowed = enumDef.values
+                .map((v) => sqlStringLiteral(v.value))
+                .join(", ");
+            const t = quote(cat.name);
+            const col = quote(column);
+            const pk = quote(cat.primaryKey);
+            queries.push({
+                catalogue: cat.name,
+                kind: "enum",
+                column,
+                target: enumName,
+                sql: 
+                // TRIM in the projection too: enum-validator.ts records the
+                // TRIMMED value in its violation objects, and A2's count-and-list
+                // parity compares those objects field-for-field.
+                `SELECT t.${pk} AS row_pk, TRIM(t.${col}) AS value FROM ${t} t ` +
+                    `WHERE t.${col} IS NOT NULL AND TRIM(t.${col}) <> '' ` +
+                    `AND TRIM(t.${col}) NOT IN (${allowed}) ORDER BY row_pk, value;`,
+            });
+        }
+    }
+    return queries;
+}
+/**
+ * Dangling-value queries for the FKs the main set SKIPS as
+ * effective-external — one query per skipped FK, returning the rows the
+ * in-memory path logs as `[finding] external` (unresolved non-empty
+ * values; resolution happens at aggregation). Empty when
+ * treatExternalAsInternal is set, exactly as the main set then skips
+ * nothing. Kept separate from generateConstraintQueries because these
+ * rows are FINDINGS, not failures — the exit contracts differ.
+ */
+export function generateExternalFindingQueries(schema, options = {}) {
+    if (options.treatExternalAsInternal === true)
+        return [];
+    const queries = [];
+    for (const cat of schema.catalogues) {
+        for (const fk of cat.foreignKeys) {
+            if (!isEffectiveExternal(fk, options))
+                continue;
+            const [targetCat, targetCol] = fk.references.split(".");
+            if (!targetCat || !targetCol) {
+                throw new Error(`ddl-generator: malformed FK reference "${fk.references}" on ${cat.name}.${fk.column}`);
+            }
+            const t = quote(cat.name);
+            const col = quote(fk.column);
+            const pk = quote(cat.primaryKey);
+            queries.push({
+                catalogue: cat.name,
+                kind: "fk",
+                column: fk.column,
+                target: fk.references,
+                sql: `SELECT t.${pk} AS row_pk, t.${col} AS value FROM ${t} t ` +
+                    `WHERE t.${col} IS NOT NULL AND t.${col} <> '' AND NOT EXISTS (` +
+                    `SELECT 1 FROM ${quote(targetCat)} r WHERE r.${quote(targetCol)} = t.${col}) ` +
+                    `ORDER BY row_pk, value;`,
+            });
+        }
+    }
+    return queries;
+}
+function pkQuery(cat, options = {}) {
+    const t = quote(cat.name);
+    const pk = quote(cat.primaryKey);
+    // M-ADR 0208 §4.4 (F-D): for a platform-scoped catalogue the key is
+    // (platform_sdd_id, pk). n rows sharing a pk are distinct iff every one
+    // carries a stamp and the stamps are all different — an EMPTY stamp is
+    // unresolved, never a key, so it collides with everything. Mirrors
+    // aggregate.ts findDuplicatePrimaryKeys.
+    const scoped = isPlatformScopedFk(cat, cat, options);
+    const having = scoped
+        ? `HAVING COUNT(*) > COUNT(DISTINCT NULLIF(${quote(PLATFORM_STAMP_COLUMN)}, ''))`
+        : `HAVING COUNT(*) > 1`;
+    return {
+        catalogue: cat.name,
+        kind: "pk",
+        column: cat.primaryKey,
+        sql: `SELECT ${pk} AS row_pk, COUNT(*) AS n FROM ${t} ` +
+            `WHERE ${pk} IS NOT NULL AND ${pk} <> '' ` +
+            `GROUP BY ${pk} ${having} ORDER BY row_pk;`,
+    };
+}
+//# sourceMappingURL=ddl-generator.js.map

package/dist/lib/catalogue/engine-validator.js

@@ -0,0 +1,222 @@
+/**
+ * Engine-path FK/PK/enum validation — M-ADR 0205 §4.4 (Phase A2).
+ *
+ * Runs the ddl-generator's queries on the embedded engine and returns
+ * results in the SAME shapes as fk-validator.ts / enum-validator.ts, so
+ * the parity harness can compare count AND list, field for field. The
+ * input is the same rowsByCatalogue map the in-memory validators take:
+ * A2 compares the two VALIDATION implementations on identical parsed
+ * input — CSV-read equivalence is deliberately out of this comparison's
+ * scope and belongs to the cutover evaluation.
+ *
+ * The engine package is a devDependency until cutover (M-ADR 0205 §4.1's
+ * no-fallback rule governs how it eventually ships). It is imported
+ * dynamically inside the entry function so merely loading this module
+ * never requires it: no production path imports the engine today, and an
+ * adopter install without the package only fails if something actually
+ * calls it — loudly.
+ *
+ * PK-duplicate detection has NO in-memory counterpart at validate time
+ * (builders dedupe at emission instead), so pkDuplicates is engine-only
+ * information: reported, never part of the parity claim — you cannot
+ * claim agreement with an instrument that does not exist.
+ */
+import { generateConstraintQueries, generateExternalFindingQueries, generateTableDdl, sqlType, } from "./ddl-generator.js";
+const INSERT_CHUNK = 500;
+function sqlStringLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+ * One loaded engine: schema DDL applied, every provided catalogue's rows
+ * inserted. Shared by the FK/PK/enum path and the coverage predicates so
+ * there is exactly one load semantics to reason about.
+ */
+export async function createEngineSession(schema, rowsByCatalogue) {
+    const { DuckDBInstance } = await import("@duckdb/node-api");
+    const instance = await DuckDBInstance.create(":memory:");
+    const conn = await instance.connect();
+    for (const ddl of generateTableDdl(schema)) {
+        await conn.run(ddl);
+    }
+    await loadRows(conn, schema, rowsByCatalogue);
+    return { conn, dispose: () => conn.disconnectSync() };
+}
+// @rule engine-fk-validation
+export async function validateWithEngine(schema, rowsByCatalogue, options = {}) {
+    const session = await createEngineSession(schema, rowsByCatalogue);
+    const conn = session.conn;
+    try {
+        const typeNonconformances = await findTypeNonconformances(conn, schema, rowsByCatalogue);
+        const failures = [];
+        const enumViolations = [];
+        const pkDuplicates = [];
+        for (const q of generateConstraintQueries(schema, options)) {
+            const reader = await conn.runAndReadAll(q.sql);
+            for (const row of reader.getRows()) {
+                if (q.kind === "fk") {
+                    failures.push({
+                        catalogue: q.catalogue,
+                        column: q.column,
+                        referencingRow: String(row[0] ?? ""),
+                        value: String(row[1] ?? ""),
+                        target: q.target,
+                    });
+                }
+                else if (q.kind === "enum") {
+                    const enumDef = schema.enums[q.target];
+                    enumViolations.push({
+                        catalogue: q.catalogue,
+                        column: q.column,
+                        rowPk: row[0] === null || row[0] === undefined ? "<no-pk>" : String(row[0]),
+                        value: String(row[1] ?? ""),
+                        allowed: enumDef.values.map((v) => v.value).join(" | "),
+                    });
+                }
+                else {
+                    pkDuplicates.push({
+                        catalogue: q.catalogue,
+                        rowPk: String(row[0] ?? ""),
+                        count: Number(row[1]),
+                    });
+                }
+            }
+        }
+        const externalFindingDetails = [];
+        for (const q of generateExternalFindingQueries(schema, options)) {
+            const reader = await conn.runAndReadAll(q.sql);
+            for (const row of reader.getRows()) {
+                externalFindingDetails.push({
+                    catalogue: q.catalogue,
+                    column: q.column,
+                    target: q.target,
+                    rowPk: row[0] === null || row[0] === undefined ? "?" : String(row[0]),
+                    value: String(row[1] ?? ""),
+                });
+            }
+        }
+        return {
+            fk: {
+                internalPass: failures.length === 0,
+                internalFailures: failures,
+                externalFindings: externalFindingDetails.length,
+            },
+            enums: { pass: enumViolations.length === 0, violations: enumViolations },
+            externalFindingDetails,
+            pkDuplicates,
+            typeNonconformances,
+        };
+    }
+    finally {
+        session.dispose();
+    }
+}
+/**
+ * The A4 cutover surface: runs the engine validation and writes findings
+ * into the caller's FindingsLog with BYTE-IDENTICAL text to what
+ * fk-validator.ts / enum-validator.ts wrote — adopters' committed
+ * findings baselines hold those literal lines, so the text is a
+ * compatibility contract, not a style choice. Line ORDER within a
+ * category follows the engine's total ORDER BY (M-ADR 0205 §4.2) and may
+ * differ from the old file-order rendering; baselines compare by
+ * membership, so ordering is free — declared in the change-set anyway.
+ */
+export async function validateWithEngineToLog(schema, rowsByCatalogue, findings, options = {}, extras = {}) {
+    const logEnumFindings = extras.logEnumFindings !== false;
+    const res = await validateWithEngine(schema, rowsByCatalogue, options);
+    for (const d of res.externalFindingDetails) {
+        findings.add("external", `${d.catalogue}.${d.column} → ${d.target}=${d.value} ` +
+            `(referencing row pk=${d.rowPk}; resolves at aggregation)`);
+    }
+    if (logEnumFindings) {
+        const enumNameByCatalogueColumn = new Map();
+        for (const cat of schema.catalogues) {
+            for (const [column, enumRef] of Object.entries(cat.columnEnums)) {
+                enumNameByCatalogueColumn.set(`${cat.name}.${column}`, enumRef.replace(/^enums\./, ""));
+            }
+        }
+        for (const v of res.enums.violations) {
+            const enumName = enumNameByCatalogueColumn.get(`${v.catalogue}.${v.column}`);
+            findings.add("divergence", `${v.catalogue}.${v.column}: row ${v.rowPk} value "${v.value}" is outside the bound enum ${enumName} (${v.allowed})`, "error");
+        }
+    }
+    return { fk: res.fk, enums: res.enums };
+}
+async function loadRows(conn, schema, rowsByCatalogue) {
+    for (const cat of schema.catalogues) {
+        const rows = rowsByCatalogue.get(cat.name) ?? [];
+        if (rows.length === 0)
+            continue;
+        for (let i = 0; i < rows.length; i += INSERT_CHUNK) {
+            const chunk = rows.slice(i, i + INSERT_CHUNK);
+            const tuples = chunk
+                .map((row) => `(${cat.columns
+                .map((c) => literal(row[c.name], cat.name, c.name, c.type))
+                .join(", ")})`)
+                .join(",\n");
+            await conn.run(`INSERT INTO "${cat.name}" VALUES\n${tuples};`);
+        }
+    }
+}
+/**
+ * Renders one cell. String columns keep the empty string AS an empty
+ * string — the in-memory validators' emptiness predicates see '' from the
+ * CSV reader, and the generated queries test both NULL and ''. Non-string
+ * columns TRY_CAST with '' becoming NULL: one uncastable cell must not
+ * abort a whole run (measured on a real estate: a prose value in a
+ * date-typed column), and the miss is not smoothed either —
+ * findTypeNonconformances re-derives every such cell with the engine's
+ * own cast semantics and reports it.
+ */
+function literal(value, catalogue, column, type) {
+    const s = value === null || value === undefined ? "" : String(value);
+    if (type === "string")
+        return sqlStringLiteral(s);
+    if (s === "")
+        return "NULL";
+    return `TRY_CAST(${sqlStringLiteral(s)} AS ${sqlType(catalogue, column, type)})`;
+}
+/**
+ * Exact engine-semantics detection of the cells TRY_CAST nulled: the
+ * distinct non-empty values of every typed column are re-checked with the
+ * SAME cast the load used — a JS re-implementation of the engine's parsers
+ * would be a second opinion pretending to be the first.
+ */
+async function findTypeNonconformances(conn, schema, rowsByCatalogue) {
+    const out = [];
+    for (const cat of schema.catalogues) {
+        const rows = rowsByCatalogue.get(cat.name) ?? [];
+        if (rows.length === 0)
+            continue;
+        for (const col of cat.columns) {
+            if (col.type === "string")
+                continue;
+            const counts = new Map();
+            for (const row of rows) {
+                const v = row[col.name];
+                const s = v === null || v === undefined ? "" : String(v);
+                if (s === "")
+                    continue;
+                counts.set(s, (counts.get(s) ?? 0) + 1);
+            }
+            if (counts.size === 0)
+                continue;
+            const engineType = sqlType(cat.name, col.name, col.type);
+            const values = [...counts.keys()].sort();
+            const tuples = values.map((v) => `(${sqlStringLiteral(v)})`).join(", ");
+            const reader = await conn.runAndReadAll(`SELECT v FROM (VALUES ${tuples}) t(v) ` +
+                `WHERE TRY_CAST(v AS ${engineType}) IS NULL ORDER BY v;`);
+            for (const row of reader.getRows()) {
+                const value = String(row[0]);
+                out.push({
+                    catalogue: cat.name,
+                    column: col.name,
+                    declaredType: col.type,
+                    value,
+                    rows: counts.get(value) ?? 0,
+                });
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=engine-validator.js.map