[zurfyx]

Note

Stack, part 9 of 10. Based on #9527 (zurfyx/y-move-keeps-unknown-fields). Review only this PR's own commits.

The @lexical/y fixes touch the same writer, cursor, reader and binding internals, so they are one linear stack: each PR is based on the one below it, each conflict is resolved once, in the PR whose change causes it, and every CI run tests the real combination.

Merge order: bottom first, #9509 → #9523 → #9522 → #9505 → #9508 → #9502 → #9504 → #9527 → #9507 → #9510. With squash merges, rebase the next PR onto main before merging it (git rebase --onto main <old base branch>).

The stack

#	PR	Branch	Base
1	#9509	zurfyx/update-error-rollback	main
2	#9523	zurfyx/write-before-unread-change	#9509
3	#9522	zurfyx/y-keep-chars-at-format-boundary	#9523
4	#9505	zurfyx/y-undo-member-closer	#9522
5	#9508	zurfyx/y-initial-state-binding	#9505
6	#9502	zurfyx/y-reorder-intent	#9508
7	#9504	zurfyx/y-preserve-unknown-attrs	#9502
8	#9527	zurfyx/y-move-keeps-unknown-fields	#9504
9	#9507 (this PR)	zurfyx/y-composition-holdback	#9527
10	#9510	zurfyx/y-incremental-read-marks	#9507

Follow-ups for after the stack (not in it):

• One "seen of Yjs" view. [lexical-y] Bug Fix: Write a local update made before an unread remote change on the document it was made on #9523's Unread (changes Yjs applied that the binding has not read) and [lexical-playground][lexical-website][lexical-y] Bug Fix: Hold back remote changes to the line being composed until the composition ends #9507's Hidden (changes held back while a line is composed) answer one question, and call sites combine them by hand. One owner module (isGone, isShown, attrOf/attrsOf and the write primitives), an item-level held overlay instead of the was/now maps, and a lint or grep test that allows raw .deleted/getAttr(s) only in the Reader and in named provenance scans. [lexical-website][lexical-y] Bug Fix: Stop a format, comment or link from spreading to the end of the document after an undo or delete races an edit inside it #9505's run-opener scans (liveItemBefore, runOpener, restatedEnd) still read raw deletedness and move there too.
• B-2 at the end of a line. Enter at the very end of a line being composed, while a collaborator's alignment change is held back, leaves that alignment off the new line Lexical copies it to. Enter inside the line keeps it on both halves. It needs a per-key "inherits on split" rule, or a Limit in y.md.
• [lexical-website][lexical-y] Bug Fix: Keep the fields an older client does not know in a block it moves #9527's group fallback chain. A moved item takes its group's fields from a chain of four lookups ($groupReference, $priorGroupItem, the nearest neighbour's marker before the write, priorGroupMarker), with separate predecessor stores for markers and nodes. One stored-predecessor lookup would replace it.

Description

While the local editor composes with an IME in a line, @lexical/y held back only plain remote inserts into that line, and only when the change had no deletion, format or marker. It read everything else mid-composition, and the hold-back itself could lose or duplicate text:

• Bug: [lexical-y] A remote insert into the composing line is shown mid-composition when the line was made by joining two lines #9492: in a line made by joining two lines, the deleted marker of the join made a remote insert look structural, so it was read mid-composition.
• A remote bold or comment split the text node being composed (S7-9). A remote Enter later in the line gave the composed text a new key, so the browser restarted the composition and committed its first character for everyone (alpha betan你好 ga, S7-15).
• Enter while composing, after a collaborator typed in the line: the held word never showed, and the composer's next edit of the line deleted it for everyone (S7-12).
• A remote paste into the composed line followed by typing in it, two people composing at one place, a joined line with a bold first word, or offline edits at the start of an emptied line stored a word twice (S7-28).
• In a highlighted code line, a remote format during a composition left the composer with other code-highlight segments than its peers and a fresh read, and the self-check warned (S7-8).

This change replaces that with one rule. While the editor composes in a line, every remote change to that line that Yjs keeps whole is held back: inserted text and inline nodes, formats and comments, line markers (a split, pasted lines), deletions of what is held, and the attributes set on the line's marker, with the values they had, taken from the transaction. Every reader and writer of the line works on the editor's view of it, Yjs minus what is held (Hidden). A change that removes something the editor shows (a deletion, a join, a MarkNode wrap) is read at once and whole; the text node being composed then keeps its key for the text that holds the composition caret, found by Yjs identity. The hold lasts while the composition goes on in that line and everything held is still in it. When it ends (the composition ends or moves, or a local edit such as Enter, Backspace or a paste takes held content out of the line), one release path reads every held change where its content is now. A local edit of the composed line's attributes keeps each held value it did not change. The text node a read shows a piece in also takes that piece's segment key (S7-8).

