@omgbase/core 0.1.0

package/dist/src/oqx-js/sql/translate.js

@@ -0,0 +1,290 @@
+// Semantics-faithful OQX-expression → SQLite translator (ADR-013 pushdown seam).
+//
+// This is the piece that lets the SQLite adapter push scalar work DOWN into the
+// store instead of materializing rows and finishing them in the in-memory
+// engine. It walks an `@omgbase/oqx` scalar `Expr` and returns a SQL fragment +
+// bound params, or `null` when it cannot translate a construction faithfully —
+// in which case the planner leaves that conjunct residual (correct, just slower).
+//
+// The cardinal rule is FIDELITY, not cleverness: the SQL a fragment emits MUST
+// evaluate to the same result as `@omgbase/oqx`'s in-memory `semantics.ts` for
+// every input, because the differential conformance suite runs each query BOTH
+// ways and asserts equality. Two consequences drive the design:
+//
+//   • oqx-js string ops are CASE-SENSITIVE, but SQLite `LIKE` is case-insensitive
+//     for ASCII. So `startsWith`/`contains`/`endsWith` translate to
+//     `substr`/`instr`, NEVER `LIKE`. `$path.lower().startsWith("lab/")` becomes
+//     `substr(lower(d.path), 1, length(?)) = ?` — the lowercasing is explicit and
+//     the match is byte-exact, matching the in-memory path.
+//   • oqx-js `==`/`!=` are absence-NORMALIZED (two absent values are equal;
+//     `absent != v` is true). SQLite `=`/`<>` are not null-safe. So `==` → `IS`
+//     and `!=` → `IS NOT` (SQLite's null-safe operators), which reproduce
+//     `equals(a,b)` including the both-absent and negation cases, while still
+//     honoring SQLite's typed comparison (`5 IS '5'` is false, matching strict
+//     `5 === "5"`).
+//
+// Only forms that are faithful in a POSITIVE, AND-composed context are
+// translated (that is the only context `partitionPushable` pushes into). `||`,
+// `!`, `in`, `matches` (needs a regexp UDF), and bare content-property routing
+// are deliberately declined here and left residual for now.
+// ---- intrinsics -------------------------------------------------------------
+// A `$`-namespaced intrinsic → a param-free SQL scalar, per target. Anything not
+// mapped (e.g. docs `$body`, reconstructed; `$title`/`$tags`, computed) returns
+// null → residual. `$updated_at`/`$dst_path`/`$dst_uri` are correlated subqueries.
+function intrinsicSql(name, ctx) {
+    const { self, doc, target } = ctx;
+    if (target === "docs")
+        switch (name) {
+            case "$id": return `${self}.doc_id`;
+            case "$path": return `${doc}.path`;
+            case "$content_hash": return `lower(hex(${self}.file_hash))`;
+            case "$updated_at": return `(SELECT c.ts FROM revisions r JOIN commits c ON c.commit_id = r.commit_id WHERE r.rev_id = ${self}.current_rev)`;
+        }
+    else if (target === "blocks")
+        switch (name) {
+            case "$id": return `${self}.block_id`;
+            case "$doc": return `${self}.doc_id`;
+            case "$path": return `${doc}.path`;
+            case "$ordinal": return `${self}.ordinal`;
+            case "$depth": return `${self}.depth`;
+            case "$body": return `${self}.text`;
+            case "$content_hash": return `lower(hex(${self}.raw_hash))`;
+        }
+    else if (target === "nodes")
+        switch (name) {
+            case "$id":
+            case "$node_id": return `${self}.node_id`;
+            case "$doc_id": return `${self}.doc_id`;
+            case "$block_id": return `${self}.block_id`;
+            case "$path": return `${doc}.path`;
+        }
+    else if (target === "edges")
+        switch (name) {
+            case "$id": return `${self}.edge_id`;
+            case "$src": return `${self}.src_doc`;
+            case "$dst": return `${self}.dst_node`;
+            case "$src_block": return `${self}.src_block`;
+            case "$via": return `${self}.via_node`;
+            case "$from_commit": return `${self}.from_commit`;
+            case "$path": return `${doc}.path`;
+            case "$dst_path": return `(SELECT dd.path FROM docs dd WHERE dd.doc_id = ${self}.dst_node)`;
+            case "$dst_uri": return `(SELECT xn.uri FROM external_nodes xn WHERE xn.node_id = ${self}.dst_node)`;
+        }
+    return null;
+}
+// docs intrinsics whose BARE (non-$) form is a loud error in-memory (10 §2) — not
+// pushable, so the residual raises it.
+const RESERVED_DOC_BASENAMES = new Set(["id", "path", "updated_at", "content_hash", "body"]);
+const SEG = /^[A-Za-z_][A-Za-z0-9_]*$/; // injection-safe inlined identifier
+// A single-valued document property (the CEL scalar-in-scope rule): the scalar
+// value only when the key has exactly one row in scope and it is card='scalar',
+// else NULL — matching the store context's `docProp` for a scalar read.
+function propScalar(docAlias, key) {
+    if (!SEG.test(key))
+        return null;
+    return `(SELECT COALESCE(p.val_text, p.val_num, p.val_bool) FROM properties p
+           WHERE p.doc_id = ${docAlias}.doc_id AND p.key = '${key}' AND p.card = 'scalar' AND p.deleted_commit IS NULL
+             AND (SELECT COUNT(*) FROM properties p2 WHERE p2.doc_id = ${docAlias}.doc_id AND p2.key = '${key}' AND p2.deleted_commit IS NULL) = 1
+           LIMIT 1)`;
+}
+// json_extract path from validated segments, or null if any segment is unsafe.
+function jsonExtract(col, segs) {
+    if (segs.some((s) => !SEG.test(s)))
+        return null;
+    return `json_extract(${col}, '$.${segs.join(".")}')`;
+}
+// better-sqlite3 binds only number/string/bigint/buffer/null — coerce booleans
+// to 1/0 (matching how json_extract surfaces JSON booleans, so `attrs.b == true`
+// compares against `1`). Non-bindable values are left as-is (they only reach a
+// bound `?` for lit/binding operands, which are scalars in practice).
+function bindable(v) {
+    return typeof v === "boolean" ? (v ? 1 : 0) : v;
+}
+// The dotted `attrs.a.b` / `doc.x` receiver chain as segments, or null if it is
+// not a plain identifier navigation.
+function memberSegments(e) {
+    if (e.kind === "ident")
+        return [e.name];
+    if (e.kind === "member") {
+        const base = memberSegments(e.recv);
+        return base ? [...base, e.name] : null;
+    }
+    return null;
+}
+// ---- value position ---------------------------------------------------------
+/** Translate an expression used as a VALUE (comparison operand, method receiver,
+ * function argument) to a SQL scalar. Returns null if not faithfully translatable. */
+export function translateValue(e, ctx) {
+    const { self, doc, target } = ctx;
+    switch (e.kind) {
+        case "lit":
+            return { sql: "?", params: [bindable(e.value)] };
+        case "binding":
+            return { sql: "?", params: [bindable(ctx.params[e.index])] };
+        case "ident": {
+            if (e.name.startsWith("$")) {
+                const sql = intrinsicSql(e.name, ctx);
+                return sql ? { sql, params: [] } : null;
+            }
+            // Bare field per target.
+            if (target === "docs") {
+                if (e.name === "format")
+                    return { sql: `${self}.format`, params: [] }; // a column, not a property
+                if (RESERVED_DOC_BASENAMES.has(e.name))
+                    return null; // residual raises the guard
+                const sql = propScalar(doc, e.name);
+                return sql ? { sql, params: [] } : null;
+            }
+            if (target === "blocks") {
+                if (e.name === "type" || e.name === "text")
+                    return { sql: `${self}.${e.name}`, params: [] };
+                // Bare non-structural identifier flattens into attrs — same pushdown as
+                // the `attrs.<k>` member form (json_extract), so `checked` == `attrs.checked`.
+                const sql = jsonExtract(`${self}.attrs`, [e.name]);
+                return sql ? { sql, params: [] } : null;
+            }
+            if (target === "nodes") {
+                if (e.name === "kind" || e.name === "name" || e.name === "value")
+                    return { sql: `${self}.${e.name}`, params: [] };
+                // Bare non-structural identifier flattens into attrs (see blocks above).
+                const sql = jsonExtract(`${self}.attrs`, [e.name]);
+                return sql ? { sql, params: [] } : null;
+            }
+            if (target === "edges") {
+                if (["predicate", "provenance", "dst_kind", "anchor", "src_field"].includes(e.name))
+                    return { sql: `${self}.${e.name}`, params: [] };
+                return null;
+            }
+            return null;
+        }
+        case "member": {
+            const segs = memberSegments(e);
+            if (!segs || segs.length < 2)
+                return null;
+            const [head, ...rest] = segs;
+            // attrs.<path> → json_extract on the row's attrs (blocks/nodes).
+            if (head === "attrs" && (target === "blocks" || target === "nodes")) {
+                const sql = jsonExtract(`${self}.attrs`, rest);
+                return sql ? { sql, params: [] } : null;
+            }
+            // doc.<x> reach-through — the owning doc (alias `doc`, which is `d`). On the
+            // docs target `doc` is the row itself; either way it resolves against `doc`.
+            if (head === "doc") {
+                if (rest.length !== 1)
+                    return null;
+                const k = rest[0];
+                if (k === "$path")
+                    return { sql: `${doc}.path`, params: [] };
+                if (k === "format")
+                    return { sql: `${doc}.format`, params: [] };
+                if (k.startsWith("$"))
+                    return null;
+                if (RESERVED_DOC_BASENAMES.has(k))
+                    return null;
+                const sql = propScalar(doc, k);
+                return sql ? { sql, params: [] } : null;
+            }
+            // block.type / block.text reach-through from a node.
+            if (head === "block" && target === "nodes" && rest.length === 1 && (rest[0] === "type" || rest[0] === "text")) {
+                return { sql: `(SELECT bb.${rest[0]} FROM blocks bb WHERE bb.block_id = ${self}.block_id)`, params: [] };
+            }
+            return null;
+        }
+        case "call": {
+            // `.lower()` / `.upper()` are the value-position string methods.
+            if (e.recv !== null && e.args.length === 0 && (e.name === "lower" || e.name === "upper")) {
+                const recv = translateValue(e.recv, ctx);
+                if (!recv)
+                    return null;
+                return { sql: `${e.name}(${recv.sql})`, params: recv.params };
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+// ---- predicate position -----------------------------------------------------
+const IS_OP = {
+    "==": "IS",
+    "!=": "IS NOT",
+    "<": "<",
+    "<=": "<=",
+    ">": ">",
+    ">=": ">=",
+};
+/** Translate an expression used as a boolean PREDICATE to a SQL boolean, or null
+ * if it cannot be pushed faithfully. Only positive, AND-safe forms are handled. */
+export function translatePredicate(e, ctx) {
+    switch (e.kind) {
+        case "logical":
+            // Only `&&` composes faithfully in a positive context; `||` is declined
+            // (its NULL/short-circuit interaction is not worth risking — leave residual).
+            if (e.op !== "&&")
+                return null;
+            return join2(translatePredicate(e.left, ctx), translatePredicate(e.right, ctx), "AND");
+        case "binary":
+            return translateComparison(e, ctx);
+        case "call":
+            return translateStringPredicate(e, ctx);
+        default:
+            // `unary` (!), `in`, bare truthy idents, member reach-through: residual.
+            return null;
+    }
+}
+function translateComparison(e, ctx) {
+    const op = IS_OP[e.op];
+    if (!op)
+        return null; // arithmetic operator in predicate position → residual
+    const l = translateValue(e.left, ctx);
+    const r = translateValue(e.right, ctx);
+    if (!l || !r)
+        return null;
+    // `==`/`!=` → null-safe IS / IS NOT (absence-normalized equality, faithful in
+    // any context). Relational ops → plain SQL: a NULL operand yields NULL, which
+    // is excluded in the positive AND context these fragments are pushed into,
+    // matching `relate`'s absent-operand ⇒ false rule.
+    return { sql: `(${l.sql} ${op} ${r.sql})`, params: [...l.params, ...r.params] };
+}
+// startsWith / contains / endsWith — CASE-SENSITIVE, via substr/instr (never
+// LIKE). `matches` (regex) is declined until a `regexp` UDF is registered.
+function translateStringPredicate(e, ctx) {
+    if (e.recv === null || e.args.length !== 1)
+        return null;
+    const recv = translateValue(e.recv, ctx);
+    const arg = translateValue(e.args[0], ctx);
+    if (!recv || !arg)
+        return null;
+    switch (e.name) {
+        case "startsWith":
+            // recv begins with arg ⇔ its first length(arg) chars equal arg.
+            return {
+                sql: `(substr(${recv.sql}, 1, length(${arg.sql})) = ${arg.sql})`,
+                params: [...recv.params, ...arg.params, ...arg.params],
+            };
+        case "endsWith":
+            // recv ends with arg ⇔ its last length(arg) chars equal arg. When arg is
+            // longer than recv, substr clamps to the whole string (a shorter value),
+            // so the equality is false — matching String.prototype.endsWith.
+            return {
+                sql: `(substr(${recv.sql}, -length(${arg.sql})) = ${arg.sql})`,
+                params: [...recv.params, ...arg.params, ...arg.params],
+            };
+        case "contains":
+            // substring test, case-sensitive.
+            return {
+                sql: `(instr(${recv.sql}, ${arg.sql}) > 0)`,
+                params: [...recv.params, ...arg.params],
+            };
+        default:
+            return null;
+    }
+}
+// Combine two optional fragments with a boolean connective; null if either is
+// untranslatable (the whole conjunct then stays residual).
+function join2(a, b, connective) {
+    if (!a || !b)
+        return null;
+    return { sql: `(${a.sql} ${connective} ${b.sql})`, params: [...a.params, ...b.params] };
+}
+//# sourceMappingURL=translate.js.map

package/dist/src/reconcile/crossdoc.d.ts

@@ -0,0 +1,34 @@
+import type { MatchBlock, ReconcileConfig } from "./types.js";
+import type { DocReconcileResult } from "./reconcile.js";
+export interface PerDocUnmatched {
+    docId: string;
+    /** old blocks that ended up deleted this run (id + content) */
+    deleted: {
+        block: MatchBlock;
+    }[];
+    /** new blocks minted as 'inserted' this run (key + assigned id + content) */
+    inserted: {
+        block: MatchBlock;
+        mintedId: string;
+    }[];
+}
+export interface CrossDocMatch {
+    /** source doc where the block was deleted */
+    fromDoc: string;
+    /** destination doc where it reappeared */
+    toDoc: string;
+    /** the surviving id (the deleted block's id carries across) */
+    carriedId: string;
+    /** the minted id that should be REPLACED by carriedId */
+    replacedMintedId: string;
+    newKey: string;
+    kind: "moved" | "edited_moved";
+    confidence: number;
+}
+export declare function crossDocMatch(docs: PerDocUnmatched[], config?: ReconcileConfig): CrossDocMatch[];
+/**
+ * Apply cross-doc matches back into per-doc reconcile results: the destination
+ * doc's minted 'inserted' id is replaced by the carried id (moved/edited_moved),
+ * and the source doc's 'deleted' disposition for that id is dropped.
+ */
+export declare function applyCrossDocMatches(resultsByDoc: Map<string, DocReconcileResult>, matches: CrossDocMatch[], matcherV: string): void;

package/dist/src/reconcile/crossdoc.js

@@ -0,0 +1,76 @@
+import { DEFAULT_CONFIG } from "./types.js";
+import { textSim, tokenCount } from "./similarity.js";
+export function crossDocMatch(docs, config = DEFAULT_CONFIG) {
+    // Pool everything.
+    const deleted = [];
+    const inserted = [];
+    for (const d of docs) {
+        for (const del of d.deleted)
+            deleted.push({ docId: d.docId, block: del.block });
+        for (const ins of d.inserted)
+            inserted.push({ docId: d.docId, block: ins.block, mintedId: ins.mintedId });
+    }
+    const pairs = [];
+    for (let di = 0; di < deleted.length; di++) {
+        for (let ii = 0; ii < inserted.length; ii++) {
+            const o = deleted[di].block;
+            const n = inserted[ii].block;
+            if (o.type !== n.type)
+                continue;
+            // don't match within the same doc (that's the intra-doc matcher's job)
+            if (deleted[di].docId === inserted[ii].docId)
+                continue;
+            const ratio = Math.max(tokenCount(o.text), tokenCount(n.text)) / Math.max(1, Math.min(tokenCount(o.text), tokenCount(n.text)));
+            if (ratio > 3)
+                continue;
+            const score = textSim(o.text, n.text);
+            if (score >= config.thetaXdoc)
+                pairs.push({ di, ii, score });
+        }
+    }
+    pairs.sort((a, b) => b.score - a.score || a.di - b.di || a.ii - b.ii);
+    const usedDel = new Set();
+    const usedIns = new Set();
+    const matches = [];
+    for (const p of pairs) {
+        if (usedDel.has(p.di) || usedIns.has(p.ii))
+            continue;
+        usedDel.add(p.di);
+        usedIns.add(p.ii);
+        const o = deleted[p.di];
+        const n = inserted[p.ii];
+        const edited = o.block.rawHashHex !== n.block.rawHashHex;
+        matches.push({
+            fromDoc: o.docId,
+            toDoc: n.docId,
+            carriedId: o.block.blockId,
+            replacedMintedId: n.mintedId,
+            newKey: n.block.key,
+            kind: edited ? "edited_moved" : "moved",
+            confidence: p.score,
+        });
+    }
+    return matches;
+}
+/**
+ * Apply cross-doc matches back into per-doc reconcile results: the destination
+ * doc's minted 'inserted' id is replaced by the carried id (moved/edited_moved),
+ * and the source doc's 'deleted' disposition for that id is dropped.
+ */
+export function applyCrossDocMatches(resultsByDoc, matches, matcherV) {
+    for (const m of matches) {
+        const dest = resultsByDoc.get(m.toDoc);
+        const src = resultsByDoc.get(m.fromDoc);
+        if (!dest || !src)
+            continue;
+        // Replace minted id with carried id in the destination assignment.
+        dest.assignment.set(m.newKey, m.carriedId);
+        // Drop the 'inserted' disposition for the minted id; add moved/edited_moved.
+        dest.dispositions = dest.dispositions.filter((d) => !(d.blockId === m.replacedMintedId && d.kind === "inserted"));
+        dest.dispositions.push({ blockId: m.carriedId, kind: m.kind, confidence: m.confidence, reason: "scored", matcherV, detail: { fromDoc: m.fromDoc } });
+        // Drop the 'deleted' disposition in the source doc.
+        src.dispositions = src.dispositions.filter((d) => !(d.blockId === m.carriedId && d.kind === "deleted"));
+        src.deleted = src.deleted.filter((id) => id !== m.carriedId);
+    }
+}
+//# sourceMappingURL=crossdoc.js.map

package/dist/src/reconcile/eval/generator.d.ts

@@ -0,0 +1,21 @@
+import type { MatchBlock } from "../types.js";
+export type EditClass = "edit" | "insert" | "delete" | "move" | "reorder" | "split" | "merge" | "copy";
+export interface GroundTruth {
+    /** new block key → old id it should carry (absent ⇒ should be minted) */
+    carries: Map<string, string>;
+    /** old ids expected to be deleted */
+    deleted: Set<string>;
+    /** per new key, the edit class that produced it (for per-class metrics) */
+    classOf: Map<string, EditClass>;
+}
+export interface GeneratedCase {
+    old: MatchBlock[];
+    neu: MatchBlock[];
+    truth: GroundTruth;
+}
+export declare function rng(seed: number): () => number;
+/** Generate one case: a base doc plus a scripted edit of the given intensity. */
+export declare function generateCase(seed: number, opts?: {
+    size?: number;
+    intensity?: number;
+}): GeneratedCase;

package/dist/src/reconcile/eval/generator.js

@@ -0,0 +1,129 @@
+import { sha256, normalizeVisibleText } from "../../core/hash.js";
+// Small deterministic PRNG (mulberry32).
+export function rng(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+const WORDS = "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua enim ad minim veniam quis nostrud".split(" ");
+function sentence(r, n = 10) {
+    const out = [];
+    for (let i = 0; i < n; i++)
+        out[i] = WORDS[Math.floor(r() * WORDS.length)];
+    return out.join(" ");
+}
+function mkOld(blocks) {
+    return blocks.map((b, index) => {
+        const text = normalizeVisibleText(b.raw, "paragraph");
+        return {
+            blockId: b.id, type: "paragraph",
+            rawHashHex: sha256(b.raw).toString("hex"),
+            normHashHex: sha256(text).toString("hex"),
+            text, anchors: [], parentKey: null, index, key: `/${index}`,
+        };
+    });
+}
+function mkNew(raws) {
+    return raws.map((raw, index) => {
+        const text = normalizeVisibleText(raw, "paragraph");
+        return {
+            type: "paragraph",
+            rawHashHex: sha256(raw).toString("hex"),
+            normHashHex: sha256(text).toString("hex"),
+            text, anchors: [], parentKey: null, index, key: `/${index}`,
+        };
+    });
+}
+/** Generate one case: a base doc plus a scripted edit of the given intensity. */
+export function generateCase(seed, opts = {}) {
+    const r = rng(seed);
+    const size = opts.size ?? 12;
+    const intensity = opts.intensity ?? 0.3;
+    // Base document.
+    const base = Array.from({ length: size }, (_, i) => ({ id: `b_${i}`, raw: sentence(r, 8 + Math.floor(r() * 8)) }));
+    const old = mkOld(base);
+    let items = base.map((b) => ({ id: b.id, raw: b.raw, cls: null }));
+    const deleted = new Set();
+    const nEdits = Math.max(1, Math.floor(size * intensity));
+    for (let e = 0; e < nEdits; e++) {
+        const roll = r();
+        const idx = Math.floor(r() * items.length);
+        if (items.length === 0)
+            break;
+        if (roll < 0.35) {
+            // edit: change a few words but keep majority (carry expected)
+            const it = items[idx];
+            if (it.id && it.cls === null) {
+                const words = it.raw.split(" ");
+                const changes = Math.max(1, Math.floor(words.length * 0.2));
+                for (let c = 0; c < changes; c++)
+                    words[Math.floor(r() * words.length)] = WORDS[Math.floor(r() * WORDS.length)];
+                it.raw = words.join(" ");
+                it.cls = "edit";
+            }
+        }
+        else if (roll < 0.5) {
+            // insert a brand-new block
+            items.splice(idx, 0, { id: null, raw: sentence(r, 10), cls: "insert" });
+        }
+        else if (roll < 0.62) {
+            // delete
+            const it = items[idx];
+            if (it.id)
+                deleted.add(it.id);
+            items.splice(idx, 1);
+        }
+        else if (roll < 0.8) {
+            // move/reorder: pop and reinsert elsewhere
+            const [it] = items.splice(idx, 1);
+            if (it) {
+                const dest = Math.floor(r() * (items.length + 1));
+                if (it.cls === null && it.id)
+                    it.cls = "move";
+                items.splice(dest, 0, it);
+            }
+        }
+        else if (roll < 0.9) {
+            // copy: near-duplicate an existing block (append a word so the original
+            // still locks uniquely and the copy is detected against it, per 03 §4).
+            const it = items[idx];
+            if (it.id)
+                items.splice(idx + 1, 0, { id: null, raw: `${it.raw} ${WORDS[Math.floor(r() * WORDS.length)]}`, cls: "copy" });
+        }
+        else {
+            // reorder two adjacent
+            if (idx + 1 < items.length) {
+                const tmp = items[idx];
+                items[idx] = items[idx + 1];
+                items[idx + 1] = tmp;
+                if (items[idx].id && items[idx].cls === null)
+                    items[idx].cls = "reorder";
+            }
+        }
+    }
+    const neu = mkNew(items.map((it) => it.raw));
+    const carries = new Map();
+    const classOf = new Map();
+    items.forEach((it, index) => {
+        const key = `/${index}`;
+        if (it.id && !deleted.has(it.id)) {
+            carries.set(key, it.id);
+            classOf.set(key, it.cls ?? "edit");
+        }
+        else if (it.cls) {
+            classOf.set(key, it.cls);
+        }
+    });
+    // Any old id not present in carries and not explicitly deleted is a delete.
+    const carriedIds = new Set(carries.values());
+    for (const b of base)
+        if (!carriedIds.has(b.id))
+            deleted.add(b.id);
+    return { old, neu, truth: { carries, deleted, classOf } };
+}
+//# sourceMappingURL=generator.js.map

package/dist/src/reconcile/eval/metrics.d.ts

@@ -0,0 +1,32 @@
+import type { ReconcileConfig } from "../types.js";
+import { type EditClass, type GeneratedCase } from "./generator.js";
+export interface ClassMetrics {
+    truePairs: number;
+    carriedPairs: number;
+    correctCarries: number;
+    precision: number;
+    recall: number;
+}
+export interface EvalReport {
+    cases: number;
+    overall: ClassMetrics;
+    perClass: Record<string, ClassMetrics>;
+    config: ReconcileConfig;
+}
+declare function blank(): {
+    truePairs: number;
+    carriedPairs: number;
+    correctCarries: number;
+};
+export declare function evaluateCase(c: GeneratedCase, config?: ReconcileConfig): {
+    overall: ReturnType<typeof blank>;
+    perClass: Map<string, ReturnType<typeof blank>>;
+};
+/** Run the synthetic suite over `n` seeded cases and produce the report. */
+export declare function runEval(opts?: {
+    n?: number;
+    size?: number;
+    intensity?: number;
+    config?: ReconcileConfig;
+}): EvalReport;
+export type { EditClass };

package/dist/src/reconcile/eval/metrics.js

@@ -0,0 +1,74 @@
+import { reconcileDocument } from "../reconcile.js";
+import { generateCase } from "./generator.js";
+function blank() {
+    return { truePairs: 0, carriedPairs: 0, correctCarries: 0 };
+}
+export function evaluateCase(c, config) {
+    const res = reconcileDocument(c.old, c.neu, config ? { config } : {});
+    const overall = blank();
+    const perClass = new Map();
+    const bucket = (cls) => perClass.get(cls) ?? perClass.set(cls, blank()).get(cls);
+    // True pairs: ground-truth carries.
+    for (const [key, oldId] of c.truth.carries) {
+        overall.truePairs++;
+        const cls = c.truth.classOf.get(key) ?? "edit";
+        bucket(cls).truePairs++;
+        const got = res.assignment.get(key);
+        if (got === oldId) {
+            overall.correctCarries++;
+            bucket(cls).correctCarries++;
+        }
+    }
+    // Carried pairs: assignments where the matcher reused an OLD id (not minted).
+    const oldIds = new Set(c.old.map((b) => b.blockId));
+    const truthByKey = c.truth.carries;
+    for (const [key, id] of res.assignment) {
+        if (oldIds.has(id)) {
+            overall.carriedPairs++;
+            const cls = c.truth.classOf.get(key) ?? "edit";
+            bucket(cls).carriedPairs++;
+            // correctness already tallied above when it matches truth; recount for
+            // precision denominators handled via correctCarries computed there.
+            void truthByKey;
+        }
+    }
+    return { overall, perClass };
+}
+function finalize(agg) {
+    return {
+        ...agg,
+        precision: agg.carriedPairs === 0 ? 1 : agg.correctCarries / agg.carriedPairs,
+        recall: agg.truePairs === 0 ? 1 : agg.correctCarries / agg.truePairs,
+    };
+}
+/** Run the synthetic suite over `n` seeded cases and produce the report. */
+export function runEval(opts = {}) {
+    const n = opts.n ?? 200;
+    const overall = blank();
+    const perClass = new Map();
+    for (let seed = 1; seed <= n; seed++) {
+        const genOpts = {};
+        if (opts.size !== undefined)
+            genOpts.size = opts.size;
+        if (opts.intensity !== undefined)
+            genOpts.intensity = opts.intensity;
+        const c = generateCase(seed, genOpts);
+        const r = evaluateCase(c, opts.config);
+        overall.truePairs += r.overall.truePairs;
+        overall.carriedPairs += r.overall.carriedPairs;
+        overall.correctCarries += r.overall.correctCarries;
+        for (const [cls, agg] of r.perClass) {
+            const b = perClass.get(cls) ?? perClass.set(cls, blank()).get(cls);
+            b.truePairs += agg.truePairs;
+            b.carriedPairs += agg.carriedPairs;
+            b.correctCarries += agg.correctCarries;
+        }
+    }
+    const perClassOut = {};
+    for (const [cls, agg] of perClass)
+        perClassOut[cls] = finalize(agg);
+    // config echo: default when not provided
+    const cfg = opts.config ?? undefined;
+    return { cases: n, overall: finalize(overall), perClass: perClassOut, config: cfg };
+}
+//# sourceMappingURL=metrics.js.map

package/dist/src/reconcile/flatten.d.ts

@@ -0,0 +1,12 @@
+import type { MatchBlock } from "./types.js";
+import type { TreeInputBlock } from "../core/store/writers.js";
+export interface FlatSource {
+    blockId?: string;
+    type: string;
+    raw: string;
+    anchors?: string[];
+    children: FlatSource[];
+}
+/** Adapt a parsed RawBlock-ish tree (no ids) to FlatSource. */
+export declare function fromInput(blocks: TreeInputBlock[]): FlatSource[];
+export declare function flatten(blocks: FlatSource[]): MatchBlock[];