@omgbase/core 0.1.0

package/dist/src/reconcile/flatten.js

@@ -0,0 +1,37 @@
+import { sha256, normalizeVisibleText } from "../core/hash.js";
+/** Adapt a parsed RawBlock-ish tree (no ids) to FlatSource. */
+export function fromInput(blocks) {
+    return blocks.map((b) => ({
+        ...(b.blockId ? { blockId: b.blockId } : {}),
+        type: b.type,
+        raw: b.raw,
+        children: fromInput(b.children),
+    }));
+}
+export function flatten(blocks) {
+    const out = [];
+    const walk = (list, parentKey) => {
+        list.forEach((b, index) => {
+            const key = `${parentKey ?? ""}/${index}`;
+            const text = normalizeVisibleText(b.raw, b.type);
+            const mb = {
+                type: b.type,
+                rawHashHex: sha256(b.raw).toString("hex"),
+                normHashHex: sha256(text).toString("hex"),
+                text,
+                anchors: b.anchors ?? [],
+                parentKey,
+                index,
+                key,
+            };
+            if (b.blockId)
+                mb.blockId = b.blockId;
+            out.push(mb);
+            if (b.children.length > 0)
+                walk(b.children, key);
+        });
+    };
+    walk(blocks, null);
+    return out;
+}
+//# sourceMappingURL=flatten.js.map

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

@@ -0,0 +1,8 @@
+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).
+ */
+export declare function phase5Scored(state: PhaseState): void;

package/dist/src/reconcile/phase5.js

