[zurfyx]

Lands together with #9678 (D86, a delete keeps every format item it leaves): this PR is stacked on it and the two were gated as one landing tree, because #9678 alone is worse than main on one gc-on seed that this change fixes. It is retargeted to main so both land as one commit; #9678 is closed as landed here.

Stacked on #9678 (D86, no collapse): review only the top commit. The two land together, #9678 first (on its own #9678 is worse than main on one gc-on session that this PR fixes; see below).

Description

DECISIONS.md D88, DECIDED (10-31); D78 DECIDED (10-31).

With Yjs's default garbage collection, which products use, an undo could
not read the format items of its own change after a collaborator deleted
them: they were collected, so the undo guards (isKeptByUndo, changeEnd,
closeRestoredRuns) took them for other content, and the value an undo
brought back ran on over the rest of the document (#9623). The unit harness
built every peer with gc off, so most tests never saw it.

• Binding: the binding sets Yjs's own Item.keep on the format items its
  transactions and its undo manager's insert, and on the end of each run
  they delete. It releases them, between transactions, when both undo
  stacks are empty (after a clear, an undo that leaves nothing, or a write
  they did not capture), and when it is disposed or its document destroyed.
  Ownership is per listening lifetime and shared across bindings on one
  document; an item another binding or an UndoManager step also keeps
  stays kept. Releasing collects nothing, as the UndoManager collects
  nothing when it releases what its steps kept. Nothing new is written.
• Cursor#runOpener: a restore's scan stops at content of another client,
  so a client's earlier end and later opener with a collaborator's text
  between them are not one restored run (Bug: [lexical-y] Undoing your own formats spreads a format onto the next word after a collaborator typed plain text inside your first run #9599).
• Cursor rule 3: a range end that writes its own copy of another client's
  opener also ends it where that opener's run ended, so undoing that
  client's change leaves the text after the range alone.
• Cursor: a format write removes the null and the restore that this
  client's own earlier insert left inside its range, as Yjs's formatText
  does (Bug: [lexical-y] Undoing text you typed into a format run and then formatted takes the format off the untouched rest of the run when a collaborator typed after it, with no concurrent edits #9671).
• Docs: y.md's Limits gets "Deleted format items a client can undo" (D88's
  cost), and the [lexical-y] Bug Fix: A delete keeps every format item it leaves (D86) #9678 review follow-ups (the Bug: [lexical-y] A comment spreads onto later words when a client types plain text into it offline and a collaborator's delete drops the null that ended it #9564 entry, the edit cost of
  deleted formatted text).

The accepted cost (D88): a format item a collaborator deletes while
this client can still undo the change that wrote it keeps its deleted
content in this client's document, and in states this client encodes,
until the document reloads or a relay that loads its state with gc on
compacts it: about 25 bytes per such deletion, in this client only (100 /
1,000 / 3,000 rounds of one client bolding a word and another clearing it:
2,603 / 25,077 / 75,077 bytes vs 229 / 231 / 231 without this PR; realistic
sessions +0.6% to 0.8%). Collecting on release was tried and dropped: it
destroyed what another UndoManager on the same document still needed.

Tests:

• regressions/OwnFormatItems.test.ts: the Bug: [lexical-y] A comment comes back over the rest of the document when a collaborator undoes removing it after its author undid adding it #9623, Bug: [lexical-y] Undoing your own formats spreads a format onto the next word after a collaborator typed plain text inside your first run #9599 and Bug: [lexical-y] Undoing text you typed into a format run and then formatted takes the format off the untouched rest of the run when a collaborator typed after it, with no concurrent edits #9671 repros
  and a restated-opener case, gc on and off, every client id order.
• regressions/UndoSpreadSession2810.test.ts: a downstream app's
  undo-fuzz session where [lexical-y] Bug Fix: A delete keeps every format item it leaves (D86) #9678 alone, with gc on, put a comment on four
  paragraphs and main did not.
• regressions/OwnFormatItemsRelease.test.ts: the release (clears, an undo
  that empties both stacks, uncaptured writes, dispose, destroy, a restart,
  another binding's and an app UndoManager's undo after a release, also
  from inside that UndoManager's capture), repeated cycles, what a relay
  stores.
• Pins that now pass are plain tests: UndoRestoredRunEndExtents (117
  cells), UndoRestoredRunEnds (20; the D64 cells stay pinned),
  UndoSpreadFuzz (5 seeds; its documents use gc on, so it is the gc-on
  gate), UndoCommentRemovalSpread (4), RunSequenceUndo seed 87.
• The harness takes a gc option, and LEXICAL_Y_GC=1 runs every harness
  test with gc on.

Test plan

Landing tree: main cfcd3c4 + #9678 + this PR. Code identical from
3a66cb0 to d1807fb (the last commits change docs and one test). Every
property, fuzz and soak lane ran with gc on and off.

Before (#9678 alone; main where named)

• Three-client view property test, 15,000 seeds: 4 bad (gc off), 14 (gc
  on). Main: 492 / 511.
• Two-client undo-spread fuzz, 3,000 seeds, gc on: 221 spreading.
  Run-sequence fuzz, 1,000 seeds: 8. Comment-run fuzz, 500: 0.
• New tests: OwnFormatItems 44 of 72 fail; UndoSpreadSession2810 2 of 4
  fail (gc on; main passes); OwnFormatItemsRelease: n/a.
• Jot's undo-spread fuzz (gc on): plain 351 / 3,000, macro 433 / 2,000
  (main 350 / 433).

After

• View property test: 4 bad with gc off and with gc on; 0 seeds wrong
  where main or [lexical-y] Bug Fix: A delete keeps every format item it leaves (D86) #9678 is right, gc on and off (identical on every head
  since 9817eb6).
• Undo-spread fuzz 0 (gc on and off); run-sequence fuzz 0 (gc on and off);
  comment-run fuzz 0.
• pnpm run ci-check passes (d1807fb). Units, all packages, gc off and
  gc on: no failure that [lexical-y] Bug Fix: A delete keeps every format item it leaves (D86) #9678 does not have (gc on: the same F30A-1 cells;
  147 pins flip). MATRIX_FULL gc off and on: the same 11 legacy-binding
  failures.
• New tests: OwnFormatItems 72 pass, UndoSpreadSession2810 4 pass,
  OwnFormatItemsRelease 24 pass.
• Soak (L1B, L2 on identical op paths, gc off and on, against [lexical-y] Bug Fix: A delete keeps every format item it leaves (D86) #9678's
  tree): about 92,000 sessions across this PR's heads, 0 failing only here;
  L1C and L3: 0 only here.
• A downstream document library (lib, two apps, fuzz spike, settle probes)
  on local builds: identical to main. Corpus growth after 10 / 40 / 150
  cycles: format items x1.005 / x1.052 / x1.261, bytes x1.002 / x1.016 /
  x1.066 (main = 1).
• Jot (typecheck, lint, format, unit, e2e 146, fuzz 6,000 + 2,000):
  identical to main. Undo-spread fuzz: plain 0 / 3,000, macro 9 / 2,000
  (all 9 also fail on main and [lexical-y] Bug Fix: A delete keeps every format item it leaves (D86) #9678). Growth runs (long notes, 2k to 20k
  words, and a concentrated hot spot): no errors, divergence or fresh-read
  mismatch; bytes on long notes x0.97 to x1.00 of main, x1.05 to x1.18 at
  the concentrated hot spot (the retention above).
• Reviews: independent reviews (gpt-6.1-sol) over seven rounds on the keep
  lifecycle; the last (3a66cb0, code identical to this head) is clean.

[vercel]

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

Project	Deployment	Actions	Updated
lexical	Ready	Preview	Nov 1, 2026 12:12am UTC
lexical-playground	Ready	Preview	Nov 1, 2026 12:12am UTC

[meta-code-review]

AI review status for this pull request.

Review status	Updated
🟢 Reviewed (for maintainers only)	Nov 1, 2026, 12:38 AM UTC

[pkg-pr-new]

lexical

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

@lexical/a11y

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

@lexical/clipboard

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

@lexical/code

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

@lexical/code-core

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

@lexical/code-prism

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

@lexical/code-shiki

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

@lexical/compiler

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

@lexical/devtools-core

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

@lexical/dragon

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

@lexical/eslint-plugin

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

@lexical/extension

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

@lexical/fast-check

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

@lexical/file

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

@lexical/hashtag

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

@lexical/headless

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

@lexical/history

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

@lexical/html

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

@lexical/internal

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

@lexical/link

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

@lexical/list

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

@lexical/mark

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

@lexical/markdown

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

@lexical/mdast

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

@lexical/offset

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

@lexical/overflow

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

@lexical/plain-text

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

@lexical/react

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

@lexical/rich-text

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

@lexical/selection

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

@lexical/table

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

@lexical/tailwind

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

@lexical/text

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

@lexical/utils

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

@lexical/y

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

@lexical/yjs

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

commit: d1807fb

[meta-code-review]

This looks good to me. Keeping a client's own format items readable while it can still undo fixes #9623 under Yjs's default garbage collection, and the Cursor changes for #9599 and #9671 bring the binding closer to what Yjs's own formatText does. The new regression tests assert both peers and a fresh reader, and they cover both client id orders with gc on and off. The suggestions below are optional and non-blocking.

Optional suggestions

1. Guard the rule-3 copy end (packages/lexical-y/src/internal/Cursor.ts:1244-1249). The new code takes changeEnd(doc, next) and writes a null after it through insertAfter, which always uses this.parent (line 791). It never checks that the end is in the same Y.Node or to the right of the copy. restatedEnd (lines 767-777) gets that guarantee by walking right from the cursor. changeEnd is a clock-order guess, so a check such as end.parent === this.parent plus a rightward scan would keep a misidentified end from writing a null somewhere else. In the existing suites the end is always ahead in the same node, so this is hardening rather than a reproduced bug.
2. Document D88's local cost in y.md's Limits. packages/lexical-y/AGENTS.md asks for accepted limits to appear in y.md's Limits (packages/lexical-website/docs/collaboration/y.md) as well as DECISIONS.md. The new D88 row accepts that a client keeps the format items collaborators delete while it can undo, and that those items are in any state it encodes until it reloads. For example, after 100 rounds of one client bolding and another clearing formats, the first client's encoded state is 2,603 bytes against 229 for the second. One sentence next to "Deleted formatted text" would cover it. While there, "against 27 ms before" (line 1108) could say what "before" means.
3. Pin the gc-on failures of the new lane. With LEXICAL_Y_GC=1, three cells of regressions/Formats.test.ts F30A-1 ("italic over "b ", italic removed from "b"; the removal undone ‖ "b" italic again", ids 1,2,3 / 3,2,1 / 2,3,1) still fail. They also fail without this change, so this is not a regression. packages/lexical-y/AGENTS.md asks for a known failure to be a test.fails naming its issue, which would keep the lane usable.
4. Test plan output. AGENTS.md (Commits and Pull Requests) asks the Test plan for the real Before and After output of the commands run. The gate results are still "to be added", and the description does not mention OwnFormatItemsRelease.test.ts or UndoSpreadSession2810.test.ts.
5. Small test nit. In OwnFormatItemsRelease.test.ts, "an undo that changes nothing and empties both stacks releases them" calls undoManager.clear() after the undo (line 183), so the clear's own release would pass the test even without the undo path. Dropping that line makes the test check what its name says.

[meta-code-review]

Optional: changeEnd is a clock-order guess, and insertAfter below always uses this.parent (line 791). Unlike restatedEnd (lines 767-777), which finds its end by walking right from the cursor, nothing here checks that end is in this Y.Node and to the right of the copy. Something like end.parent === this.parent plus a rightward scan would keep a misidentified end (a later write of that client elsewhere) from getting a stray null.

[zurfyx]

Not taken in this PR: in every suite and fuzz run the copied opener's end is ahead of the copy in the same node, so this would be hardening without a failing case, and any change to where rule 5 writes its null needs the full property and soak gates again. Noted as a follow-up (a same-parent check plus a rightward scan, like restatedEnd).

[meta-code-review]

Optional: "before" could name what the 27 ms is measured against. This bullet's neighbourhood would also be a good place for D88's local cost, which packages/lexical-y/AGENTS.md asks to list under Limits: a client keeps the format items collaborators delete while it can undo the change that wrote them, and those items are in any state it encodes until it reloads.

[zurfyx]

Done in d1807fb: the 27 ms now says what it is measured against, and Limits has a "Deleted format items a client can undo" entry with D88's local cost (about 25 bytes each; 2,603 vs 229 bytes after 100 rounds; a gc-on server or relay drops them). D88 links to it.

[meta-code-review]

Nit: with this clear() the test passes through the stack-cleared release even if the undo path did not release. Without it the undo path does release (both stacks end empty and the kept items go to zero), so dropping this line makes the test check what its name says.

[zurfyx]

Done in d1807fb: the clear() is gone, so the cell passes only through the undo path (B removed the bold, so A's undo changes nothing and drops its step).

[meta-code-review]

Optional: with LEXICAL_Y_GC=1, three F30A-1 cells in regressions/Formats.test.ts still fail ("italic over "b " … "b" italic again", ids 1,2,3 / 3,2,1 / 2,3,1). They fail without this PR too, but packages/lexical-y/AGENTS.md asks for known failures to be test.fails naming an issue, which would keep this lane green.

[zurfyx]

Agreed it should be pinned; the F30A-1 gc-on failure has no issue yet and fails the same way on main. It goes into the test-only follow-up that re-points this package's test.fails markers (filed issue + exact-predicate pin under LEXICAL_Y_GC=1), so this PR stays scoped.

[meta-code-review]

This looks good to me. Keeping a client's own format items readable while it can still undo fixes #9623 under Yjs's default garbage collection, and the Cursor changes for #9599 and #9671 follow what Yjs's own formatText does. The new regression tests assert both peers and a fresh reader, in both client id orders with gc on and off, and they fail on the parent commit. The suggestions below are optional and non-blocking.

Optional suggestions

1. Release a container the UndoManager kept first (packages/lexical-y/src/internal/Binding.ts:1233-1237). An item that is already kept when the binding first keeps it is recorded as external (lines 1147-1151) and is never unkept on release (lines 1182-1184). When that earlier keeper is the binding's own UndoManager, its clear() unkeeps the item, this loop keeps it again, and it then stays kept until the document reloads. For example: delete a character inside a box container, then bold a word in it, then clear both stacks. The box's container item is still kept, and if a collaborator then deletes the box, this client's state is 267 bytes against the collaborator's 169; with the two steps in the other order both are 169. D88 says the binding releases what it kept once both stacks are empty. Marking the entry non-external before keeping it again fixes this, and the release and spread tests still pass:

   for (const it of kept) {
     if (!it.keep) {
       const entry = keepOwners.get(it);
       if (entry !== undefined) {
         entry.external = false;
       }
       it.keep = true;
     }
   }

2. Paste the Test plan's output. AGENTS.md (Commits and Pull Requests) asks for ### Before and ### After sections with the command and its real output. The plan currently says the gates are still running, and it leaves out OwnFormatItemsRelease.test.ts and UndoSpreadSession2810.test.ts.

3. Nit: D88's row in packages/lexical-y/DECISIONS.md gives the gcFilter alternative twice; one of the two sentences can go.

Thanks for agreeing to pin the three F30A-1 cells that fail with LEXICAL_Y_GC=1 (they fail the same way without this change) as test.fails with an issue, and for tracking the rule-3 copy-end guard as a follow-up.

[meta-code-review]

Optional: an item this binding first saw already kept is recorded as external (lines 1147-1151) and never unkept (lines 1182-1184). When the earlier keeper is this UndoManager, its clear() unkeeps the item, this loop keeps it again, and it stays kept until reload. Repro: delete a character inside a box container, bold a word in it, clear both stacks; the box's container item is still kept, and after a collaborator deletes the box this client's state is 267 bytes against 169 (169 for both with the steps swapped). Marking the entry non-external here fixes it:

for (const it of kept) {
  if (!it.keep) {
    const entry = keepOwners.get(it);
    if (entry !== undefined) {
      entry.external = false;
    }
    it.keep = true;
  }
}

[zurfyx]

Agreed, and thanks for the repro. It stays inside the in-session retention D88 accepts (a kept flag on a container until reload, in this client only), so I am not re-gating this PR for it; it goes into the next lexical-y follow-up together with the rule-3 copy-end guard, with your box-container case as its test.

[meta-code-review]

Nit: this row gives the gcFilter alternative twice ("Accepted over a stored change (a gcFilter keeping every format item ...)" and "A gcFilter keeping every format item fixed the same cases ..."); one of the two sentences can go.

[zurfyx]

Right, the second gcFilter sentence is redundant; trimmed in the same follow-up (docs only).