openwriter 0.14.0 → 0.16.0

package/dist/server/node-matcher.js

@@ -19,14 +19,14 @@
  *     - Insert (any block still unmatched → fresh ID)
  *   Phase 3: orphans = previousNodes entries no rule claimed (= deletes)
  *
- * Fingerprints use math signals (per-sentence char count, 3-char prefix/suffix,
- * terminator, word-length sequence) plus full word arrays for math-collision
- * disambiguation. Documented in node-fingerprint.ts.
+ * Fingerprints carry one tuple per sentence: char count, content hash,
+ * terminator type. Hash equality identifies "same sentence text" in 8 bytes.
+ * Documented in node-fingerprint.ts.
  *
  * adr: adr/node-identity-matcher.md
  */
 import { generateNodeId } from './helpers.js';
-import { fingerprintAll, isExactMatch, isSameContent, sentenceArraysEqual, sentenceTuplesEqual, } from './node-fingerprint.js';
+import { fingerprintAll, isExactMatch, isSameContent, sentenceArraysEqual, } from './node-fingerprint.js';
 /**
  * Run the matcher.
  *
@@ -51,9 +51,9 @@ export function matchNodes(previousNodes, newBlocks, options = {}) {
     applyMergeRule(unmatched, previousNodes, claimedPrevIds, pinned);
     applyTypeChangeRule(unmatched, previousNodes, claimedPrevIds, pinned);
     applyEditRule(unmatched, previousNodes, claimedPrevIds, pinned);
-    applySlotContinuityRule(unmatched, previousNodes, claimedPrevIds, pinned);
+    applySlotContinuityRule(unmatched, previousNodes, claimedPrevIds, pinned, graveyard);
     applyGraveyardRestoreRule(unmatched, graveyard, claimedGraveIds, pinned);
-    applyInsertRule(unmatched, pinned);
+    applyInsertRule(unmatched, pinned, previousNodes, claimedPrevIds, graveyard, claimedGraveIds);
     const orphaned = previousNodes
         .filter((prev) => !claimedPrevIds.has(prev.id))
         .map((prev) => ({ id: prev.id, fingerprint: prev.fingerprint }));
@@ -387,12 +387,31 @@ function applyEditRule(unmatched, previousNodes, claimedPrevIds, pinned) {
 // ----------------------------------------------------------------------
 // Slot-continuity fallback
 // ----------------------------------------------------------------------
-function applySlotContinuityRule(unmatched, previousNodes, claimedPrevIds, pinned) {
+function applySlotContinuityRule(unmatched, previousNodes, claimedPrevIds, pinned, graveyard) {
     let progress = true;
     while (progress) {
         progress = false;
         for (let ui = 0; ui < unmatched.length; ui++) {
             const candidate = unmatched[ui];
+            // Skip candidates that carry an explicit ID already known to the
+            // identity graph (in previousNodes or graveyard). Such IDs are real
+            // signals — the load-time matcher's previous pin, a restored snapshot,
+            // or a paste-back from graveyard. Don't override them with positional
+            // guessing; let applyInsertRule preserve them (for previousNodes hits)
+            // or applyGraveyardRestoreRule restore them (for graveyard hits).
+            //
+            // Transient IDs (not in either set — e.g. a fresh ID typed in the
+            // editor by a user replacing a block in place) still go through
+            // slot-continuity per the "slot is innocent" principle.
+            //
+            // adr: adr/node-identity-matcher.md
+            if (candidate.block.id) {
+                const id = candidate.block.id;
+                const inPrev = previousNodes.some((p) => p.id === id);
+                const inGrave = graveyard.some((g) => g.id === id);
+                if (inPrev || inGrave)
+                    continue;
+            }
             const matchingOrphans = previousNodes.filter((orphan) => {
                 if (claimedPrevIds.has(orphan.id))
                     return false;
@@ -440,36 +459,22 @@ function applySlotContinuityRule(unmatched, previousNodes, claimedPrevIds, pinne
     }
 }
 /**
- * Lightweight content overlap signal used by slot-continuity scoring.
- * Per sentence-pair: +1 f, +1 l, +1 t, +2 wls-equal, +3×shared-words,
- * +10 full word-array equality. Word-level overlap is the disambiguator
- * when math signals collide.
+ * Lightweight content overlap signal used by slot-continuity scoring to
+ * disambiguate between multiple candidate orphans in the same slot range.
+ *
+ * Per sentence pair across both blocks: +1 for each hash that appears in
+ * both arrays. Since hashes fold sentence text + terminator together, this
+ * counts the number of fully-shared sentences between the two blocks — the
+ * matcher's only meaningful similarity question.
  */
 function sentenceSignalOverlapScore(a, b) {
     if (!a.sentences || !b.sentences)
         return 0;
+    const seen = new Set(a.sentences);
     let score = 0;
-    for (const sa of a.sentences) {
-        for (const sb of b.sentences) {
-            if (sa.f === sb.f)
-                score++;
-            if (sa.l === sb.l)
-                score++;
-            if (sa.t === sb.t)
-                score++;
-            if (arraysEqual(sa.wls, sb.wls))
-                score += 2;
-            if (Array.isArray(sa.w) && Array.isArray(sb.w)) {
-                const aSet = new Set(sa.w);
-                let shared = 0;
-                for (const w of sb.w)
-                    if (aSet.has(w))
-                        shared++;
-                score += shared * 3;
-                if (arraysEqual(sa.w, sb.w))
-                    score += 10;
-            }
-        }
+    for (const h of b.sentences) {
+        if (seen.has(h))
+            score++;
     }
     return score;
 }
@@ -506,11 +511,44 @@ function applyGraveyardRestoreRule(unmatched, graveyard, claimedGraveIds, pinned
 // ----------------------------------------------------------------------
 // Insert rule (last resort)
 // ----------------------------------------------------------------------
-function applyInsertRule(unmatched, pinned) {
+function applyInsertRule(unmatched, pinned, previousNodes, claimedPrevIds, graveyard, claimedGraveIds) {
     for (let i = unmatched.length - 1; i >= 0; i--) {
         const candidate = unmatched[i];
+        // Preserve an existing block ID if the TipTap node already carried one
+        // (e.g. agent-assigned via applyChangesToDocument, or freshly minted by
+        // the doc-update path). Minting a new ID here would diverge the server
+        // copy from the browser copy — the browser still has the original ID,
+        // so subsequent updates targeting the new ID can't be resolved and the
+        // browser's autosave later overwrites server state with stale content.
+        //
+        // If the preserved ID also lives in previousNodes or the graveyard, we
+        // must claim it from those sets so the same ID doesn't simultaneously
+        // appear in pinned AND in orphaned/remaining-graveyard. Without claiming,
+        // bb000001 would end up listed in both `nodes:` and `graveyard:` in the
+        // output frontmatter — the matcher's identity invariant says an ID lives
+        // in exactly one place.
+        //
+        // If the preserved ID is already claimed (another block earlier in this
+        // pass took it, e.g. an exact-match), fall back to a fresh ID to keep IDs
+        // globally unique.
+        //
+        // adr: adr/node-identity-matcher.md
+        let id;
+        const preservedId = candidate.block.id;
+        if (preservedId &&
+            !claimedPrevIds.has(preservedId) &&
+            !claimedGraveIds.has(preservedId)) {
+            id = preservedId;
+            if (previousNodes.some((p) => p.id === preservedId))
+                claimedPrevIds.add(preservedId);
+            if (graveyard.some((g) => g.id === preservedId))
+                claimedGraveIds.add(preservedId);
+        }
+        else {
+            id = generateNodeId();
+        }
         pinned.push({
-            id: generateNodeId(),
+            id,
             position: candidate.position,
             fingerprint: candidate.fingerprint,
             block: candidate.block,
@@ -544,21 +582,10 @@ function slotHighBound(previousNodes, claimedPrevIds, pinned, orphanIdx) {
 function shareAnySentenceTuple(a, b) {
     if (!Array.isArray(a) || !Array.isArray(b))
         return false;
-    for (const sa of a) {
-        for (const sb of b) {
-            if (sentenceTuplesEqual(sa, sb))
-                return true;
-        }
+    const seen = new Set(a);
+    for (const sb of b) {
+        if (seen.has(sb))
+            return true;
     }
     return false;
 }
-function arraysEqual(a, b) {
-    if (!Array.isArray(a) || !Array.isArray(b))
-        return false;
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++)
-        if (a[i] !== b[i])
-            return false;
-    return true;
-}