@@ -0,0 +1,167 @@
+import { shingles, dice, tokenCount } from "./similarity.js";
+// score(o,n) = 0.55 text_sim + 0.15 neighbor_ctx + 0.10 parent_match
+//            + 0.10 position_prior + 0.10 anchor_evidence
+function scorePair(o, n, state, oldCount, newCount) {
+    const textSimVal = dice(shingles(o.text), shingles(n.text));
+    // neighbor_ctx: fraction of {prev,next} siblings that are matched pairs.
+    const neighborCtx = neighborContext(o, n, state);
+    // parent_match: 1 if parents are a matched pair (or both roots).
+    const parentMatch = parentsMatched(o, n, state) ? 1 : 0;
+    // position_prior: 1 - |rel_pos(o) - rel_pos(n)|
+    const relO = oldCount > 1 ? o.index / (oldCount - 1) : 0;
+    const relN = newCount > 1 ? n.index / (newCount - 1) : 0;
+    const positionPrior = 1 - Math.abs(relO - relN);
+    // anchor_evidence: shared anchors / code-fence info / heading prefix.
+    const anchorEvidence = sharedAnchorEvidence(o, n);
+    return (0.55 * textSimVal +
+        0.15 * neighborCtx +
+        0.1 * parentMatch +
+        0.1 * positionPrior +
+        0.1 * anchorEvidence);
+}
+function siblingAt(blocks, parentKey, index) {
+    return blocks.find((b) => b.parentKey === parentKey && b.index === index);
+}
+function neighborContext(o, n, state) {
+    let matched = 0;
+    let total = 0;
+    for (const delta of [-1, 1]) {
+        const oldSib = siblingAt(state.old, o.parentKey, o.index + delta);
+        const newSib = siblingAt(state.neu, n.parentKey, n.index + delta);
+        if (oldSib || newSib) {
+            total++;
+            // matched pair if the old sibling's id is assigned to the new sibling's key
+            if (oldSib && newSib && state.matched.get(newSib.key) === oldSib.blockId)
+                matched++;
+        }
+    }
+    return total === 0 ? 0 : matched / total;
+}
+function parentsMatched(o, n, state) {
+    if (o.parentKey === null && n.parentKey === null)
+        return true;
+    if (o.parentKey === null || n.parentKey === null)
+        return false;
+    // old parent block whose key === o.parentKey; check its id maps to n.parentKey
+    const oldParent = state.old.find((b) => b.key === o.parentKey);
+    if (!oldParent?.blockId)
+        return false;
+    return state.matched.get(n.parentKey) === oldParent.blockId;
+}
+function sharedAnchorEvidence(o, n) {
+    if (o.anchors.length > 0 && n.anchors.some((a) => o.anchors.includes(a)))
+        return 1;
+    return 0;
+}
+// Candidate pruning (03 §5): |token_count diff| ≤ 3× and a shared 3-gram; cap
+// 12 candidates per block by shingle overlap.
+function pruneCandidates(olds, news) {
+    const oldShingles = new Map();
+    for (const o of olds)
+        oldShingles.set(o, shingles(o.text));
+    const candidates = [];
+    for (const n of news) {
+        const ns = shingles(n.text);
+        const nCount = tokenCount(n.text);
+        const perBlock = [];
+        for (const o of olds) {
+            if (o.type !== n.type)
+                continue;
+            const oCount = tokenCount(o.text);
+            const ratio = Math.max(oCount, nCount) / Math.max(1, Math.min(oCount, nCount));
+            if (ratio > 3)
+                continue;
+            const os = oldShingles.get(o);
+            let shares = false;
+            for (const s of ns)
+                if (os.has(s)) {
+                    shares = true;
+                    break;
+                }
+            if (!shares && ns.size > 0 && os.size > 0)
+                continue;
+            perBlock.push({ old: o, neu: n, score: 0 });
+        }
+        // cap at 12 by shingle overlap
+        perBlock.sort((a, b) => dice(oldShingles.get(b.old), ns) - dice(oldShingles.get(a.old), ns));
+        candidates.push(...perBlock.slice(0, 12));
+    }
+    return candidates;
+}
+function unmatchedOld(state) {
+    return state.old.filter((b) => !state.usedOld.has(b.blockId));
+}
+function unmatchedNew(state) {
+    return state.neu.filter((b) => !state.usedNew.has(b.key));
+}
+/**
+ * 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).
+ */
+export function phase5Scored(state) {
+    const olds = unmatchedOld(state);
+    const news = unmatchedNew(state);
+    if (olds.length === 0 || news.length === 0)
+        return;
+    // Bulk path guard: too many unmatched ⇒ skip (handled by give-up logic 2.5).
+    if (olds.length + news.length > state.config.maxScoredBlocks * 2)
+        return;
+    const oldCount = state.old.length;
+    const newCount = state.neu.length;
+    const candidates = pruneCandidates(olds, news);
+    for (const c of candidates)
+        c.score = scorePair(c.old, c.neu, state, oldCount, newCount);
+    // Deterministic order: score desc, then old key, then new key.
+    candidates.sort((a, b) => b.score - a.score || cmp(a.old.key, b.old.key) || cmp(a.neu.key, b.neu.key));
+    // All scored candidates per new key, for near-miss recording (R5).
+    const byNewKey = new Map();
+    for (const c of candidates)
+        (byNewKey.get(c.neu.key) ?? byNewKey.set(c.neu.key, []).get(c.neu.key)).push(c);
+    // accepted pairs per parent for the order (R3) check
+    const acceptedByParent = new Map();
+    for (const c of candidates) {
+        if (state.usedOld.has(c.old.blockId) || state.usedNew.has(c.neu.key))
+            continue;
+        const threshold = tokenCount(c.neu.text) < state.config.smallBlockTokens ? state.config.thetaSmall : state.config.thetaAccept;
+        if (c.score < threshold)
+            break; // sorted desc: nothing below will qualify either
+        // R3: within the same new parent, accepted pairs must not cross in order.
+        if (c.old.parentKey === c.neu.parentKey) {
+            const list = acceptedByParent.get(c.neu.parentKey) ?? [];
+            const crosses = list.some((p) => (p.oldIndex - c.old.index) * (p.newIndex - c.neu.index) < 0);
+            if (crosses)
+                continue;
+        }
+        // Near-misses (R5): other candidates for this new block whose score fell
+        // within 0.1 below the acceptance threshold. Recorded on the winner.
+        const nearMisses = (byNewKey.get(c.neu.key) ?? [])
+            .filter((o) => o.old.blockId !== c.old.blockId && o.score < threshold && o.score >= threshold - 0.1)
+            .map((o) => ({ blockId: o.old.blockId, score: round(o.score) }));
+        // accept
+        state.matched.set(c.neu.key, c.old.blockId);
+        state.usedOld.add(c.old.blockId);
+        state.usedNew.add(c.neu.key);
+        const moved = c.old.parentKey !== c.neu.parentKey || c.old.index !== c.neu.index;
+        const kind = moved ? "edited_moved" : "edited";
+        state.dispositions.push({
+            blockId: c.old.blockId,
+            kind,
+            confidence: c.score,
+            reason: "scored",
+            matcherV: state.config.matcherV,
+            detail: nearMisses.length > 0 ? { near_misses: nearMisses } : {},
+        });
+        const list = acceptedByParent.get(c.neu.parentKey) ?? [];
+        list.push({ oldIndex: c.old.index, newIndex: c.neu.index });
+        acceptedByParent.set(c.neu.parentKey, list);
+    }
+}
+function round(n) {
+    return Math.round(n * 1000) / 1000;
+}
+function cmp(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+//# sourceMappingURL=phase5.js.map

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

@@ -0,0 +1,2 @@
+import type { PhaseState } from "./phases.js";
+export declare function phase6aCompound(state: PhaseState): void;

package/dist/src/reconcile/phase6a.js

@@ -0,0 +1,159 @@
+import { shingles, dice, tokenCount, tokenize } from "./similarity.js";
+// Phase 6a — compound classification (03 §4): split, merge, copy over the
+// still-unmatched. Split/merge use dominant-fragment inheritance (tunable via
+// split.dominant_share; set to 1.01 to disable). Copies never steal identity.
+function unmatchedOld(state) {
+    return state.old.filter((b) => !state.usedOld.has(b.blockId));
+}
+function unmatchedNew(state) {
+    return state.neu.filter((b) => !state.usedNew.has(b.key));
+}
+// coverage(concat(N), O): how much of O's shingles the concatenation covers.
+function coverage(concatText, oText) {
+    const os = shingles(oText);
+    if (os.size === 0)
+        return 0;
+    const cs = shingles(concatText);
+    let covered = 0;
+    for (const s of os)
+        if (cs.has(s))
+            covered++;
+    return covered / os.size;
+}
+function carryTo(state, oldId, newB, kind, confidence, detail) {
+    state.matched.set(newB.key, oldId);
+    state.usedOld.add(oldId);
+    state.usedNew.add(newB.key);
+    state.dispositions.push({ blockId: oldId, kind, confidence, reason: "scored", matcherV: state.config.matcherV, detail });
+}
+// Record a mint-with-lineage disposition against a still-minted new block. The
+// new block gets a fresh id later (assignment step); here we note the lineage
+// keyed by the new block's positional key in detail.
+function noteLineage(state, newB, kind, counterpartOldId) {
+    state.usedNew.add(newB.key);
+    state.dispositions.push({
+        blockId: `NEW:${newB.key}`,
+        kind,
+        confidence: null,
+        reason: "scored",
+        matcherV: state.config.matcherV,
+        detail: { counterpart: counterpartOldId, newKey: newB.key },
+    });
+}
+/** Detect splits: one old block O covered by a run of ≥2 adjacent new blocks. */
+function detectSplits(state) {
+    const { splitCoverage, splitDominantShare } = state.config;
+    for (const o of unmatchedOld(state)) {
+        const news = unmatchedNew(state)
+            .filter((n) => n.parentKey === o.parentKey && n.type === o.type)
+            .sort((a, b) => a.index - b.index);
+        // find a contiguous run (by index) of length ≥2 covering O
+        for (let start = 0; start < news.length; start++) {
+            for (let end = news.length; end > start + 1; end--) {
+                const run = news.slice(start, end);
+                if (!isContiguous(run))
+                    continue;
+                const concat = run.map((n) => n.text).join(" ");
+                const cov = coverage(concat, o.text);
+                if (cov < splitCoverage)
+                    continue;
+                // leftover < 0.2 of the run's content is novel? approximate via reverse coverage.
+                const leftover = 1 - coverage(o.text, concat);
+                if (leftover >= 0.2)
+                    continue;
+                // dominant fragment: first fragment holding ≥ share of O's tokens?
+                const oTokens = tokenCount(o.text) || 1;
+                const first = run[0];
+                const firstShare = sharedTokenFraction(first.text, o.text, oTokens);
+                if (firstShare >= splitDominantShare) {
+                    carryTo(state, o.blockId, first, "edited", 0.8 * cov, { split: run.map((n) => n.key), dominant: first.key });
+                    for (const n of run.slice(1))
+                        noteLineage(state, n, "split_from", o.blockId);
+                }
+                else {
+                    state.usedOld.add(o.blockId);
+                    state.dispositions.push({ blockId: o.blockId, kind: "deleted", confidence: null, reason: "tombstone", matcherV: state.config.matcherV, detail: { splitInto: run.map((n) => n.key) } });
+                    for (const n of run)
+                        noteLineage(state, n, "split_from", o.blockId);
+                }
+                return; // one split per pass (conservative)
+            }
+        }
+    }
+}
+/** Detect merges: a run of ≥2 adjacent old blocks covered by one new block. */
+function detectMerges(state) {
+    const { splitCoverage, splitDominantShare } = state.config;
+    for (const n of unmatchedNew(state)) {
+        const olds = unmatchedOld(state)
+            .filter((o) => o.parentKey === n.parentKey && o.type === n.type)
+            .sort((a, b) => a.index - b.index);
+        for (let start = 0; start < olds.length; start++) {
+            for (let end = olds.length; end > start + 1; end--) {
+                const run = olds.slice(start, end);
+                if (!isContiguous(run))
+                    continue;
+                const concat = run.map((o) => o.text).join(" ");
+                const cov = coverage(n.text, concat);
+                if (cov < splitCoverage)
+                    continue;
+                const nTokens = tokenCount(n.text) || 1;
+                // dominant contributor: first old block holding ≥ share of N's tokens.
+                const first = run[0];
+                const firstShare = sharedTokenFraction(first.text, n.text, nTokens);
+                if (firstShare >= splitDominantShare) {
+                    carryTo(state, first.blockId, n, "edited", 0.8 * cov, { merge: run.map((o) => o.blockId), dominant: first.blockId });
+                    for (const o of run.slice(1)) {
+                        state.usedOld.add(o.blockId);
+                        state.dispositions.push({ blockId: o.blockId, kind: "merged_into", confidence: 0.8 * cov, reason: "scored", matcherV: state.config.matcherV, detail: { into: first.blockId } });
+                    }
+                }
+                else {
+                    state.usedNew.add(n.key);
+                    for (const o of run) {
+                        state.usedOld.add(o.blockId);
+                        state.dispositions.push({ blockId: o.blockId, kind: "merged_into", confidence: null, reason: "scored", matcherV: state.config.matcherV, detail: { mergedKey: n.key } });
+                    }
+                    noteLineage(state, n, "merged_into", first.blockId);
+                }
+                return;
+            }
+        }
+    }
+}
+/** Detect copies: unmatched new block ≥ copy.sim to a MATCHED (present) old block. */
+function detectCopies(state) {
+    const matchedOldIds = new Set(state.matched.values());
+    const matchedOld = state.old.filter((o) => matchedOldIds.has(o.blockId));
+    for (const n of unmatchedNew(state)) {
+        for (const o of matchedOld) {
+            if (o.type !== n.type)
+                continue;
+            if (dice(shingles(o.text), shingles(n.text)) >= state.config.copySim) {
+                noteLineage(state, n, "copied_from", o.blockId);
+                break;
+            }
+        }
+    }
+}
+export function phase6aCompound(state) {
+    detectSplits(state);
+    detectMerges(state);
+    detectCopies(state);
+}
+function isContiguous(run) {
+    for (let i = 1; i < run.length; i++)
+        if (run[i].index !== run[i - 1].index + 1)
+            return false;
+    return true;
+}
+function sharedTokenFraction(fragment, whole, wholeTokenCount) {
+    const fragTokens = new Set(tokenize(fragment));
+    const wholeTokens = tokenize(whole);
+    let shared = 0;
+    for (const t of wholeTokens)
+        if (fragTokens.has(t))
+            shared++;
+    return shared / wholeTokenCount;
+}
+//# sourceMappingURL=phase6a.js.map

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

@@ -0,0 +1,28 @@
+import type { MatchBlock, Disposition, ReconcileConfig } from "./types.js";
+export interface PhaseState {
+    old: MatchBlock[];
+    neu: MatchBlock[];
+    /** new key → old id */
+    matched: Map<string, string>;
+    /** old ids already consumed */
+    usedOld: Set<string>;
+    /** new keys already matched */
+    usedNew: Set<string>;
+    dispositions: Disposition[];
+    config: ReconcileConfig;
+}
+/** Phase 1 — exact raw-hash lock. */
+export declare function phase1Exact(state: PhaseState): void;
+/** Phase 2 — normalized-hash lock. */
+export declare function phase2Normalized(state: PhaseState): void;
+/** Phase 3 — anchor lock: same authored ^ref, unique on both sides. */
+export declare function phase3Anchor(state: PhaseState): void;
+/**
+ * Phase 4 — context propagation (03 §4). Matched siblings vouch for the
+ * stranger between them: within a gap bounded by matched blocks, if exactly one
+ * unmatched OLD child remains, pair it with its best-matching unmatched NEW
+ * child in that same gap (text_sim ≥ floor, unique best). Insertions in the gap
+ * do not block the carry — they simply lose to the better-matching candidate,
+ * which is why an inserted block never steals an edited block's identity.
+ */
+export declare function phase4Context(state: PhaseState): void;

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

@@ -0,0 +1,21 @@
+import type { MatchBlock, ReconcileConfig, MatchResult } from "./types.js";
+export interface ResurrectionCandidate {
+    blockId: string;
+    rawHashHex: string;
+    normHashHex: string;
+    type: string;
+}
+export interface ReconcileOptions {
+    config?: ReconcileConfig;
+    /** resurrection pool (cross-checkpoint) matched by raw/norm hash only. */
+    pool?: ResurrectionCandidate[];
+}
+export interface DocReconcileResult extends MatchResult {
+    /** pool ids consumed by resurrection this run */
+    consumedPool: string[];
+}
+/**
+ * Reconcile one document. `oldBlocks` carry ids; `newBlocks` do not. Returns the
+ * assignment (new key → id), dispositions, and deleted old ids.
+ */
+export declare function reconcileDocument(oldBlocks: MatchBlock[], newBlocks: MatchBlock[], opts?: ReconcileOptions): DocReconcileResult;

package/dist/src/reconcile/reconcile.js

@@ -0,0 +1,115 @@
+import { mintId } from "../core/ids.js";
+import { DEFAULT_CONFIG } from "./types.js";
+import { phase1Exact, phase2Normalized, phase3Anchor, phase4Context } from "./phases.js";
+import { phase5Scored } from "./phase5.js";
+import { phase6aCompound } from "./phase6a.js";
+function newState(old, neu, config) {
+    return { old, neu, matched: new Map(), usedOld: new Set(), usedNew: new Set(), dispositions: [], config };
+}
+// Bulk-rewrite give-up (03 §6): after phase 2, if a large doc is mostly
+// unmatched with low mean similarity, mint everything + one bulk_rewrite.
+function shouldBulkRewrite(state) {
+    const total = state.neu.length;
+    if (total < state.config.bulkMinBlocks)
+        return false;
+    const unmatchedFrac = (state.neu.length - state.usedNew.size) / total;
+    return unmatchedFrac > state.config.bulkUnmatchedFrac;
+}
+/** Resurrection (03 §4 phase 6b, cross-checkpoint): match remaining new blocks
+ * against a pool by exact raw/norm hash only. Consumes matched pool rows. */
+function phase6bResurrection(state, pool, consumed) {
+    const byRaw = new Map();
+    const byNorm = new Map();
+    for (const c of pool) {
+        byRaw.set(`${c.type} ${c.rawHashHex}`, c);
+        byNorm.set(`${c.type} ${c.normHashHex}`, c);
+    }
+    for (const n of state.neu) {
+        if (state.usedNew.has(n.key))
+            continue;
+        const hit = byRaw.get(`${n.type} ${n.rawHashHex}`) ?? byNorm.get(`${n.type} ${n.normHashHex}`);
+        if (hit && !consumed.has(hit.blockId)) {
+            consumed.add(hit.blockId);
+            state.matched.set(n.key, hit.blockId);
+            state.usedNew.add(n.key);
+            state.dispositions.push({ blockId: hit.blockId, kind: "resurrected", confidence: 0.99, reason: "exact_hash", matcherV: state.config.matcherV, detail: {} });
+        }
+    }
+}
+/**
+ * Reconcile one document. `oldBlocks` carry ids; `newBlocks` do not. Returns the
+ * assignment (new key → id), dispositions, and deleted old ids.
+ */
+export function reconcileDocument(oldBlocks, newBlocks, opts = {}) {
+    const config = opts.config ?? DEFAULT_CONFIG;
+    const state = newState(oldBlocks, newBlocks, config);
+    const consumedPool = new Set();
+    phase1Exact(state);
+    phase2Normalized(state);
+    if (shouldBulkRewrite(state)) {
+        return bulkRewrite(state);
+    }
+    phase3Anchor(state);
+    phase4Context(state);
+    phase5Scored(state);
+    phase6aCompound(state);
+    if (opts.pool && opts.pool.length > 0)
+        phase6bResurrection(state, opts.pool, consumedPool);
+    return finalize(state, [...consumedPool]);
+}
+// Phase 7 defaults + assignment resolution. Every new block gets a final id:
+// carried (from state.matched), lineage-minted (NEW:<key> dispositions), or a
+// plain minted 'inserted'. Remaining old blocks are 'deleted'.
+function finalize(state, consumedPool) {
+    const assignment = new Map();
+    const dispositions = [...state.dispositions];
+    // Carried assignments.
+    for (const [newKey, oldId] of state.matched)
+        assignment.set(newKey, oldId);
+    // Lineage placeholders (split_from/merged_into/copied_from on NEW:<key>):
+    // mint a fresh id and rewrite the disposition to the minted id.
+    for (const d of dispositions) {
+        if (d.blockId.startsWith("NEW:")) {
+            const newKey = d.detail.newKey;
+            const minted = assignment.get(newKey) ?? mintId("b");
+            assignment.set(newKey, minted);
+            d.blockId = minted;
+        }
+    }
+    // Remaining new blocks with no assignment → minted 'inserted'.
+    for (const n of state.neu) {
+        if (!assignment.has(n.key)) {
+            const minted = mintId("b");
+            assignment.set(n.key, minted);
+            dispositions.push({ blockId: minted, kind: "inserted", confidence: null, reason: null, matcherV: state.config.matcherV, detail: {} });
+        }
+    }
+    // Remaining old blocks (not carried) → deleted.
+    const deleted = [];
+    for (const o of state.old) {
+        if (!state.usedOld.has(o.blockId)) {
+            deleted.push(o.blockId);
+            dispositions.push({ blockId: o.blockId, kind: "deleted", confidence: null, reason: "tombstone", matcherV: state.config.matcherV, detail: {} });
+        }
+    }
+    return { assignment, dispositions, deleted, consumedPool };
+}
+function bulkRewrite(state) {
+    // Mint everything; emit one doc-scoped bulk_rewrite + deleted for all old.
+    const assignment = new Map();
+    const dispositions = [
+        { blockId: "DOC", kind: "bulk_rewrite", confidence: null, reason: null, matcherV: state.config.matcherV, detail: { unmatchedFrac: (state.neu.length - state.usedNew.size) / state.neu.length } },
+    ];
+    for (const n of state.neu) {
+        const minted = mintId("b");
+        assignment.set(n.key, minted);
+        dispositions.push({ blockId: minted, kind: "inserted", confidence: null, reason: null, matcherV: state.config.matcherV, detail: {} });
+    }
+    const deleted = [];
+    for (const o of state.old) {
+        deleted.push(o.blockId);
+        dispositions.push({ blockId: o.blockId, kind: "deleted", confidence: null, reason: "tombstone", matcherV: state.config.matcherV, detail: {} });
+    }
+    return { assignment, dispositions, deleted, consumedPool: [] };
+}
+//# sourceMappingURL=reconcile.js.map

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

@@ -0,0 +1,7 @@
+export declare function tokenize(text: string): string[];
+/** Token 3-gram shingles (padded so short texts still produce shingles). */
+export declare function shingles(text: string, n?: number): Set<string>;
+/** Dice coefficient over two shingle sets: 2|A∩B| / (|A|+|B|). */
+export declare function dice(a: Set<string>, b: Set<string>): number;
+export declare function textSim(a: string, b: string): number;
+export declare function tokenCount(text: string): number;

package/dist/src/reconcile/similarity.js

@@ -0,0 +1,41 @@
+// Text similarity (03 §5): token 3-gram shingle Dice coefficient over
+// normalized text. Deterministic; no clock/RNG.
+export function tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+}
+/** Token 3-gram shingles (padded so short texts still produce shingles). */
+export function shingles(text, n = 3) {
+    const tokens = tokenize(text);
+    const out = new Set();
+    if (tokens.length === 0)
+        return out;
+    if (tokens.length < n) {
+        out.add(tokens.join(" "));
+        return out;
+    }
+    for (let i = 0; i + n <= tokens.length; i++) {
+        out.add(tokens.slice(i, i + n).join(" "));
+    }
+    return out;
+}
+/** Dice coefficient over two shingle sets: 2|A∩B| / (|A|+|B|). */
+export function dice(a, b) {
+    if (a.size === 0 && b.size === 0)
+        return 1;
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let inter = 0;
+    for (const s of a)
+        if (b.has(s))
+            inter++;
+    return (2 * inter) / (a.size + b.size);
+}
+export function textSim(a, b) {
+    if (a === b)
+        return 1;
+    return dice(shingles(a), shingles(b));
+}
+export function tokenCount(text) {
+    return tokenize(text).length;
+}
+//# sourceMappingURL=similarity.js.map

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