Behavior changes: a remote split or change of type of the line being composed now waits for the composition to end, and a held insert survives a remote join (two existing tests in Composition.test.ts are updated). A code block turned into a heading still replaces the composed node, because its class changes. y.md documents the rule and its limits.

Follow-up commits:

• S7-37 (tests only): a remote delete while inserts are held in the composing line. The first commit already handles it; the regression test and a matrix shape (a three-node line with a third peer) cover it.
• MF-1 and B-2: the hold captures only marker keys the client owns, and a change of keys it does not own creates no hold. A held alignment or type now stays on both halves of a split made while composing (the composed line and the new line that ends at the old marker). Lines the composed line was joined into keep their own values.

Closes #9492

Restack (October 29)

Rebased onto #9527 (it was based on #9504). Conflicts, resolved in its first commit:

• with [lexical-y] Bug Fix: Write a local update made before an unread remote change on the document it was made on #9523 in Binding.ts, Cursor.ts, State.ts and Write.ts: isShownEnd is !isGone && isEndItem && !hidden.hides; the cursor steps over isGone(r) || isHeldFormat(r); unitLeft and prevLiveEnd skip gone ends.
• with [lexical-website][lexical-y] Bug Fix: Keep the fields an older client does not know in a block it moves #9527 in Write.ts: $writeMarker(item, d: Desired) with let desired = this.$marker(d), then this PR's held merge, before owners and $markerAsStored are computed.

New commits:

