@omgbase/core 0.1.0 → 0.2.0

package/dist/src/mutate/plan-update.d.ts

@@ -1,6 +1,7 @@
 import type { Store } from "../core/store/store.js";
 import { type ReconcileConfig } from "../reconcile/types.js";
 import { type ApplyResult } from "./apply.js";
+import type { DocStore } from "./doc-store.js";
 import { type Opset } from "./opset.js";
 export interface PlanUpdateOptions {
     config?: ReconcileConfig;
@@ -13,7 +14,10 @@ export interface PlanUpdateOptions {
 export declare function planUpdate(store: Store, repoId: string, rootPath: string, docRef: string, content: string, opts?: PlanUpdateOptions): Opset;
 export interface ApplyOpsetRequest {
     repoId: string;
-    rootPath: string;
+    /** Working-tree root for the default filesystem write target; omit only with an explicit `docStore`. */
+    rootPath?: string;
+    /** Write target (ADR-014 §5); defaults to a filesystem store at `rootPath`. */
+    docStore?: DocStore;
     opset: Opset;
     origin: {
         actor: string;
@@ -21,6 +25,8 @@ export interface ApplyOpsetRequest {
     };
     dryRun?: boolean;
     omgbaseDir?: string;
+    /** Commit timestamp (RFC 3339 UTC); defaults to now (see `ApplyRequest.ts`). */
+    ts?: string;
 }
 /**
  * Apply an opset through the kernel write path. Validates the plan's

package/dist/src/mutate/plan-update.js

@@ -159,11 +159,13 @@ export function applyOpset(store, req) {
     }
     return apply(store, {
         repoId: req.repoId,
-        rootPath: req.rootPath,
+        ...(req.rootPath !== undefined ? { rootPath: req.rootPath } : {}),
+        ...(req.docStore !== undefined ? { docStore: req.docStore } : {}),
         ops: opsetKernelOps(opset),
         origin: req.origin,
         ...(req.dryRun !== undefined ? { dryRun: req.dryRun } : {}),
         ...(req.omgbaseDir !== undefined ? { omgbaseDir: req.omgbaseDir } : {}),
+        ...(req.ts !== undefined ? { ts: req.ts } : {}),
         ...(opset.frontmatter ? { setFrontmatter: [{ doc: opset.precondition.doc, raw: opset.frontmatter.raw }] } : {}),
     });
 }

package/dist/src/oqx-js/context.js

@@ -159,11 +159,49 @@ export function makeStoreContext(store, repoId, opts = {}) {
         const r = one(`SELECT ordinal FROM blocks WHERE doc_id = ? AND block_id = ?`, block.doc_id, first);
         return r?.ordinal ?? block.ordinal;
     };
+    // ---- a document's live blocks in DOCUMENT order (spec/surface §1.2) --------
+    // Pre-order over the containment forest (children by parent_block, siblings by
+    // (ordinal, block_id)); each row is paired with its top-level ancestor's
+    // ordinal, which is what section ranges are expressed in.
+    const docBlocksPreorder = (docId, path) => {
+        const rows = all(`SELECT b.*, ? AS __path FROM blocks b WHERE b.doc_id = ? AND b.deleted_commit IS NULL ORDER BY b.ordinal, b.block_id`, path, docId);
+        const ids = new Set(rows.map((r) => r.block_id));
+        const byParent = new Map();
+        for (const r of rows) {
+            const parent = r.parent_block != null && ids.has(r.parent_block) ? r.parent_block : null;
+            let list = byParent.get(parent);
+            if (!list)
+                byParent.set(parent, (list = []));
+            list.push(r);
+        }
+        const out = [];
+        const walk = (parent, top) => {
+            for (const r of byParent.get(parent) ?? []) {
+                const t = top ?? r.ordinal;
+                out.push({ row: r, top: t });
+                walk(r.block_id, t);
+            }
+        };
+        walk(null, null);
+        return out;
+    };
+    // A document's nodes in DOCUMENT order: by the owning block's pre-order rank
+    // (block-less nodes first), then span_start, then node_id. Node ids are content
+    // hashes over random doc ids, so an id order would differ per ingest.
+    const docNodesInOrder = (docId, path) => {
+        const rank = new Map();
+        docBlocksPreorder(docId, path).forEach((x, i) => rank.set(x.row.block_id, i));
+        const rows = all(`SELECT n.*, ? AS __path FROM nodes n WHERE n.doc_id = ?`, path, docId);
+        const pos = (n) => (n.block_id == null ? -1 : rank.get(n.block_id) ?? Number.MAX_SAFE_INTEGER);
+        const span = (n) => (typeof n.span_start === "number" ? n.span_start : -1);
+        rows.sort((a, b) => pos(a) - pos(b) || span(a) - span(b) || (a.node_id < b.node_id ? -1 : a.node_id === b.node_id ? 0 : 1));
+        return tagAll(rows, "nodes");
+    };
     // ---- relations (return row arrays) ----------------------------------------
     const rel = {
         docs: {
-            nodes: (r) => tagAll(all(`SELECT n.*, ? AS __path FROM nodes n WHERE n.doc_id = ?`, r.path, r.doc_id), "nodes"),
-            blocks: (r) => tagAll(all(`SELECT b.*, ? AS __path FROM blocks b WHERE b.doc_id = ? AND b.deleted_commit IS NULL ORDER BY b.ordinal, b.block_id`, r.path, r.doc_id), "blocks"),
+            nodes: (r) => docNodesInOrder(r.doc_id, r.path),
+            blocks: (r) => tagAll(docBlocksPreorder(r.doc_id, r.path).map((x) => x.row), "blocks"),
             out: (r) => tagAll(all(`SELECT DISTINCT d2.* FROM docs d2 JOIN edges e ON e.dst_node = d2.doc_id
          WHERE e.src_doc = ? AND e.to_commit IS NULL AND d2.repo_id = ? AND d2.deleted_commit IS NULL ORDER BY d2.path, d2.doc_id`, r.doc_id, repoId), "docs"),
             in: (r) => tagAll(all(`SELECT DISTINCT d2.* FROM docs d2 JOIN edges e ON e.src_doc = d2.doc_id
@@ -174,7 +212,7 @@ export function makeStoreContext(store, repoId, opts = {}) {
         },
         blocks: {
             children: (r) => tagAll(all(`SELECT b.*, ? AS __path FROM blocks b WHERE b.parent_block = ? AND b.deleted_commit IS NULL ORDER BY b.ordinal, b.block_id`, r.__path, r.block_id), "blocks"),
-            nodes: (r) => tagAll(all(`SELECT n.*, ? AS __path FROM nodes n WHERE n.block_id = ?`, r.__path, r.block_id), "nodes"),
+            nodes: (r) => tagAll(all(`SELECT n.*, ? AS __path FROM nodes n WHERE n.block_id = ? ORDER BY n.span_start, n.node_id`, r.__path, r.block_id), "nodes"),
             out_edges: (r) => tagAll(all(`SELECT e.*, ? AS __path FROM edges e WHERE e.src_block = ? AND e.to_commit IS NULL ORDER BY e.predicate, e.edge_id`, r.__path, r.block_id), "edges"),
             // enclosing section node(s): md:section whose range contains this block's top ordinal.
             section: (r) => {
@@ -190,9 +228,8 @@ export function makeStoreContext(store, repoId, opts = {}) {
                 const f = jattr(r, "first_ordinal"), l = jattr(r, "last_ordinal");
                 if (f == null || l == null)
                     return [];
-                // blocks whose top-level ordinal falls in the section range.
-                const rows = all(`SELECT b.*, ? AS __path FROM blocks b WHERE b.doc_id = ? AND b.deleted_commit IS NULL ORDER BY b.ordinal, b.block_id`, r.__path, r.doc_id);
-                const kept = rows.filter((b) => { const t = topOrdinal(b); return t >= f && t <= l; });
+                // blocks whose top-level ancestor's ordinal falls in the section range, in document order.
+                const kept = docBlocksPreorder(r.doc_id, r.__path).filter((x) => x.top >= f && x.top <= l).map((x) => x.row);
                 return tagAll(kept, "blocks");
             },
             subsections: (r) => {

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

@@ -1,12 +1,22 @@
 import type { MatchBlock } from "../types.js";
 export type EditClass = "edit" | "insert" | "delete" | "move" | "reorder" | "split" | "merge" | "copy";
+/** Structured-mode classes (list-item edits; see generateStructuredCase). */
+export type StructuredEditClass = "item-edit-mid" | "item-edit-last" | "item-insert" | "item-delete" | "item-move" | "item-gains-nested-list" | "item-reorder"
+/** an item deleted and an unrelated item inserted in its slot (the new item must mint; m2.3 singleton-rule cost) */
+ | "item-replace"
+/** the list container whose items were edited (must carry) */
+ | "list"
+/** any block the script did not touch (must carry) */
+ | "same"
+/** the paragraph / nested list / nested items minted under an item that gained a nested list */
+ | "nested-new";
 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>;
+    classOf: Map<string, EditClass | StructuredEditClass>;
 }
 export interface GeneratedCase {
     old: MatchBlock[];
@@ -19,3 +29,16 @@ export declare function generateCase(seed: number, opts?: {
     size?: number;
     intensity?: number;
 }): GeneratedCase;
+export interface StructuredOpts {
+    /** top-level blocks in the base document (default 10) */
+    size?: number;
+    /** edits per case ≈ size × intensity (default 0.3 ⇒ 3) */
+    intensity?: number;
+    /** words per list item; a number fixes it, absent ⇒ 2–6 per item */
+    itemWords?: number;
+}
+type Cls = StructuredEditClass;
+export declare const STRUCTURED_ITEM_CLASSES: readonly Cls[];
+/** Generate one structured case (see the mode comment above). */
+export declare function generateStructuredCase(seed: number, opts?: StructuredOpts): GeneratedCase;
+export {};

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

@@ -1,4 +1,5 @@
 import { sha256, normalizeVisibleText } from "../../core/hash.js";
+import { flatten } from "../flatten.js";
 // Small deterministic PRNG (mulberry32).
 export function rng(seed) {
     let a = seed >>> 0;
@@ -126,4 +127,251 @@ export function generateCase(seed, opts = {}) {
             deleted.add(b.id);
     return { old, neu, truth: { carries, deleted, classOf } };
 }
+// A larger vocabulary than the flat mode's so short items stay unique within a
+// document (ground truth needs distinguishable items; duplicates would make the
+// "right" id a coin toss the matcher cannot be blamed for).
+const ITEM_WORDS = ("alpha bravo charlie delta echo foxtrot golf hotel india juliet kilo lima mike november oscar papa " +
+    "quebec romeo sierra tango uniform victor whiskey xray yankee zulu apple banana cherry damson elder " +
+    "fig grape hazel iris jasmine kale lemon mango nectar olive peach quince radish sage thyme umber " +
+    "violet walnut yarrow zest amber birch cedar dune ember flint gorse heath ivy jade kelp lotus moss " +
+    "nickel onyx pearl quartz reed slate tundra vale willow").split(" ");
+function itemToSource(it, withId) {
+    const own = it.words.join(" ");
+    if (it.nested === null) {
+        const s = { type: "list_item", raw: `- ${own}`, children: [] };
+        if (withId && it.id)
+            s.blockId = it.id;
+        return s;
+    }
+    // Parser shape: item raw keeps the nested lines; children are the folded
+    // paragraph and the nested list; the nested list's first line starts at content.
+    const nestedItemRaws = it.nested.map((w) => `- ${w}`);
+    const nestedList = {
+        type: "list",
+        raw: nestedItemRaws.join("\n  "),
+        children: nestedItemRaws.map((raw) => ({ type: "list_item", raw, children: [] })),
+    };
+    const s = {
+        type: "list_item",
+        raw: `- ${own}\n  ${nestedItemRaws.join("\n  ")}`,
+        children: [{ type: "paragraph", raw: own, children: [] }, nestedList],
+    };
+    if (withId && it.id)
+        s.blockId = it.id;
+    return s;
+}
+function blockToSource(b, withId) {
+    if (b.kind === "list") {
+        const children = b.items.map((it) => itemToSource(it, withId));
+        const s = { type: "list", raw: children.map((c) => c.raw).join("\n"), children };
+        if (withId)
+            s.blockId = b.id;
+        return s;
+    }
+    const s = { type: b.kind, raw: b.raw, children: [] };
+    if (withId)
+        s.blockId = b.id;
+    return s;
+}
+/** Walk a FlatSource tree in flatten()'s order, yielding the same positional keys. */
+function walkKeys(list, parentKey, fn) {
+    list.forEach((b, index) => {
+        const key = `${parentKey ?? ""}/${index}`;
+        fn(b, key);
+        walkKeys(b.children, key, fn);
+    });
+}
+export const STRUCTURED_ITEM_CLASSES = [
+    "item-edit-mid", "item-edit-last", "item-insert", "item-delete", "item-move", "item-gains-nested-list", "item-reorder",
+    "item-replace",
+];
+/** Generate one structured case (see the mode comment above). */
+export function generateStructuredCase(seed, opts = {}) {
+    // Offset the seed space so structured cases never share a PRNG stream with flat ones.
+    const r = rng((seed + 0x5a5a0000) >>> 0);
+    const size = opts.size ?? 10;
+    const intensity = opts.intensity ?? 0.3;
+    const pick = (arr) => arr[Math.floor(r() * arr.length)];
+    const wordCount = () => opts.itemWords ?? 2 + Math.floor(r() * 5);
+    let nextId = 0;
+    const mint = () => `b_${nextId++}`;
+    const used = new Set(); // item texts, unique across the document
+    const freshWords = (n) => {
+        for (let attempt = 0; attempt < 50; attempt++) {
+            const w = Array.from({ length: n }, () => pick(ITEM_WORDS));
+            const key = w.join(" ");
+            if (!used.has(key)) {
+                used.add(key);
+                return w;
+            }
+        }
+        // Vocabulary exhausted for this length (only plausible for 1-word items): accept a repeat.
+        return Array.from({ length: n }, () => pick(ITEM_WORDS));
+    };
+    const replaceWord = (words, at) => {
+        // Replace so the resulting item text is new to the document (bounded retries).
+        for (let attempt = 0; attempt < 50; attempt++) {
+            const w = pick(ITEM_WORDS);
+            if (w === words[at])
+                continue;
+            const trial = [...words];
+            trial[at] = w;
+            const key = trial.join(" ");
+            if (!used.has(key)) {
+                used.add(key);
+                words[at] = w;
+                return;
+            }
+        }
+        words[at] = pick(ITEM_WORDS.filter((w) => w !== words[at]));
+    };
+    // Base document: ids are assigned in document (pre-order) order.
+    const blocks = [];
+    for (let i = 0; i < size; i++) {
+        const roll = r();
+        // Guarantee two lists so there is always something to edit.
+        const wantList = roll < 0.5 || (i >= size - 2 && blocks.filter((b) => b.kind === "list").length < 2);
+        if (wantList) {
+            const id = mint();
+            const n = 3 + Math.floor(r() * 5); // 3–7 items
+            const items = Array.from({ length: n }, () => ({ id: mint(), words: freshWords(wordCount()), cls: null, nested: null }));
+            blocks.push({ kind: "list", id, items, cls: null });
+        }
+        else if (roll < 0.65) {
+            blocks.push({ kind: "heading", id: mint(), raw: `${"#".repeat(1 + Math.floor(r() * 3))} ${sentence(r, 2 + Math.floor(r() * 3))}` });
+        }
+        else {
+            blocks.push({ kind: "paragraph", id: mint(), raw: sentence(r, 8 + Math.floor(r() * 8)) });
+        }
+    }
+    const oldTree = blocks.map((b) => blockToSource(b, true));
+    const old = flatten(oldTree);
+    // Scripted item edits.
+    const deleted = new Set();
+    const lists = blocks.filter((b) => b.kind === "list");
+    const nEdits = Math.max(1, Math.floor(size * intensity));
+    for (let e = 0; e < nEdits; e++) {
+        const list = pick(lists);
+        const cls = pick(STRUCTURED_ITEM_CLASSES);
+        const untouched = list.items.map((it, i) => [it, i]).filter(([it]) => it.id !== null && it.cls === null);
+        if (untouched.length === 0)
+            continue;
+        const [it, idx] = pick(untouched);
+        switch (cls) {
+            case "item-edit-mid": {
+                // change 1–2 words, none of them the last one
+                const positions = it.words.length - 1;
+                if (positions < 1)
+                    continue;
+                const changes = Math.min(positions, 1 + Math.floor(r() * 2));
+                const chosen = new Set();
+                while (chosen.size < changes)
+                    chosen.add(Math.floor(r() * positions));
+                used.delete(it.words.join(" "));
+                for (const at of chosen)
+                    replaceWord(it.words, at);
+                it.cls = cls;
+                break;
+            }
+            case "item-edit-last": {
+                used.delete(it.words.join(" "));
+                replaceWord(it.words, it.words.length - 1);
+                it.cls = cls;
+                break;
+            }
+            case "item-insert": {
+                const at = Math.floor(r() * (list.items.length + 1));
+                list.items.splice(at, 0, { id: null, words: freshWords(wordCount()), cls, nested: null });
+                break;
+            }
+            case "item-delete": {
+                if (list.items.length < 3)
+                    continue;
+                deleted.add(it.id);
+                list.items.splice(idx, 1);
+                break;
+            }
+            case "item-move": {
+                if (list.items.length < 3)
+                    continue;
+                list.items.splice(idx, 1);
+                let dest = Math.floor(r() * list.items.length);
+                if (dest >= idx)
+                    dest++; // any position other than the original
+                list.items.splice(Math.min(dest, list.items.length), 0, it);
+                it.cls = cls;
+                break;
+            }
+            case "item-reorder": {
+                const j = idx + 1 < list.items.length ? idx + 1 : idx - 1;
+                if (j < 0)
+                    continue;
+                const other = list.items[j];
+                if (other.id === null || other.cls !== null)
+                    continue;
+                list.items[idx] = other;
+                list.items[j] = it;
+                it.cls = cls;
+                other.cls = cls;
+                break;
+            }
+            case "item-replace": {
+                // Delete the item and put an unrelated fresh item in its slot: the same
+                // shape the singleton rule (spec/reconcile §5 phase 4a step 5) reads as
+                // an edit, so this class measures its cost (the new item must mint).
+                deleted.add(it.id);
+                list.items[idx] = { id: null, words: freshWords(wordCount()), cls, nested: null };
+                break;
+            }
+            case "item-gains-nested-list": {
+                it.nested = Array.from({ length: 2 + Math.floor(r() * 2) }, () => freshWords(1)[0]);
+                it.cls = cls;
+                break;
+            }
+            default:
+                continue;
+        }
+        list.cls = "list";
+    }
+    // New tree: built with the truth ids attached, harvested, then stripped.
+    const newTree = blocks.map((b) => blockToSource(b, true));
+    const carries = new Map();
+    const classOf = new Map();
+    const clsByKey = new Map();
+    {
+        // Classes by key: mirror blockToSource's shape.
+        const listIdx = new Map();
+        blocks.forEach((b, i) => listIdx.set(b, i));
+        for (const b of blocks) {
+            const bk = `/${listIdx.get(b)}`;
+            if (b.kind !== "list") {
+                clsByKey.set(bk, "same");
+                continue;
+            }
+            clsByKey.set(bk, b.cls ?? "same");
+            b.items.forEach((it, i) => {
+                const ik = `${bk}/${i}`;
+                clsByKey.set(ik, it.cls ?? (it.id === null ? "item-insert" : "same"));
+                if (it.nested !== null) {
+                    clsByKey.set(`${ik}/0`, "nested-new");
+                    clsByKey.set(`${ik}/1`, "nested-new");
+                    it.nested.forEach((_, j) => clsByKey.set(`${ik}/1/${j}`, "nested-new"));
+                }
+            });
+        }
+    }
+    walkKeys(newTree, null, (b, key) => {
+        const cls = clsByKey.get(key) ?? "same";
+        classOf.set(key, cls);
+        if (b.blockId && !deleted.has(b.blockId))
+            carries.set(key, b.blockId);
+        delete b.blockId;
+    });
+    const neu = flatten(newTree);
+    const carriedIds = new Set(carries.values());
+    for (const b of old)
+        if (!carriedIds.has(b.blockId))
+            deleted.add(b.blockId);
+    return { old, neu, truth: { carries, deleted, classOf } };
+}
 //# sourceMappingURL=generator.js.map

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

@@ -1,6 +1,8 @@
-import type { ReconcileConfig } from "../types.js";
-import { type EditClass, type GeneratedCase } from "./generator.js";
+import { type ReconcileConfig } from "../types.js";
+import { type EditClass, type GeneratedCase, type StructuredEditClass } from "./generator.js";
 export interface ClassMetrics {
+    /** new blocks of this class (carried or minted in truth) */
+    newBlocks: number;
     truePairs: number;
     carriedPairs: number;
     correctCarries: number;
@@ -9,24 +11,46 @@ export interface ClassMetrics {
 }
 export interface EvalReport {
     cases: number;
+    mode: EvalMode;
     overall: ClassMetrics;
     perClass: Record<string, ClassMetrics>;
+    /** old ids the truth deletes, and how many of them the matcher carried anyway */
+    deleted: {
+        expected: number;
+        wronglyCarried: number;
+    };
+    /** the effective config the suite ran under */
     config: ReconcileConfig;
 }
-declare function blank(): {
+export type EvalMode = "flat" | "structured";
+type Agg = {
+    newBlocks: number;
     truePairs: number;
     carriedPairs: number;
     correctCarries: number;
 };
 export declare function evaluateCase(c: GeneratedCase, config?: ReconcileConfig): {
-    overall: ReturnType<typeof blank>;
-    perClass: Map<string, ReturnType<typeof blank>>;
+    overall: Agg;
+    perClass: Map<string, Agg>;
+    deleted: {
+        expected: number;
+        wronglyCarried: number;
+    };
 };
-/** Run the synthetic suite over `n` seeded cases and produce the report. */
-export declare function runEval(opts?: {
+export interface RunEvalOptions {
     n?: number;
+    /** flat: top-level paragraphs per doc (12); structured: top-level blocks per doc (10) */
     size?: number;
     intensity?: number;
+    /** structured mode only: words per list item (absent ⇒ 2–6 per item) */
+    itemWords?: number;
+    /** "flat" (default; the release-gate suite) or "structured" (lists of short items) */
+    mode?: EvalMode;
+    /** full config; defaults to DEFAULT_CONFIG */
     config?: ReconcileConfig;
-}): EvalReport;
-export type { EditClass };
+    /** fields to override on top of `config` (e.g. `{ contextSimFloor: 0.3 }`) */
+    configOverrides?: Partial<ReconcileConfig>;
+}
+/** Run the synthetic suite over `n` seeded cases and produce the report. */
+export declare function runEval(opts?: RunEvalOptions): EvalReport;
+export type { EditClass, StructuredEditClass };

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

@@ -1,38 +1,51 @@
 import { reconcileDocument } from "../reconcile.js";
-import { generateCase } from "./generator.js";
+import { DEFAULT_CONFIG } from "../types.js";
+import { generateCase, generateStructuredCase, } from "./generator.js";
 function blank() {
-    return { truePairs: 0, carriedPairs: 0, correctCarries: 0 };
+    return { newBlocks: 0, truePairs: 0, carriedPairs: 0, correctCarries: 0 };
+}
+function add(into, from) {
+    into.newBlocks += from.newBlocks;
+    into.truePairs += from.truePairs;
+    into.carriedPairs += from.carriedPairs;
+    into.correctCarries += from.correctCarries;
 }
 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);
+    // Flat mode leaves untouched blocks unclassified and they count as "edit"
+    // (kept: the release gates were tuned against that bucketing).
+    const classOf = (key) => c.truth.classOf.get(key) ?? "edit";
+    for (const b of c.neu) {
+        overall.newBlocks++;
+        bucket(classOf(b.key)).newBlocks++;
+    }
     // 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) {
+        bucket(classOf(key)).truePairs++;
+        if (res.assignment.get(key) === oldId) {
             overall.correctCarries++;
-            bucket(cls).correctCarries++;
+            bucket(classOf(key)).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;
+    const carriedOld = new Set();
     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;
+            bucket(classOf(key)).carriedPairs++;
+            carriedOld.add(id);
         }
     }
-    return { overall, perClass };
+    let wronglyCarried = 0;
+    for (const id of c.truth.deleted)
+        if (carriedOld.has(id))
+            wronglyCarried++;
+    return { overall, perClass, deleted: { expected: c.truth.deleted.size, wronglyCarried } };
 }
 function finalize(agg) {
     return {
@@ -44,31 +57,41 @@ function finalize(agg) {
 /** Run the synthetic suite over `n` seeded cases and produce the report. */
 export function runEval(opts = {}) {
     const n = opts.n ?? 200;
+    const mode = opts.mode ?? "flat";
+    const config = { ...(opts.config ?? DEFAULT_CONFIG), ...(opts.configOverrides ?? {}) };
     const overall = blank();
     const perClass = new Map();
+    const deleted = { expected: 0, wronglyCarried: 0 };
     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;
+        let c;
+        if (mode === "structured") {
+            const genOpts = {};
+            if (opts.size !== undefined)
+                genOpts.size = opts.size;
+            if (opts.intensity !== undefined)
+                genOpts.intensity = opts.intensity;
+            if (opts.itemWords !== undefined)
+                genOpts.itemWords = opts.itemWords;
+            c = generateStructuredCase(seed, genOpts);
+        }
+        else {
+            const genOpts = {};
+            if (opts.size !== undefined)
+                genOpts.size = opts.size;
+            if (opts.intensity !== undefined)
+                genOpts.intensity = opts.intensity;
+            c = generateCase(seed, genOpts);
         }
+        const r = evaluateCase(c, config);
+        add(overall, r.overall);
+        for (const [cls, agg] of r.perClass)
+            add(perClass.get(cls) ?? perClass.set(cls, blank()).get(cls), agg);
+        deleted.expected += r.deleted.expected;
+        deleted.wronglyCarried += r.deleted.wronglyCarried;
     }
     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 };
+    return { cases: n, mode, overall: finalize(overall), perClass: perClassOut, deleted, config };
 }
 //# sourceMappingURL=metrics.js.map

package/dist/src/reconcile/flatten.js

@@ -1,4 +1,4 @@
-import { sha256, normalizeVisibleText } from "../core/hash.js";
+import { sha256, childQuoteDepth, visibleText } from "../core/hash.js";
 /** Adapt a parsed RawBlock-ish tree (no ids) to FlatSource. */
 export function fromInput(blocks) {
     return blocks.map((b) => ({
@@ -10,10 +10,12 @@ export function fromInput(blocks) {
 }
 export function flatten(blocks) {
     const out = [];
-    const walk = (list, parentKey) => {
+    // quoteDepth = blockquote ancestors; text follows spec/format §4.1 (containers
+    // compose from children, nested raws lose their `> ` prefixes).
+    const walk = (list, parentKey, quoteDepth) => {
         list.forEach((b, index) => {
             const key = `${parentKey ?? ""}/${index}`;
-            const text = normalizeVisibleText(b.raw, b.type);
+            const text = visibleText(b, quoteDepth);
             const mb = {
                 type: b.type,
                 rawHashHex: sha256(b.raw).toString("hex"),
@@ -28,10 +30,10 @@ export function flatten(blocks) {
                 mb.blockId = b.blockId;
             out.push(mb);
             if (b.children.length > 0)
-                walk(b.children, key);
+                walk(b.children, key, childQuoteDepth(b.type, quoteDepth));
         });
     };
-    walk(blocks, null);
+    walk(blocks, null, 0);
     return out;
 }
 //# sourceMappingURL=flatten.js.map

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

@@ -3,6 +3,7 @@ import type { PhaseState } from "./phases.js";
  * Phase 5 — scored assignment. Greedy-by-score with R3 order constraints:
  * accept the highest-scoring candidate, discard conflicting candidates
  * (same old or new, or order-crossing with an already-accepted same-parent
- * pair), repeat. Accept while score ≥ θ (θ_small for tiny blocks).
+ * pair), repeat. Accept a candidate when score ≥ θ (θ_small for tiny blocks);
+ * a candidate below its θ is skipped, not a stopping point.
  */
 export declare function phase5Scored(state: PhaseState): void;