@@ -0,0 +1,46 @@
+export type DispositionKind = "same" | "edited" | "moved" | "edited_moved" | "inserted" | "deleted" | "split_from" | "merged_into" | "copied_from" | "resurrected" | "bulk_rewrite";
+export type Reason = "exact_hash" | "normalized_hash" | "anchor" | "context_unique" | "scored" | "tombstone" | "api";
+export interface MatchBlock {
+    /** present on old blocks; undefined on new blocks until assigned */
+    blockId?: string;
+    type: string;
+    rawHashHex: string;
+    normHashHex: string;
+    text: string;
+    anchors: string[];
+    parentKey: string | null;
+    index: number;
+    /** stable positional key: parentKey + '/' + index */
+    key: string;
+}
+export interface Disposition {
+    blockId: string;
+    kind: DispositionKind;
+    confidence: number | null;
+    reason: Reason | null;
+    matcherV: string;
+    detail: Record<string, unknown>;
+}
+export interface ReconcileConfig {
+    matcherV: string;
+    thetaAccept: number;
+    thetaSmall: number;
+    thetaXdoc: number;
+    splitCoverage: number;
+    splitDominantShare: number;
+    copySim: number;
+    bulkUnmatchedFrac: number;
+    bulkMinBlocks: number;
+    maxScoredBlocks: number;
+    smallBlockTokens: number;
+    contextSimFloor: number;
+}
+export declare const DEFAULT_CONFIG: ReconcileConfig;
+/** The result of matching one document's old tree against new blocks. */
+export interface MatchResult {
+    /** new block key → assigned id (carried) or minted id */
+    assignment: Map<string, string>;
+    dispositions: Disposition[];
+    /** old block ids that were not carried (deleted) */
+    deleted: string[];
+}

package/dist/src/reconcile/types.js

@@ -0,0 +1,19 @@
+// Reconciliation types (reconciliation-spec). The matcher takes the last
+// persisted block tree (blocks carrying ids) and the newly parsed tree (blocks
+// without ids) and produces an assignment: each new block either CARRIES an
+// existing id or is MINTED, plus a disposition per carry/mint.
+export const DEFAULT_CONFIG = {
+    matcherV: "m1.0",
+    thetaAccept: 0.62,
+    thetaSmall: 0.8,
+    thetaXdoc: 0.8,
+    splitCoverage: 0.8,
+    splitDominantShare: 0.7,
+    copySim: 0.95,
+    bulkUnmatchedFrac: 0.45,
+    bulkMinBlocks: 100,
+    maxScoredBlocks: 2000,
+    smallBlockTokens: 8,
+    contextSimFloor: 0.35,
+};
+//# sourceMappingURL=types.js.map