• N2: the Writer constructor no longer refreshes held marker values from raw Yjs. Under [lexical-y] Bug Fix: Write a local update made before an unread remote change on the document it was made on #9523 that read a remote change the binding had not read yet and wrote it as the client's own, so a composition step that never touched the alignment changed which concurrent value Yjs kept (justify became right, three clients). Test: N2: in regressions/Composition.test.ts.
• Refactor: $holds and Hidden's isShown judge deletedness with isGone, as shownLength and isShownEnd do, and the Reader's held-attribute check uses attrsBefore from Unread.ts instead of a copy in Binding.ts. Hidden#marker's TSDoc points to ownsMarkerAttr.
• MF-1 test: it now requires that a composition changes nothing A stores when A splits the line. It used to require the field to be stored once, which a split never guaranteed (see [lexical-website][lexical-y] Bug Fix: Keep the fields an older client does not know in a block it moves #9527's N1).

Fixed after a randomized soak test of the whole stack (one commit):

• L1C-3: a multi-paragraph paste into the line being composed, after a held insert, no longer stores its last paragraph twice when the composition ends: inserts the release already showed are read, not held again.
• L1C-4: a remote bold on the composing line is shown when the composition ends with Enter in the same update (as Android's insertParagraph and composition data ending in a line break do), also after later splits of that line.
• S8-4: the next composition step after a held insert and a held paste no longer throws cursor advanced past the end, which dropped every later step and lost the composed text.
• S8-6: with BlockIdExtension, a pasted list item's blockId in the composer's editor matches the stored one.
  Tests L1C-3:, L1C-4:, S8-4: and S8-6: in regressions/Composition.test.ts; the test harness can enable BlockIdExtension per peer.

Important

Decision for Gerard (N1), shared with #9527: a split by a client that does not own a field keeps it on both lines. #9527 describes the alternative and how to switch; this PR's MF-1 test holds under either rule.

Changeset

.changeset/lexical-y-composition-holdback.md: [fix] for @lexical/y, with a Verify: paragraph.

Test plan

New tests:

• packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts: one case per finding, Bug: [lexical-y] A remote insert into the composing line is shown mid-composition when the line was made by joining two lines #9492, S7-8, S7-9, S7-12, S7-15 and S7-28 in four shapes, and R-1 to R-4 from a review of this change (R-5 is in the block-id file).
• packages/lexical-y/src/__tests__/unit/CompositionHoldBack.test.ts (matrix in __tests__/utils/compositionHoldBack.ts): 6 line shapes x 13 remote changes x 9 ways the composition ends or the composer edits the line's structure x 2 client id orders. Each case checks that the line keeps its nodes while a change is held, that the composed node keeps its key, that every editor equals a fresh read with a quiet self-check, and that nothing a collaborator did is lost or stored twice. CompositionHoldBackBlockIds.test.ts runs part of it with BlockIdExtension.
• packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs: a peer presses Enter later in the line being composed (IME driven through CDP).

Before

On main (0cd7448):

$ ./node_modules/.bin/vitest --run --project unit packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts packages/lexical-y/src/__tests__/unit/CompositionHoldBack.test.ts packages/lexical-y/src/__tests__/unit/CompositionHoldBackBlockIds.test.ts
 ❯ |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts (40 tests | 32 failed) 1702ms
 ❯ |unit| packages/lexical-y/src/__tests__/unit/CompositionHoldBackBlockIds.test.ts (157 tests | 79 failed) 8308ms
 ❯ |unit| packages/lexical-y/src/__tests__/unit/CompositionHoldBack.test.ts (1404 tests | 802 failed) 59265ms
 Test Files  3 failed (3)
      Tests  913 failed | 688 passed (1601)

 FAIL  |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts > #9492: a remote insert into a line made by joining two lines, while composing > waits for the composition to end (insert at 1, ids 1,2)
AssertionError: expected 'aXYbc def ghiて' to be 'abc def ghiて' // Object.is equality

 FAIL  |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts > S7-8: a peer formats a word of a highlighted code line while A composes in it > A, B and a fresh read agree after the composition (completed, ids 1,2)
AssertionError: expected [ …(3) ] to deeply equal []
+   "self-check: line 94: format k at 5",
+   "self-check: line 94: format k at 5",

 FAIL  |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts > S7-9: a peer bolds or comments a word in the text node A composes in > the composed node keeps its text until the composition ends (bold, ids 1,2)
Expected: "alpha beta gamma に"
Received: "alpha "

 FAIL  |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts > S7-12: Enter while composing, after a peer typed in the composed line > the held word shows, and stays (Enter at the composition start, then the end, ids 1,2)
Expected: "paragraph() / paragraph("s1z s2z s3z ")"
Received: "paragraph() / paragraph("s1z skb5z 2z s3z ")"

 FAIL  |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts > S7-15: a peer presses Enter later in the line A composes in > the composed node keeps its key, text and line (ids 1,2)
AssertionError: expected 1 to be +0 // Object.is equality

 FAIL  |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts > S7-28: a peer pastes paragraphs into the composed line, then types in them > every word is stored once (one composition step, ids 1,2)
AssertionError: expected 2 to be 1 // Object.is equality

$ E2E_BROWSER=chromium E2E_EDITOR_MODE=rich-text-with-collab-y ./node_modules/.bin/playwright test --project=chromium --workers=1 --retries=0 --repeat-each=3 packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs -g 'Collab Y: IME'
  ✘   3 [chromium] › packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs:221:3 › Collab Y: IME › compose while a peer splits the line after the composition (12.6s)
  ✘   7 [chromium] › packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs:221:3 › Collab Y: IME › compose while a peer splits the line after the composition (12.5s)
  ✘  11 [chromium] › packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs:221:3 › Collab Y: IME › compose while a peer splits the line after the composition (13.3s)
    -   "paragraph:s1z s2z日本 s3z",
    +   "paragraph:s1z s2zにh日本 s3z",
  3 failed
  9 passed (2.9m)

After

$ ./node_modules/.bin/vitest --run --project unit packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts packages/lexical-y/src/__tests__/unit/CompositionHoldBack.test.ts packages/lexical-y/src/__tests__/unit/CompositionHoldBackBlockIds.test.ts
 ✓ |unit| packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts (40 tests) 2015ms
 ✓ |unit| packages/lexical-y/src/__tests__/unit/CompositionHoldBackBlockIds.test.ts (157 tests) 10015ms
 ✓ |unit| packages/lexical-y/src/__tests__/unit/CompositionHoldBack.test.ts (1404 tests) 73260ms
 Test Files  3 passed (3)
      Tests  1601 passed (1601)

$ ./node_modules/.bin/vitest --project unit --project scripts-unit --no-watch
 Test Files  563 passed | 3 skipped (566)
      Tests  16840 passed | 16 expected fail | 4 skipped (16860)

$ E2E_BROWSER=chromium E2E_EDITOR_MODE=rich-text-with-collab-y ./node_modules/.bin/playwright test --project=chromium packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs packages/lexical-playground/__tests__/e2e/Collaboration.spec.mjs packages/lexical-playground/__tests__/e2e/CollabYSync.spec.mjs packages/lexical-playground/__tests__/e2e/CollabYStructure.spec.mjs
  ✓  10 [chromium] › packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs:176:3 › Collab Y: IME › compose in a line while a peer types in the same line (14.3s)
  ✓  11 [chromium] › packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs:197:3 › Collab Y: IME › compose while a peer splits the line before the composition (13.5s)
  ✓  12 [chromium] › packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs:221:3 › Collab Y: IME › compose while a peer splits the line after the composition (13.4s)
  ✓  13 [chromium] › packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs:245:3 › Collab Y: IME › compose in a line while a peer joins it into the previous line (13.6s)
  32 passed (2.9m)

$ pnpm run ci-check
Changeset check passed: 5 pending changeset(s) valid.
Found 0 errors

Not exercised: the collab Y e2e specs in Firefox and WebKit (the IME specs drive the composition through CDP, so they run in Chromium only), and a manual check with a real IME.

After, stacked on #9504 (ac575d2b4)

$ ./node_modules/.bin/vitest --project unit --project scripts-unit --no-watch
 Test Files  564 passed | 3 skipped (567)
      Tests  17280 passed | 18 expected fail | 6 skipped (17304)

$ LEXICAL_Y_BLOCK_ID=1 ./node_modules/.bin/vitest --run --project unit packages/lexical-y/src/__tests__/unit/CompositionHoldBack.test.ts packages/lexical-y/src/__tests__/unit/regressions/Composition.test.ts
 Test Files  2 passed (2)
      Tests  1815 passed | 2 skipped (1817)

$ E2E_BROWSER=chromium E2E_EDITOR_MODE=rich-text-with-collab-y ./node_modules/.bin/playwright test --project=chromium packages/lexical-playground/__tests__/e2e/CollabYNodes.spec.mjs packages/lexical-playground/__tests__/e2e/Collaboration.spec.mjs packages/lexical-playground/__tests__/e2e/CollabYSync.spec.mjs packages/lexical-playground/__tests__/e2e/CollabYStructure.spec.mjs
  32 passed (2.6m)

$ pnpm run ci-check
Changeset check passed: 7 pending changeset(s) valid.
Found 0 errors

The #9504 test SchemaSkew.test.ts "releasing what a composition held back" now injects its reader failure into $apply on the composing client, because the release no longer calls $refreshComposed.

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated
lexical	Ready	Preview	Oct 29, 2026 7:52pm UTC
lexical-playground	Ready	Preview	Oct 29, 2026 7:52pm UTC

[pkg-pr-new]

lexical

npm i https://pkg.pr.new/lexical@9507

@lexical/a11y

npm i https://pkg.pr.new/@lexical/a11y@9507

@lexical/clipboard

npm i https://pkg.pr.new/@lexical/clipboard@9507

@lexical/code

npm i https://pkg.pr.new/@lexical/code@9507

@lexical/code-core

npm i https://pkg.pr.new/@lexical/code-core@9507

@lexical/code-prism

npm i https://pkg.pr.new/@lexical/code-prism@9507

@lexical/code-shiki

npm i https://pkg.pr.new/@lexical/code-shiki@9507

@lexical/compiler

npm i https://pkg.pr.new/@lexical/compiler@9507

@lexical/devtools-core

npm i https://pkg.pr.new/@lexical/devtools-core@9507

@lexical/dragon

npm i https://pkg.pr.new/@lexical/dragon@9507

@lexical/eslint-plugin

npm i https://pkg.pr.new/@lexical/eslint-plugin@9507

@lexical/extension

npm i https://pkg.pr.new/@lexical/extension@9507

@lexical/fast-check

npm i https://pkg.pr.new/@lexical/fast-check@9507

@lexical/file

npm i https://pkg.pr.new/@lexical/file@9507

@lexical/hashtag

npm i https://pkg.pr.new/@lexical/hashtag@9507

@lexical/headless

npm i https://pkg.pr.new/@lexical/headless@9507

@lexical/history

npm i https://pkg.pr.new/@lexical/history@9507

@lexical/html

npm i https://pkg.pr.new/@lexical/html@9507

@lexical/internal

npm i https://pkg.pr.new/@lexical/internal@9507

@lexical/link

npm i https://pkg.pr.new/@lexical/link@9507

@lexical/list

npm i https://pkg.pr.new/@lexical/list@9507

@lexical/mark

npm i https://pkg.pr.new/@lexical/mark@9507

@lexical/markdown

npm i https://pkg.pr.new/@lexical/markdown@9507

@lexical/mdast

npm i https://pkg.pr.new/@lexical/mdast@9507

@lexical/offset

npm i https://pkg.pr.new/@lexical/offset@9507

@lexical/overflow

npm i https://pkg.pr.new/@lexical/overflow@9507

@lexical/plain-text

npm i https://pkg.pr.new/@lexical/plain-text@9507

@lexical/react

npm i https://pkg.pr.new/@lexical/react@9507

@lexical/rich-text

npm i https://pkg.pr.new/@lexical/rich-text@9507

@lexical/selection

npm i https://pkg.pr.new/@lexical/selection@9507

@lexical/table

npm i https://pkg.pr.new/@lexical/table@9507

@lexical/tailwind

npm i https://pkg.pr.new/@lexical/tailwind@9507

@lexical/text

npm i https://pkg.pr.new/@lexical/text@9507

@lexical/utils

npm i https://pkg.pr.new/@lexical/utils@9507

@lexical/y

npm i https://pkg.pr.new/@lexical/y@9507

@lexical/yjs

npm i https://pkg.pr.new/@lexical/yjs@9507

commit: 005b397