Fix reconcile loop when attribution marks are non-self-excluding

When an integrator declares the fixed `y-attributed-*` marks
*non-self-excluding* (e.g. BlockNote, so user content marks may overlap
them), `nodeToDelta` keyed them with the overlapping-mark `--<hash>`
suffix while the attribution mapper and the PM->Y strip key them bare.
The PM<->Y write diff and the Y->PM reconcile then disagreed on the
format key and flapped between `y-attributed-delete` and
`y-attributed-delete--<hash>` forever - a paragraph->heading suggestion
froze the browser.

Key the three fixed attribution mark names bare regardless of
self-exclusion: the attribution manager already aggregates every author
of a span into a single mark (its `userIds` is a list), so an attribution
mark never needs the overlapping-mark hash to stay distinct.

Adds a block-boundary regression test that reconcile-loops (hits a
transaction guard) without the fix and converges with it.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: YousefED

src/sync-utils.js

@@ -192,14 +192,28 @@ const hashedMarkNameRegex = /(.*)(--[a-zA-Z0-9+/=]{8})$/
  */
 export const yattr2markname = attrName => hashedMarkNameRegex.exec(attrName)?.[1] ?? attrName
 
+/**
+ * The three fixed attribution mark names (see {@link defaultMapAttributionToMark}).
+ * They are always keyed by their bare name in the Y representation - never given
+ * the overlapping-mark `--<hash>` suffix below - because the attribution mapper
+ * and the PM->Y strip both key them bare, and the attribution manager already
+ * aggregates every author of a span into a single mark (its `userIds` is a list),
+ * so there is never more than one attribution mark of a kind on a span to
+ * disambiguate. If an integrator declares these marks *non-self-excluding* (e.g.
+ * so user content marks may overlap them, as BlockNote does), hashing them would
+ * make {@link nodeToDelta}'s key disagree with the mapper's, and the PM<->Y
+ * reconcile would flap between the two forms forever.
+ */
+const attributionMarkNameSet = new Set(['y-attributed-insert', 'y-attributed-delete', 'y-attributed-format'])
+
 /**
  * Inverse of {@link yattr2markname}: the delta format key for a PM mark.
  *
  * @param {import('prosemirror-model').Mark} mark
  * @return {string}
  */
 const markToYattrName = mark =>
-  mark.type.excludes(mark.type)
+  attributionMarkNameSet.has(mark.type.name) || mark.type.excludes(mark.type)
     ? mark.type.name
     : `${mark.type.name}--${hashOfJSON(mark.toJSON())}`
 

tests/block-boundary.test.js

@@ -331,3 +331,75 @@ export const testStrictContainerChildFlipReject = _tc => {
   assertDocJSON(viewer.state.doc, expected, 'viewer: original paragraph after reject')
   assertDocJSON(editor.state.doc, expected, 'editor: original paragraph after reject')
 }
+
+/**
+ * Regression: a boundary-raised type change must converge (no PM<->Y reconcile
+ * loop) when the integrator declares the `y-attributed-*` attribution marks
+ * *non-self-excluding* - as BlockNote does, so user content marks can overlap
+ * them.
+ *
+ * The bug: `nodeToDelta` keys a non-self-excluding mark with the overlapping-mark
+ * `--<hash>` suffix (`y-attributed-delete--<hash>`), but the attribution mapper
+ * keys it bare (`y-attributed-delete`). The PM->Y diff and the Y->PM reconcile
+ * then disagree on the key and flap between the two forms forever (the browser
+ * demo froze on a paragraph->heading suggestion). The fix keys the three fixed
+ * attribution mark names bare regardless of self-exclusion. This test loops
+ * (hangs / hits the guard) without that fix.
+ *
+ * @param {t.TestCase} _tc
+ */
+export const testBoundaryRaiseConvergesWithOverlappingAttributionMarks = _tc => {
+  // `excludes: ''` makes the mark non-self-excluding (multiple may coexist on a
+  // span) - the configuration that triggered the hash/bare key reconcile loop.
+  const overlappingMark = () => ({
+    excludes: '',
+    attrs: { userIds: { default: [] }, timestamp: { default: null } },
+    toDOM () { return /** @type {import('prosemirror-model').DOMOutputSpec} */ (['span', 0]) }
+  })
+  const amark = 'y-attributed-insert y-attributed-delete y-attributed-format'
+  const overlapSchema = new Schema({
+    nodes: {
+      doc: { content: 'blockGroup' },
+      blockGroup: { content: 'blockContainer+', marks: amark, toDOM () { return ['div', 0] } },
+      blockContainer: { content: 'blockContent blockGroup?', attrs: { id: { default: null } }, marks: amark, toDOM () { return ['div', 0] } },
+      paragraph: { content: 'inline*', group: 'blockContent', marks: amark, toDOM () { return ['p', 0] } },
+      heading: { content: 'inline*', group: 'blockContent', attrs: { level: { default: 1 } }, marks: amark, toDOM (n) { return ['h' + n.attrs.level, 0] } },
+      text: { group: 'inline' }
+    },
+    marks: {
+      'y-attributed-insert': overlappingMark(),
+      'y-attributed-delete': overlappingMark(),
+      'y-attributed-format': overlappingMark()
+    }
+  })
+  const doc = new Y.Doc({ gc: false, guid: 'base' })
+  const suggestionModeDoc = new Y.Doc({ isSuggestionDoc: true, gc: false, guid: 'se' })
+  const am = Y.createAttributionManagerFromDiff(doc, suggestionModeDoc, { attrs: new Y.Attributions() })
+  am.suggestionMode = true
+  doc.get('prosemirror').applyDelta(delta.create().insert([
+    delta.create('blockGroup', {}, [delta.create('blockContainer', { id: 'A' }, [delta.create('paragraph', {}, 'child')])])
+  ]).done())
+
+  let txCount = 0
+  const view = new EditorView(
+    { mount: document.createElement('div') },
+    {
+      state: EditorState.create({ schema: overlapSchema, plugins: [YPM.syncPlugin({ matchNodes })] }),
+      // Guard so a reconcile-loop regression fails cleanly instead of hanging CI.
+      dispatchTransaction (tr) {
+        if (++txCount > 100) throw new Error('reconcile loop: >100 transactions for a single flip')
+        view.updateState(view.state.apply(tr))
+      }
+    }
+  )
+  YPM.configureYProsemirror({ ytype: suggestionModeDoc.get('prosemirror'), attributionManager: am })(view.state, view.dispatch)
+
+  txCount = 0
+  view.dispatch(view.state.tr.setNodeMarkup(2, overlapSchema.nodes.heading, { level: 2 }))
+
+  t.assert(txCount <= 100, 'converged without a reconcile loop')
+  const bg = view.state.doc.child(0)
+  t.assert(bg.childCount === 2, 'boundary raised to two sibling blockContainers')
+  t.assert(bg.child(0).child(0).type.name === 'paragraph', 'first block is the deleted paragraph')
+  t.assert(bg.child(1).child(0).type.name === 'heading', 'second block is the inserted heading')
+}