openwriter 0.14.0 → 0.15.0

package/dist/server/node-matcher.js

@@ -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;
@@ -506,11 +525,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,