[zurfyx]

Description

The Limits section of the @lexical/y docs described some cases wrongly and left others out.

• Moves. The docs listed "turning a paragraph into a list inside a container" as an operation that moves content. That holds only for a paragraph that holds text, in a container that is not a shadow root: there $insertList replaces the whole container with the list, and the container's content moves into it, so text a collaborator types in it at the same time is lost and two concurrent conversions show it twice. In a table cell or another shadow root, the paragraph becomes a list item in place and keeps the typing, as at the root. The bullet now says so.
• Undo. Undoing the replacement of a block with a new one (replace without includeChildren) after a collaborator edited the new block brings the old block's text back and keeps their edit next to it. Text they typed there, or the text of a block they put in its place, shows after the old text (twice, where they put the same text back). This happens with one undo and no concurrency, so the "both undo" sentence did not cover it. The Undo bullet now does, and says that replace(node, true), which $setBlocksType uses, keeps the block's children, so undoing it keeps their text once (paragraph("Revenue grew by 4% in Q3.")).
• Undo of a format, typed text inside it. The Undo bullet said a collaborator's text typed inside a format's range keeps that format after it when it arrives "as you undo". It also happens when the undoing client saw that text first: bold one two, a collaborator types plain mid after one, undo the bold, and two stays bold (the collaborator's write restored the bold after mid; the undo removes only its own items). The bullet now says both, with that example. Races.test.ts AUDIT-U1 pins the concurrent case (a limit: the undoing client cannot see the restore), asserts today's result for the seen case, and has a test.fails for the seen case that passes once it is fixed (the undoing client holds the restore and can end the value past it).
• Undo: a comment or format running on (Bug: [lexical-y] A comment spreads onto later words when two collaborators undo text they typed inside it while a third deletes past its end #9575). Writes inside a comment or a format are undone (two collaborators' writes; with [lexical-y] Bug Fix: End a restored comment or format run with the writer's own null also where the writer opened the run itself #9562, also one client's two writes) while another client, which has not seen the undos, deletes text across its end. The delete collapses the deleted content at the end, keeping the writers' nulls but not the run's own end, and the undos remove those nulls, so the run carries on over the following words and into the next line. No text is lost. A rare race, accepted as a documented limit: the Undo bullet now says so, and Races.test.ts has Bug: [lexical-y] A comment spreads onto later words when two collaborators undo text they typed inside it while a third deletes past its end #9575's repro as a regular test of today's outcome plus a test.fails for the fix. Checked on main for a comment and for bold, and on [lexical-y] Bug Fix: End a restored comment or format run with the writer's own null also where the writer opened the run itself #9562's head for one client's two writes (its S9-12b).
• Undo: a collaborator's format after a run's end (Bug: [lexical-y] A collaborator's format that starts where your own format run ends is lost when you change part of that run at the same time #9589, Bug: [lexical-y] A restore inside a run whose format change has more than 64 items gets no end of its own, so the format spreads to the rest of the document #9603). A collaborator applies a format to text starting right where a run of that format ends, or from inside the run past its end (bolds bb, or lo bb, after the bold Kilo), while another client removes the format from part of the run (unbolds il) or types inside it without the format. Both put an item right after the run's end, Yjs orders them by client id, and with some orders the writer's null separates the collaborator's opener from its text, so bb stays plain on every peer. No text is lost, and when that client undoes its edit, bb is bold again. Accepted as a documented limit; the Undo bullet now says so. Checked in both id orders on main cad9015 and on main + [lexical-y] Bug Fix: End a restored comment or format run with the writer's own null also where the writer opened the run itself #9562 ac2c143: main loses the format only when the client writing inside the run is not the one that formatted it; with [lexical-y] Bug Fix: End a restored comment or format run with the writer's own null also where the writer opened the run itself #9562 also when it is ( bb plain with ids [2, 1]), for bb, lo bb, ilo bb and o bb cc; after the undo bb is bold everywhere. [lexical-y] Bug Fix: End a restored comment or format run with the writer's own null also where the writer opened the run itself #9562 pins its case.
• Nested lists of the same type in adjacent list items merge (Bug: [lexical-y] $insertList in a bound editor merges the new list into the previous nested list, unlike the same command without collaboration #9591). The document stores no identity for a nested list or its wrapper item, so two nested lists of the same type held by adjacent list items read back as one list, keeping the first list's start, and the bound editor keeps that shape. Turning a nested bullet list into a number list right after another item's nested number list therefore makes it part of that list in a bound editor (an editor without collaboration keeps them apart). Peers converge. Accepted as a documented limit: the paragraph on adjacent lists of the same type now says so, and Races.test.ts pins Bug: [lexical-y] $insertList in a bound editor merges the new list into the previous nested list, unlike the same command without collaboration #9591's repro as a test.fails (as a plain test it fails at the comparison after $insertList). Races.test.ts: 118 passed + 5 expected fail (123).
• Other races. A join (Backspace at the start of a line, or undoing a split) while a collaborator inserts or moves a block to the place of the join joins the line before to that block instead: its text becomes part of the block, which keeps its own type (a paragraph joined into a code block becomes code), and the line after stays apart: after a Backspace it takes the type of the line before (a paragraph after a heading becomes a heading), after undoing a split it keeps its own. This was not documented. Old main 0cd7448 behaves the same.
• Other races: typing inside a formatted range. The bullet said only that text typed at the start of a range a collaborator formats at the same time can take the format. Text typed inside the range always takes it, and text typed at its end can take it too, by the order Yjs gives the inserts (also when the range comes from an agent's older read). The bullet now says so.
• Moves: merging table cells. Merging cells moves the content of the cells merged away into the first cell, so what a collaborator types in a merged-away cell at the same time is lost. Not named before; the Moves bullet now lists it.
• Moves: undoing a wrap. When a move put a block into a container it made (wrapping a paragraph in a box) and a collaborator typed in it since, undoing the move keeps the container whole (as an undo keeps any container a collaborator put content in) and restores the block next to it, so its text shows twice. The Moves bullet now says so.

Each case gets a case in Races.test.ts, run in both client id orders with causal and per-sender delivery.

Test plan

Before

What the binding does, from probes on main (A converts, undoes or joins; B edits; then sync):

list conversion ‖ B types X at offset 1
CT root   | before paragraph("abc") | final list[bullet](listitem("aXbc"))
CT table  | before table(tablerow(tablecell(paragraph("abc")))) | final table(tablerow(tablecell(list[bullet](listitem("aXbc")))))
CT shadow | before test_col(test_col_title("t") test_col_content(paragraph("abc"))) | final test_col(test_col_title("t") test_col_content(list[bullet](listitem("aXbc"))))
CT box    | before test_box[b](paragraph("abc")) | final list[bullet](listitem("abc"))

A replaces block 1 with an equal paragraph; B edits it; A undoes
UR B types into it    | mid paragraph("top") / paragraph("oneX two") / paragraph("end") | final paragraph("top") / paragraph("one twoX") / paragraph("end")
UR B replaces again   | mid paragraph("top") / paragraph("one two") / paragraph("end") | final paragraph("top") / paragraph("one twoone two") / paragraph("end")

B undoes a split (or joins) ‖ A moves or inserts a block at the join point
S810 undo split       | before paragraph("t38z t") / paragraph("39z t40z") / paragraph("mid") / code("let x = 1") | final code("t38z tlet x = 1") / paragraph("39z t40z") / paragraph("mid")
S810 insert para ‖ join | before paragraph("t38z t") / paragraph("39z t40z") / paragraph("mid") / code("let x = 1") | final paragraph("t38z tnew para") / paragraph("39z t40z") / paragraph("mid") / code("let x = 1")

After

$ vitest --run --project unit --reporter=verbose packages/lexical-y/src/__tests__/unit/Races.test.ts -t "list in|undo of a block replacement|setBlocksType|inserted at a join|AUDIT-U1|9575"
 ✓ ... @lexical/y races, A=1 B=2 causal > list in a table cell ‖ type
 ✓ ... @lexical/y races, A=1 B=2 causal > list in a container that is not a shadow root ‖ type
 ✓ ... @lexical/y races, A=1 B=2 causal > undo of a block replacement after a collaborator edits the new block
 ✓ ... @lexical/y races, A=1 B=2 causal > undo of $setBlocksType after a collaborator edits the block
 ✓ ... @lexical/y races, A=1 B=2 causal > block inserted at a join ‖ Backspace join
 ✓ ... @lexical/y races, A=1 B=2 causal > block inserted at a join ‖ Backspace join of a heading and a paragraph
 ✓ ... @lexical/y races, A=1 B=2 causal > block inserted at a join ‖ undo of a split, the line after a heading
 (the same in A=2 B=1 causal, A=1 B=2 per-sender, A=2 B=1 per-sender)
 ✓ ... AUDIT-U1 arriving as the undo is made: the text after the typing keeps the format (1,2,3), (2,1,3)
 ✓ ... AUDIT-U1 seen before the undo: the text after the typing keeps the format (1,2,3), (2,1,3)
 ✓ ... AUDIT-U1 seen before the undo: the undo removes the format everywhere (1,2,3), (2,1,3) (test.fails)
 ✓ ... #9575 as documented: the comment runs on over the next words and line (1,2,3,4), (4,3,2,1)
 ✓ ... #9575: the comment ends where it ended (1,2,3,4), (4,3,2,1) (test.fails)
      Tests  38 passed | 4 expected fail | 80 skipped (122)

$ vitest --run --project unit packages/lexical-y/src/__tests__/unit/Races.test.ts
      Tests  118 passed | 5 expected fail (123)

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

[vercel]

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

Project	Deployment	Actions	Updated
lexical	Ready	Preview	Oct 30, 2026 6:32pm UTC
lexical-playground	Ready	Preview	Oct 30, 2026 6:32pm UTC

[meta-code-review]

AI review status for this pull request.

Review status	Updated
⏳ Queued (for maintainers only)	Oct 30, 2026, 6:32 PM UTC

[pkg-pr-new]

lexical

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

@lexical/a11y

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

@lexical/clipboard

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

@lexical/code

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

@lexical/code-core

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

@lexical/code-prism

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

@lexical/code-shiki

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

@lexical/compiler

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

@lexical/devtools-core

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

@lexical/dragon

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

@lexical/eslint-plugin

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

@lexical/extension

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

@lexical/fast-check

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

@lexical/file

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

@lexical/hashtag

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

@lexical/headless

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

@lexical/history

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

@lexical/html

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

@lexical/internal

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

@lexical/link

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

@lexical/list

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

@lexical/mark

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

@lexical/markdown

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

@lexical/mdast

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

@lexical/offset

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

@lexical/overflow

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

@lexical/plain-text

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

@lexical/react

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

@lexical/rich-text

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

@lexical/selection

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

@lexical/table

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

@lexical/tailwind

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

@lexical/text

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

@lexical/utils

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

@lexical/y

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

@lexical/yjs

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

commit: d8fb2ff

[meta-code-review]

Thanks for tightening the @lexical/y Limits section. The list-conversion clarification, merged cells, the wrap and replacement undos and the format-undo example all match what the binding does at the PR head, and each has a case in Races.test.ts. One sentence needs a fix, plus a few smaller suggestions.

1. Join race: "the line after stays as it was" does not hold when the two lines have different types (packages/lexical-website/docs/collaboration/y.md, lines 1019–1025)

After a Backspace join, the line after takes the type of the line before. Here is the new block inserted at a join ‖ Backspace join case with a heading before the paragraph; it passes in all four orders at the PR head:

{
  a: () => $block([0]).insertAfter($p('New.')),
  b: () => $selectIn([1], 0).deleteCharacter(true),
  expected: 'paragraph("Revenue grew 4%New.") / heading[h1](" in Q3.")',
  id: 'block inserted at a join ‖ Backspace join of a heading and a paragraph',
  init: () =>
    $getRoot().append(
      $createHeadingNode('h1').append($createTextNode('Revenue grew 4%')),
      $p(' in Q3.'),
    ),
},

in Q3. was a paragraph and ends up a heading. A paragraph before a heading turns the heading into a paragraph, and a code block moved to the join does the same (code("Titlelet x = 1") / heading[h1]("body")). That fits the page's own storage rule (How content is stored: a block that holds text is its text followed by a ¶ marker carrying its type): after the join the joined line ends at the line after's marker, and the join gives that marker the line before's type. Undoing a split keeps the line after's type, so only the Backspace form is affected. Suggested wording: "…, and the line after stays apart; after a Backspace it takes the type of the line before (a paragraph after a heading becomes a heading)." Adding the case above would pin it; the current case joins two paragraphs, so it cannot see either type claim.

2. Name the replace form the undo sentence covers (y.md, lines 957–961)

replace(node, true), which $setBlocksType calls, keeps the children and undoes without doubling anything: turn Revenue grew 4% in Q3. into a heading with $setBlocksType, let a collaborator type by , undo, and the result is paragraph("Revenue grew by 4% in Q3."). Wording such as "replacing a block with a new one (replace without includeChildren, …)" keeps readers who change block types that way from expecting doubled text.

3. Also assert the seen case of AUDIT-U1 (packages/lexical-y/src/__tests__/unit/Races.test.ts, line 491)

The test.fails passes for any outcome other than paragraph("one mid two"), a throw during setup included, so the documented " two stays bold" is not asserted for the seen case. It currently gives paragraph("one mid" " two"{1}) / paragraph("tail"), as the docs say; a regular test asserting that next to the test.fails keeps the limit pinned and still flags the fix.

4. Test plan. AGENTS.md (Commits and Pull Requests) asks for the real After output of the command run. The pasted run (Tests 88 passed (88)) predates the last three commits; at the head the file runs 104 tests (102 passed, 2 expected fail), including the merge-cells, box-wrap, format-inside and AUDIT-U1 cases.

No changeset is needed for website and test changes (CONTRIBUTING.md, Changesets).

[meta-code-review]

After a Backspace join of lines of different types the line after takes the type of the line before, so "stays as it was" holds only when both lines share a type. A heading Revenue grew 4% followed by a paragraph in Q3., joined while a collaborator inserts paragraph New. at the join, ends paragraph("Revenue grew 4%New.") / heading[h1](" in Q3.") in all four orders; undoing a split keeps the line after's type. Suggested: "…, and the line after stays apart; after a Backspace it takes the type of the line before (a paragraph after a heading becomes a heading)."

[zurfyx]

Fixed in 21194a3. The bullet now says the line after stays apart: after a Backspace it takes the type of the line before (a paragraph after a heading becomes a heading), after undoing a split it keeps its own. Your case is in Races.test.ts (block inserted at a join ‖ Backspace join of a heading and a paragraph, paragraph("Revenue grew 4%New.") / heading[h1](" in Q3.") in all four orders), with a second one for the undo form where a collaborator made the line after a heading (block inserted at a join ‖ undo of a split, the line after a heading: paragraph("Revenue grew 4%New.") / heading[h2](" in Q3.")).

[meta-code-review]

replace(node, true) (what $setBlocksType calls) keeps the children and undoes without doubling: a heading made with $setBlocksType, typed in by a collaborator and undone, gives paragraph("Revenue grew by 4% in Q3."). Consider naming the form: "replacing a block with a new one (replace without includeChildren, …)".

[zurfyx]

Done in 21194a3: the sentence names replace without includeChildren, and adds that replace(node, true), which $setBlocksType uses, keeps the block's children, so undoing it keeps the collaborator's text once. New case undo of $setBlocksType after a collaborator edits the block asserts paragraph("Revenue grew by 4% in Q3.") in all four orders.

[meta-code-review]

This passes for any outcome other than paragraph("one mid two"), so the documented " two stays bold" isn't asserted for the seen case. It currently gives paragraph("one mid" " two"{1}) / paragraph("tail"); a regular test asserting that, next to this one, would pin the limit while this one still flags the fix.

[zurfyx]

Added in 21194a3: AUDIT-U1 seen before the undo: the text after the typing keeps the format asserts paragraph("one mid" " two"{1}) / paragraph("tail") for both id orders, next to the test.fails, which still flags the fix.

[meta-code-review]

Thanks for the follow-up. The join-race sentence now says the line after takes the line before's type after a Backspace and keeps its own after undoing a split, the undo sentence names replace without includeChildren (with the $setBlocksType case beside it), and AUDIT-U1's seen case is asserted next to its test.fails. Each new sentence in the Limits section matches what @lexical/y does at the PR head, in both client-id orders with causal and per-sender delivery. Two optional suggestions:

1. The line after also takes the line before's alignment and indent (packages/lexical-website/docs/collaboration/y.md, lines 1026–1028)

After a Backspace, the line after takes the line before's whole block marker, not only its type. With a centered, indented heading before the paragraph, the paragraph becomes a centered, indented heading:

heading[h1, center, indent 1]("Revenue grew 4%") / paragraph(" in Q3.")
  A inserts paragraph("New.") after line 1 ‖ B: Backspace at the start of line 2
  → paragraph("Revenue grew 4%New.") / heading[h1, center, indent 1](" in Q3.")

A forward Delete at the end of line 1 gives the same result as the Backspace. That fits the page's own storage rule (How content is stored: the ¶ marker carries the block's type and fields). Suggested wording: "after a Backspace or Delete it takes the type, alignment and indent of the line before (a paragraph after a centered heading becomes a centered heading)".

2. Pin the two outcomes that have no case yet (packages/lexical-y/src/__tests__/unit/Races.test.ts)

Every other new sentence has a Documented (…) case. The move form of the join race ("a paragraph joined into a code block that way becomes code") holds today without one; this case passes in all four orders at the head (it needs $createCodeNode from @lexical/code):

{
  a: () => $block([0]).insertAfter($block([3])),
  b: () => $selectIn([1], 0).deleteCharacter(true),
  expected:
    'code("Titlelet x = 1") / heading[h1]("body") / paragraph("mid")',
  // Documented (Other races): the line before joins the moved block,
  // which keeps its own type.
  id: 'block moved to a join ‖ Backspace join',
  init: () =>
    $getRoot().append(
      $createHeadingNode('h1').append($createTextNode('Title')),
      $p('body'),
      $p('mid'),
      $createCodeNode().append($createTextNode('let x = 1')),
    ),
},

The same goes for "twice, where they put the same text back" (lines 960–962): replace one two with an equal paragraph, let B replace it again, undo, and the line reads one twoone two. Cases for both keep those sentences from drifting when the binding changes.

No changeset is needed for website and test changes (CONTRIBUTING.md, Changesets).

[meta-code-review]

Nit: the line after takes the line before's alignment and indent too, not only its type. With a centered, indented h1 before the paragraph, the race ends paragraph("Revenue grew 4%New.") / heading[h1, center, indent 1](" in Q3.") in all four orders, and a forward Delete at the end of line 1 does the same as the Backspace. Suggested: "after a Backspace or Delete it takes the type, alignment and indent of the line before (a paragraph after a centered heading becomes a centered heading)".

[meta-code-review]

Consider a fourth join case for the move form the docs describe ("a paragraph joined into a code block that way becomes code"): all three join cases here insert a new block. On heading("Title") / paragraph("body") / paragraph("mid") / code("let x = 1"), A's $block([0]).insertAfter($block([3])) ‖ B's Backspace at the start of body ends code("Titlelet x = 1") / heading[h1]("body") / paragraph("mid") in all four orders today.

[meta-code-review]

This looks good. The new Limits sentences in packages/lexical-website/docs/collaboration/y.md match what @lexical/y does at the PR head (the list conversion inside a container, merged cells, the wrap and replacement undos, the format undo, the join race, typing in a range formatted at the same time, and the #9575 run-on, which reproduces for a comment and for bold), and the new cases in Races.test.ts assert the document every peer and a fresh reader converge on. A few optional, non-blocking suggestions:

1. The one-client trigger for the run-on is ahead of main (packages/lexical-website/docs/collaboration/y.md, lines 979–980)

The sentence lists "(one client's two writes, or two clients' writes)". At the PR head, a single client typing X and Y inside the comment and undoing both, while D deletes ter and bb as in #9575, leaves the comment ending where it ended (aa |Kilome[c1]| cc dd / tail line), whether that client is the commenter or another one, for a comment and for bold, in both client id orders. The PR description also says this form needs #9562. Since the Merge order section says this PR documents main, consider "when several writes inside it, by more than one client, are undone", and letting #9562 add the one-client form when it lands.

2. The #9589 sentence fits Other races better than Undo (y.md, lines 982–987)

That race has no undo in it: an unbold or a plain write inside a run racing a collaborator's format that starts where the run ends. In the Limits list it is the sibling of "Bold ‖ bold on adjacent ranges of one line can leave part unformatted" under Other races, which is where someone whose collaborator's bold vanished would look.

3. Pin the #9589 limit the way #9575 is pinned (packages/lexical-y/src/__tests__/unit/Races.test.ts)

The PR description says each case gets a case in Races.test.ts; #9589 is the only new limit without one. Main shows it when another client bolded the run (B bolds Kilo, then A unbolds il while B bolds bb: with ids [2, 1, 3] bb ends plain on every peer, with [1, 2, 3] it keeps the bold). This passes today ($bold is the helper from #9589's repro; it needs $setSelection from lexical):

const $bold = (from: number, to: number) => () => {
  const selection = $selectIn([0], from, to);
  selection.format = (selection.anchor.getNode() as TextNode).getFormat();
  selection.formatText('bold');
  $setSelection(null);
};
for (const ids of [
  [1, 2, 3],
  [2, 1, 3],
]) {
  test(`#9589 as documented: a collaborator's bold where its own run ends (${ids})`, async () => {
    const t = await setup(
      () => $getRoot().append($p('aa Kilo bb cc'), $p('tail line')),
      {ids},
    );
    t.b.update($bold(3, 7)); // B bolds "Kilo"
    await t.sync();
    t.offline();
    t.a.update($bold(4, 6)); // A unbolds "il"
    t.b.update($bold(7, 10)); // B bolds " bb"
    await t.sync();
    await expectConverged(t.peers);
    expect(t.a.describe()).toBe(
      ids[0] === 2
        ? 'paragraph("aa " "K"{1} "il" "o"{1} " bb cc") / paragraph("tail line")'
        : 'paragraph("aa " "K"{1} "il" "o bb"{1} " cc") / paragraph("tail line")',
    );
  });
}

The #9575 block could also run once with bold over Kilometer, since the sentence says "a comment or format" and bold runs on the same way (aa |Kilome cc dd[b] / tail line[b]).

The earlier optional notes still stand: after a raced Backspace join the line after also takes the line before's alignment and indent (lines 1036–1037), and the code-block move form of the join race and the "twice, where they put the same text back" outcome have no case yet.

No changeset is needed for website and test changes (CONTRIBUTING.md, Changesets).

[meta-code-review]

Optional: the one-client form doesn't happen at this revision. With #9575's steps but one client typing X and Y inside the comment and undoing both (while D deletes ter and bb), the comment ends where it ended, aa |Kilome[c1]| cc dd / tail line, whether that client is the commenter or another one, for a comment and for bold, in both client id orders; the PR description also says this form needs #9562. Since this PR documents main, consider "when several writes inside it, by more than one client, are undone", and letting #9562 add the one-client form.

[meta-code-review]

Optional: this race has no undo in it (an unbold or a plain write inside the run racing a collaborator's format that starts where the run ends), so it fits Other races, next to "Bold ‖ bold on adjacent ranges of one line can leave part unformatted", better than the Undo bullet.

[meta-code-review]

Optional: the #9589 sentence in y.md is the only new limit without a case here. Main shows it when another client bolded the run (B bolds Kilo; A unbolds il while B bolds bb): bb ends plain on every peer with ids [2, 1, 3] and keeps the bold with [1, 2, 3]. The review comment has a case for it that passes today.

[meta-code-review]

This looks good. The new Limits sentences in packages/lexical-website/docs/collaboration/y.md match what @lexical/y does at this head (the list conversion inside a container that is not a shadow root, merged cells, the wrap and $setBlocksType undos, the format undo after a collaborator's plain typing, the #9575 run-on for a comment and for bold, the #9591 nested-list merge and the join race), and the new Races.test.ts cases assert the document every peer and a fresh reader converge on. A few optional, non-blocking suggestions:

1. The one-client run-on trigger is ahead of main (y.md:982-983). With #9575's steps, one client's two writes inside the comment (its own comment or another client's), undone while D deletes ter and bb, leave the comment ending after Kilome, and so do two clients writing once each; it runs on with three writes by two clients (as in #9575) or one write each by three clients. Since the one-client form comes with #9562, consider "when several writes inside it, by more than one client, are undone", and letting #9562 add the rest when it lands.

2. What doubles on undo is new content, not the missing flag (y.md:960-966). A replace without includeChildren that first moves the old text nodes into the new block (h.append(...p.getChildren()); p.replace(h), as $wrapNodes does) undoes after a collaborator types by to paragraph("Revenue grew by 4% in Q3."), the text once, like replace(h, true); only a new block holding a new text node gives paragraph("Revenue grew 4% in Q3.by "). Consider: "Undoing the replacement of a block with a new one holding new content (not the old block's children, which replace(node, true) and $setBlocksType keep) …".

3. Pin #9591's merged shape (Races.test.ts:672). The test.fails passes for any difference between the two editors after $insertList, or a throw. A regular test next to it asserting today's shape (the converted list inside the previous item's nested number list, keeping its start of 0), as the AUDIT-U1 and #9575 blocks do, would pin what y.md:601-604 documents.

4. Earlier suggestions that still apply at this head: the run-end format sentence (y.md:985-992) has no case on main, where it reproduces when another client bolded the run ( bb ends plain whenever the bolding client's id is lower than the writer's, and is bold again after the writer's undo); the line after a raced join also takes the line before's alignment and indent, and a forward Delete at the end of the line before joins the same way (y.md:1041); and the move form of the join race has no case.

[meta-code-review]

Optional: what doubles on undo is new content rather than the missing flag. A replace without includeChildren that first moves the old text nodes into the new block (h.append(...p.getChildren()); p.replace(h), as $wrapNodes does) undoes after a collaborator types by to paragraph("Revenue grew by 4% in Q3."), the text once, the same as replace(h, true); only a new block holding a new text node gives paragraph("Revenue grew 4% in Q3.by "). Suggested: "Undoing the replacement of a block with a new one holding new content (not the old block's children, which replace(node, true) and $setBlocksType keep) …".

[meta-code-review]

Optional: this test.fails passes for any difference between the two editors after $insertList, or a throw, so it does not pin the merged shape y.md now documents. Today the bound editor, and a fresh bound reader of the doc, show the converted list inside the previous item's nested number list with that list's start: list[number,1](listitem(list[check,99](listitem(list[number,0](listitem() listitem("t5043z")))))). A regular test asserting that next to this one, as the AUDIT-U1 and #9575 blocks do, would pin the limit while this one still flags the fix.