diff --git a/.changeset/lexical-y-own-run-restore-end.md b/.changeset/lexical-y-own-run-restore-end.md
new file mode 100644
index 00000000000..e16bf3d5497
--- /dev/null
+++ b/.changeset/lexical-y-own-run-restore-end.md
@@ -0,0 +1,7 @@
+---
+'@lexical/y': patch
+---
+
+[fix] A comment (or format) no longer spreads over the rest of the document when its author types unformatted text inside it while a collaborator's delete drops the comment's end
+
+Verify: comment a word, then, offline, type uncommented text inside it while a collaborator deletes the word and text next to it; after the client reconnects, the words after it stay uncommented on every client.
diff --git a/packages/lexical-y/src/__tests__/unit/OwnRunRestoreEnd.test.ts b/packages/lexical-y/src/__tests__/unit/OwnRunRestoreEnd.test.ts
new file mode 100644
index 00000000000..478e8aeba4a
--- /dev/null
+++ b/packages/lexical-y/src/__tests__/unit/OwnRunRestoreEnd.test.ts
@@ -0,0 +1,600 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+// @vitest-environment node
+
+import type {Item} from '@y/y';
+
+import {$addMarkID, $getNodeMarkIDs} from '@lexical/mark';
+import {ContentFormat} from '@y/y';
+import {
+  $createTextNode,
+  $getRoot,
+  $isTextNode,
+  $setSelection,
+  type LexicalNode,
+  type TextNode,
+} from 'lexical';
+import {describe, expect, test} from 'vitest';
+
+import {
+  $block,
+  $p,
+  $selectIn,
+  expectConverged,
+  type Peer,
+  setup,
+} from '../utils/harness';
+import {prepareMarkState as prepare} from '../utils/sizeOps';
+
+// A client types uncommented text inside a word it commented itself, so its
+// write restores the comment after that text and relies on the comment's own
+// end (the null its comment wrote after the word) to end it. A collaborator
+// that has not seen that text deletes the word and then deletes the
+// comment's opener and end there, which for it bracket deleted content only,
+// so deleting them changes nothing it shows. That second step is simulated
+// with raw Yjs deletes (dropCommentItems): it stands for any concurrent
+// deletion of that end, such as the bounded collapse a delete next to a run
+// of deleted content runs (Cursor#collapseGap, which keeps a bounded number
+// of the format items there), and isolates the condition this guards: the
+// restore's run losing the end it relied on. Merged, the restore must still
+// end where the comment ended, not run on over the rest of the document.
+
+/** Each word of `peer`'s first line, with its comment ids. */
+function words(peer: Peer): string {
+  return peer.read(() =>
+    ($block([0]).getAllTextNodes() as TextNode[])
+      .flatMap(n => {
+        const ids = $getNodeMarkIDs(n as LexicalNode);
+        return n
+          .getTextContent()
+          .split(' ')
+          .filter(w => w !== '')
+          .map(w => (ids.length > 0 ? `${w}[${ids.join(',')}]` : w));
+      })
+      .join(' '),
+  );
+}
+
+/** Delete `peer`'s live format items of comment `id` with raw Yjs deletes. */
+function dropCommentItems(peer: Peer, id: string) {
+  const doc = peer.doc;
+  doc.transact(tr => {
+    const walk = (type: {_start: Item | null}) => {
+      for (let it = type._start; it !== null; it = it.right) {
+        if (
+          !it.deleted &&
+          it.content instanceof ContentFormat &&
+          it.content.key.endsWith(id)
+        ) {
+          it.delete(tr);
+        }
+        const content = it.content as {type?: {_start?: Item | null}};
+        if (content.type !== undefined && content.type._start !== undefined) {
+          walk(content.type as {_start: Item | null});
+        }
+      }
+    };
+    walk(doc.get('lexical-y') as unknown as {_start: Item | null});
+  });
+}
+
+/**
+ * Delete `peer`'s first live bold opener of its first line and the next
+ * live bold item after it (that run's end) with raw Yjs deletes, as
+ * dropCommentItems does for a comment.
+ */
+function dropFirstBoldRun(peer: Peer) {
+  const doc = peer.doc;
+  doc.transact(tr => {
+    const root = doc.get('lexical-y') as unknown as {_start: Item | null};
+    let opener: Item | null = null;
+    for (let it = root._start; it !== null; it = it.right) {
+      if (
+        it.deleted ||
+        !(it.content instanceof ContentFormat) ||
+        it.content.key !== 'f:bold'
+      ) {
+        continue;
+      }
+      if (opener === null) {
+        if (it.content.value === true) {
+          opener = it;
+        }
+      } else {
+        opener.delete(tr);
+        it.delete(tr);
+        return;
+      }
+    }
+  });
+}
+
+/** Whether each text node of `peer` holding text after "lo" is bold. */
+function boldAfterLo(peer: Peer): string {
+  return peer.read(() => {
+    const out: string[] = [];
+    let seen = false;
+    for (const n of $getRoot().getAllTextNodes() as TextNode[]) {
+      if (seen) {
+        out.push(`${n.getTextContent()}${n.hasFormat('bold') ? '*' : ''}`);
+      }
+      if (n.getTextContent().endsWith('lo')) {
+        seen = true;
+      }
+    }
+    return out.join('|');
+  });
+}
+
+/** Bold the first line from `from` to `to`. */
+const $boldIn = (from: number, to: number) => () => {
+  const selection = $selectIn([0], from, to);
+  selection.format = (selection.anchor.getNode() as TextNode).getFormat();
+  selection.formatText('bold');
+  $setSelection(null);
+};
+
+/** In `peer`'s first line, insert uncommented `text` at offset `off`. */
+function $insertPlainAt(off: number, text: string) {
+  for (const node of $block([0]).getAllTextNodes() as TextNode[]) {
+    if (off > 0 && off < node.getTextContentSize()) {
+      const [, tail] = node.splitText(off);
+      tail.insertBefore($createTextNode(text));
+      return;
+    }
+    off -= node.getTextContentSize();
+  }
+  throw new Error(`no text node holds offset ${off} inside it`);
+}
+
+describe('@lexical/y a restore of a comment its own client opened', () => {
+  for (const ids of [
+    [1, 2],
+    [2, 1],
+  ]) {
+    test(`ends where the comment ended when a collaborator's delete drops the comment's end (ids ${ids})`, async () => {
+      const t = await setup(
+        () => $getRoot().append($p('aa Kilo bb cc'), $p('tail line')),
+        {ids, prepare},
+      );
+      t.a.update(() => void $addMarkID('c1', $selectIn([0], 3, 7)));
+      await t.sync();
+      expect(words(t.a)).toBe('aa Kilo[c1] bb cc');
+      t.offline();
+      // A types uncommented "X" inside its own commented word
+      t.a.update(() => {
+        const node = ($block([0]).getAllTextNodes() as TextNode[]).find(n =>
+          n.getTextContent().startsWith('Kilo'),
+        )!;
+        const [, tail] = node.splitText(2);
+        tail.insertBefore($createTextNode('X'));
+      });
+      expect(words(t.a)).toBe('aa Ki[c1] X lo[c1] bb cc');
+      // B deletes the word, then drops the comment's items around it
+      t.b.update(() => void $selectIn([0], 3, 8).removeText());
+      dropCommentItems(t.b, 'c1');
+      expect(words(t.b)).toBe('aa bb cc');
+      await t.sync();
+      await expectConverged(t.peers);
+      // A's "X" is uncommented, and so is everything after it
+      expect(words(t.a)).toBe('aa Xbb cc');
+      expect(
+        t.a.read(() =>
+          ($block([1]).getAllTextNodes() as TextNode[]).some(
+            n => $getNodeMarkIDs(n).length > 0,
+          ),
+        ),
+      ).toBe(false);
+    });
+    // Pinned, as on main: the comment's run here ends with the end its
+    // restore after the uncommented text wrote, not with the end of the
+    // write that opened it, which is all rule 5 follows (see runOpener).
+    test.fails(
+      `ends where the comment ended when the comment was written with a hole in it (ids ${ids})`,
+      async () => {
+        const t = await setup(
+          () => $getRoot().append($p('aa Kilo bb cc'), $p('tail line')),
+          {ids, prepare},
+        );
+        // One write: the comment, with uncommented "X" inside it, so the
+        // comment's end ends the run its restore after "X" opens
+        t.a.update(() => {
+          $addMarkID('c1', $selectIn([0], 3, 7));
+          const node = ($block([0]).getAllTextNodes() as TextNode[]).find(n =>
+            n.getTextContent().startsWith('Kilo'),
+          )!;
+          const [, tail] = node.splitText(2);
+          tail.insertBefore($createTextNode('X'));
+        });
+        await t.sync();
+        expect(words(t.a)).toBe('aa Ki[c1] X lo[c1] bb cc');
+        t.offline();
+        // A types uncommented "Y" inside "lo"
+        t.a.update(() => {
+          const node = ($block([0]).getAllTextNodes() as TextNode[]).find(
+            n => n.getTextContent() === 'lo',
+          )!;
+          const [, tail] = node.splitText(1);
+          tail.insertBefore($createTextNode('Y'));
+        });
+        expect(words(t.a)).toBe('aa Ki[c1] X l[c1] Y o[c1] bb cc');
+        t.b.update(() => void $selectIn([0], 3, 9).removeText());
+        dropCommentItems(t.b, 'c1');
+        expect(words(t.b)).toBe('aa bb cc');
+        await t.sync();
+        await expectConverged(t.peers);
+        expect(words(t.a)).toBe('aa Ybb cc');
+      },
+    );
+    // S9-12: one write of A types uncommented text at two places inside A's
+    // own comment, so both of its restores end at the comment's end. Rule 5
+    // gives that end one null of A's own (not one per restore: the undo
+    // removes them together, and a second one would push the comment's end
+    // out of the last items a collaborator's collapse keeps). A undoes the
+    // write while B, which has not seen the undo, deletes the rest of the
+    // comment and then the text after it.
+    test(`S9-12: ends where the comment ended when its author undoes a write with two inserts inside it while a collaborator deletes past its end (ids ${ids})`, async () => {
+      const t = await setup(
+        () => $getRoot().append($p('aa Kilometer bb cc dd'), $p('tail line')),
+        {ids, prepare},
+      );
+      t.a.update(() => void $addMarkID('c1', $selectIn([0], 3, 12)));
+      await t.sync();
+      t.a.update(() => {
+        $insertPlainAt(9, 'Y');
+        $insertPlainAt(6, 'X');
+      });
+      await t.sync();
+      expect(words(t.a)).toBe('aa Kil[c1] X ome[c1] Y ter[c1] bb cc dd');
+      t.offline();
+      t.a.undo();
+      expect(words(t.a)).toBe('aa Kilometer[c1] bb cc dd');
+      // B deletes "ter", then " bb"
+      t.b.update(() => void $selectIn([0], 11, 14).removeText());
+      t.b.update(() => void $selectIn([0], 11, 14).removeText());
+      expect(words(t.b)).toBe('aa Kil[c1] X ome[c1] Y cc dd');
+      await t.sync();
+      await expectConverged(t.peers);
+      expect(words(t.a)).toBe('aa Kilome[c1] cc dd');
+      expect(
+        t.a.read(() =>
+          ($block([1]).getAllTextNodes() as TextNode[]).some(
+            n => $getNodeMarkIDs(n).length > 0,
+          ),
+        ),
+      ).toBe(false);
+    });
+    // S9-12b, pinned as failing: as S9-12, but A types "X" and "Y" in two
+    // writes, so each write puts a null of A's own right after the comment's
+    // end. B's collapse keeps those two nulls (a key's last items) and drops
+    // the end, and A undoes both writes: the comment runs on. Main passes
+    // (it writes no null of A's own for A's own run). One own null per end
+    // across writes would leave a restore without its own end when only the
+    // earlier write is undone, so this needs provenance or another collapse
+    // rule.
+    test.fails(
+      `S9-12b: ends where the comment ended when its author undoes two writes inside it while a collaborator deletes past its end (ids ${ids})`,
+      async () => {
+        const t = await setup(
+          () => $getRoot().append($p('aa Kilometer bb cc dd'), $p('tail line')),
+          {ids, prepare},
+        );
+        t.a.update(() => void $addMarkID('c1', $selectIn([0], 3, 12)));
+        await t.sync();
+        t.a.update(() => $insertPlainAt(6, 'X'));
+        t.a.update(() => $insertPlainAt(10, 'Y'));
+        await t.sync();
+        expect(words(t.a)).toBe('aa Kil[c1] X ome[c1] Y ter[c1] bb cc dd');
+        t.offline();
+        t.a.undo();
+        t.a.undo();
+        expect(words(t.a)).toBe('aa Kilometer[c1] bb cc dd');
+        t.b.update(() => void $selectIn([0], 11, 14).removeText());
+        t.b.update(() => void $selectIn([0], 11, 14).removeText());
+        expect(words(t.b)).toBe('aa Kil[c1] X ome[c1] Y cc dd');
+        await t.sync();
+        await expectConverged(t.peers);
+        expect(words(t.a)).toBe('aa Kilome[c1] cc dd');
+      },
+    );
+    test(`a restore in another client's run keeps its end after that client wrote the value again (ids ${ids})`, async () => {
+      // B bolds "Kilo", types plain text, bolds "cc", then undoes all three,
+      // while A types plain "X" inside "Kilo": the scan from B's end of
+      // "Kilo" passes B's later text and finds B's later bold opener, which
+      // is not right after that text and opens no hole.
+      const t = await setup(
+        () => $getRoot().append($p('aa Kilo bb cc dd'), $p('tail line')),
+        {ids, prepare},
+      );
+      t.b.update($boldIn(3, 7));
+      await t.sync();
+      t.b.update(() => $insertPlainAt(10, ' zz'));
+      await t.sync();
+      t.b.update($boldIn(14, 16));
+      await t.sync();
+      t.offline();
+      t.b.undo();
+      t.b.undo();
+      t.b.undo();
+      t.a.update(() => $insertPlainAt(5, 'X'));
+      await t.sync();
+      await expectConverged(t.peers);
+      expect(t.a.describe()).toBe(
+        'paragraph("aa KiX" "lo"{1} " bb cc dd") / paragraph("tail line")',
+      );
+    });
+    test(`a restore in another client's run keeps its end when that run's items are dropped after its client wrote the value again (ids ${ids})`, async () => {
+      // As above without the undos: B's bold opener and end of "Kilo" are
+      // dropped while A types plain "X" inside it.
+      const t = await setup(
+        () => $getRoot().append($p('aa Kilo bb cc dd'), $p('tail line')),
+        {ids, prepare},
+      );
+      t.b.update($boldIn(3, 7));
+      await t.sync();
+      t.b.update(() => $insertPlainAt(10, ' zz'));
+      await t.sync();
+      t.b.update($boldIn(14, 16));
+      await t.sync();
+      t.offline();
+      t.a.update(() => $insertPlainAt(5, 'X'));
+      dropFirstBoldRun(t.b);
+      await t.sync();
+      await expectConverged(t.peers);
+      expect(boldAfterLo(t.a)).toBe(' bb zz |cc*| dd|tail line');
+    });
+    test(`a restore of a run its own client opened keeps its end after that client wrote the value again (ids ${ids})`, async () => {
+      // A bolds "Kilo", types plain text, bolds "cc", then types plain "X"
+      // inside "Kilo" while B drops the bold opener and end of "Kilo".
+      const t = await setup(
+        () => $getRoot().append($p('aa Kilo bb cc dd'), $p('tail line')),
+        {ids, prepare},
+      );
+      t.a.update($boldIn(3, 7));
+      await t.sync();
+      t.a.update(() => $insertPlainAt(10, ' zz'));
+      await t.sync();
+      t.a.update($boldIn(14, 16));
+      await t.sync();
+      t.offline();
+      t.a.update(() => $insertPlainAt(5, 'X'));
+      dropFirstBoldRun(t.b);
+      await t.sync();
+      await expectConverged(t.peers);
+      expect(boldAfterLo(t.a)).toBe(' bb zz |cc*| dd|tail line');
+    });
+    // Pinned, as on main: with 64 comment ids the undo of Z still removes
+    // the comments from the untouched "et" (rule 5 writes no null for a
+    // restore in this run, see runOpener; the one comment id case passes).
+    test.fails(
+      `a later write's hole is not a run end with 64 comments on the run (ids ${ids})`,
+      async () => {
+        // Each write puts a null and a restore per comment id.
+        const t = await setup(
+          () => $getRoot().append($p('aa Kilometer bb cc'), $p('tail line')),
+          {ids, prepare},
+        );
+        const marks = Array.from({length: 64}, (_, i) => `m${i}`);
+        t.a.update(() => {
+          const selection = $selectIn([0], 3, 12);
+          for (const id of marks) {
+            $addMarkID(id, selection);
+          }
+        });
+        await t.sync();
+        t.b.update(() => $insertPlainAt(10, 'Y'));
+        await t.sync();
+        t.a.update(() => $insertPlainAt(6, 'X'));
+        await t.sync();
+        t.a.update(() => $insertPlainAt(9, 'Z'));
+        await t.sync();
+        t.b.update(() => $insertPlainAt(8, 'Q'));
+        await t.sync();
+        t.a.undo();
+        await t.sync();
+        await expectConverged(t.peers);
+        expect(
+          t.a.read(() =>
+            ($block([0]).getAllTextNodes() as TextNode[])
+              .map(n => `${n.getTextContent()}:${$getNodeMarkIDs(n).length}`)
+              .join('|'),
+          ),
+        ).toBe('aa :0|Kil:64|X:0|o:64|Q:0|met:64|Y:0|er:64| bb cc:0');
+      },
+    );
+    for (const value of ['comment', 'bold'] as const) {
+      test(`a later write's hole is not a run end (${value}, ids ${ids})`, async () => {
+        // A's second write inside its own run ("Z") opens a hole with a
+        // null of A's; B's restore in front of that hole must not take that
+        // null for the run's end (it is followed by A's text and A's
+        // restore of the run's value), or A's undo of "Z" leaves B's null
+        // ending the run early.
+        const t = await setup(
+          () => $getRoot().append($p('aa Kilometer bb cc'), $p('tail line')),
+          {ids, prepare},
+        );
+        const shown = (peer: Peer) =>
+          value === 'comment'
+            ? words(peer)
+            : peer.read(() =>
+                ($block([0]).getAllTextNodes() as TextNode[])
+                  .map(
+                    n => n.getTextContent() + (n.hasFormat('bold') ? '*' : ''),
+                  )
+                  .join('|'),
+              );
+        t.a.update(() => {
+          const selection = $selectIn([0], 3, 12);
+          if (value === 'comment') {
+            $addMarkID('c1', selection);
+          } else {
+            selection.formatText('bold');
+          }
+        });
+        await t.sync();
+        t.b.update(() => $insertPlainAt(10, 'Y'));
+        await t.sync();
+        t.a.update(() => $insertPlainAt(6, 'X'));
+        await t.sync();
+        t.a.update(() => $insertPlainAt(9, 'Z'));
+        await t.sync();
+        t.b.update(() => $insertPlainAt(8, 'Q'));
+        await t.sync();
+        t.a.undo();
+        await t.sync();
+        await expectConverged(t.peers);
+        expect(shown(t.a)).toBe(
+          value === 'comment'
+            ? 'aa Kil[c1] X o[c1] Q met[c1] Y er[c1] bb cc'
+            : 'aa |Kil*|X|o*|Q|met*|Y|er*| bb cc',
+        );
+      });
+    }
+    // A unbolds part of its own bold run while B bolds text starting at the
+    // run's end: A's own-run null and B's opener share their origins, and
+    // with A's id higher Yjs puts the null between B's opener and its text,
+    // so " bb" ends plain for ids [2, 1] (main keeps it bold there). A
+    // documented limit, tracked in #9589.
+    (ids[0] === 2 ? test.fails : test)(
+      `keeps a collaborator's bold that starts where the author's bold ends (ids ${ids})`,
+      async () => {
+        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);
+        };
+        const t = await setup(
+          () => $getRoot().append($p('aa Kilo bb cc'), $p('tail line')),
+          {ids, prepare},
+        );
+        t.a.update($bold(3, 7));
+        await t.sync();
+        t.offline();
+        t.a.update($bold(4, 6));
+        t.b.update($bold(7, 10));
+        await t.sync();
+        await expectConverged(t.peers);
+        expect(t.a.describe()).toContain('"o bb"{1}');
+      },
+    );
+    // The same tie when the author types plain text inside its own bold run
+    // while B bolds from inside that run past its end: A's own-run null after
+    // the run's end and B's opener there share their origins, so with A's id
+    // higher B's bold on " bb cc" is lost on every client (main keeps it; it
+    // comes back if A undoes its typing). Documented with #9589.
+    (ids[0] === 2 ? test.fails : test)(
+      `keeps a collaborator's bold that runs past the end of the author's bold while the author types inside it (ids ${ids})`,
+      async () => {
+        const $boldAll = (from: number, to: number) => () => {
+          for (const n of $selectIn([0], from, to).extract()) {
+            if ($isTextNode(n) && !n.hasFormat('bold')) {
+              n.toggleFormat('bold');
+            }
+          }
+          $setSelection(null);
+        };
+        const t = await setup(
+          () => $getRoot().append($p('aa Kilo bb cc dd'), $p('tail line')),
+          {ids, prepare},
+        );
+        t.a.update($boldAll(3, 7));
+        await t.sync();
+        t.offline();
+        t.a.update(() => $insertPlainAt(5, 'X'));
+        t.b.update($boldAll(5, 13));
+        await t.sync();
+        await expectConverged(t.peers);
+        const shownBold = t.a.read(() =>
+          ($block([0]).getAllTextNodes() as TextNode[])
+            .map(n =>
+              n.hasFormat('bold')
+                ? `[${n.getTextContent()}]`
+                : n.getTextContent(),
+            )
+            .join(''),
+        );
+        expect(shownBold).toBe('aa [Ki]X[lo bb cc] dd');
+      },
+    );
+  }
+});
+
+/** Deletes every format item of `peer`'s document whose key names one of `ids`. */
+function dropMarkItems(peer: Peer, ids: readonly string[]): void {
+  peer.doc.transact(tr => {
+    const walk = (type: {_start: Item | null}) => {
+      for (let it = type._start; it !== null; it = it.right) {
+        if (
+          !it.deleted &&
+          it.content instanceof ContentFormat &&
+          ids.some(id => (it.content as ContentFormat).key.endsWith(id))
+        ) {
+          it.delete(tr);
+        }
+        const content = it.content as {type?: {_start?: Item | null}};
+        if (content.type?._start !== undefined) {
+          walk(content.type as {_start: Item | null});
+        }
+      }
+    };
+    walk(peer.doc.get('lexical-y') as unknown as {_start: Item | null});
+  });
+}
+
+describe("@lexical/y a restore inside its own client's comment run, with many comment ids", () => {
+  for (const count of [1, 16, 64, 128]) {
+    for (const ids of [
+      [1, 2],
+      [2, 1],
+    ]) {
+      // Past 64 structs, rule 5 cannot find where the comment change ended
+      // (changeEnd's scan is capped), so the restore gets no end of its own
+      // and every comment spreads, as on main: tracked in #9603.
+      (count > 64 ? test.fails : test)(
+        `ends after the run when a collaborator deletes the word and its comment items (${count} ids, ids ${ids})`,
+        async () => {
+          const marks = Array.from(
+            {length: count},
+            (_, i) => `m${i.toString().padStart(3, '0')}`,
+          );
+          const t = await setup(
+            () => $getRoot().append($p('aa Kilometer bb cc'), $p('tail line')),
+            {ids, prepare},
+          );
+          t.a.update(() => {
+            const selection = $selectIn([0], 3, 12);
+            for (const id of marks) {
+              $addMarkID(id, selection);
+            }
+          });
+          await t.sync();
+          t.offline();
+          t.a.update(() => $insertPlainAt(6, 'X'));
+          t.b.update(() => void $selectIn([0], 3, 13).removeText());
+          dropMarkItems(t.b, marks);
+          await t.sync();
+          await expectConverged(t.peers);
+          expect(t.a.read(() => $getRoot().getTextContent())).toBe(
+            'aa Xbb cc\n\ntail line',
+          );
+          expect(
+            t.a.read(() =>
+              $getRoot()
+                .getAllTextNodes()
+                .flatMap(node => $getNodeMarkIDs(node)),
+            ),
+          ).toEqual([]);
+        },
+      );
+    }
+  }
+});
diff --git a/packages/lexical-y/src/__tests__/unit/RunSequenceUndo.test.ts b/packages/lexical-y/src/__tests__/unit/RunSequenceUndo.test.ts
new file mode 100644
index 00000000000..2702a202363
--- /dev/null
+++ b/packages/lexical-y/src/__tests__/unit/RunSequenceUndo.test.ts
@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+// @vitest-environment node
+
+// Two clients, random words with random formats. B gives a run a format,
+// types plain " zz" somewhere, gives a second run (or its own " zz") the same
+// format, and the clients sync. Then, concurrently, A types plain "X" inside
+// the first run while B undoes one to three of its writes (the last undo
+// sometimes after A's "X" reached B). Words outside both runs keep the
+// formats they had, and the clients agree. (Found by the randomized
+// run-sequence sessions; seed 87 also fails on main, #9599.)
+
+import {
+  buildEditorFromExtensions,
+  getExtensionDependencyFromEditor,
+} from '@lexical/extension';
+import {RichTextExtension} from '@lexical/rich-text';
+import * as Y from '@y/y';
+import {
+  $createParagraphNode,
+  $createRangeSelection,
+  $createTextNode,
+  $getRoot,
+  $setSelection,
+  configExtension,
+  defineExtension,
+  type LexicalEditor,
+  type TextFormatType,
+  type TextNode,
+} from 'lexical';
+import {expect, test} from 'vitest';
+
+import {YCollabExtension} from '../..';
+import {createYDoc, seedYState} from '../../headless';
+
+const extensions = [RichTextExtension];
+const config = {extensions, onWarn: () => {}, schemaVersion: 1};
+const FORMATS: TextFormatType[] = [
+  'bold',
+  'italic',
+  'underline',
+  'strikethrough',
+];
+const SEEDS = 200;
+// Seeds of this range that fail on main as well (#9599).
+const FAIL_ON_MAIN = [87];
+
+function rngOf(seed: number) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function client(seed: Uint8Array, id: number) {
+  const doc = createYDoc(seed);
+  doc.clientID = id;
+  const editor = buildEditorFromExtensions(
+    defineExtension({
+      $initialEditorState: null,
+      dependencies: [
+        ...extensions,
+        configExtension(YCollabExtension, {doc, schemaVersion: 1}),
+      ],
+      name: 'c' + id,
+    }),
+  );
+  return {doc, editor};
+}
+
+function $find(token: string): [TextNode, number] {
+  for (const t of $getRoot().getAllTextNodes()) {
+    const i = t.getTextContent().indexOf(token);
+    if (i >= 0) {
+      return [t, i];
+    }
+  }
+  throw new Error(token);
+}
+
+function $select(from: string, to: string) {
+  const [a, ao] = $find(from);
+  const [b, bo] = $find(to);
+  const s = $createRangeSelection();
+  s.anchor.set(a.getKey(), ao, 'text');
+  s.focus.set(b.getKey(), bo + to.length, 'text');
+  $setSelection(s);
+  return s;
+}
+
+function $typePlain(token: string, offset: number, text: string) {
+  const [node, i] = $find(token);
+  const s = $createRangeSelection();
+  s.anchor.set(node.getKey(), i + offset, 'text');
+  s.focus.set(node.getKey(), i + offset, 'text');
+  $setSelection(s);
+  s.setFormat(0);
+  s.insertText(text);
+}
+
+const formatsOf = (editor: LexicalEditor) =>
+  editor.getEditorState().read(() => {
+    const m: Record<string, number> = {};
+    for (const t of $getRoot().getAllTextNodes()) {
+      for (const w of t.getTextContent().split(/\s+/)) {
+        if (/^w\d+$/.test(w)) {
+          m[w] = (m[w] ?? 0) | t.getFormat();
+        }
+      }
+    }
+    return m;
+  });
+
+test('a run sequence undone while a collaborator types inside the first run leaves other words as they were', async () => {
+  const failing: number[] = [];
+  for (let seed = 1; seed <= SEEDS; seed++) {
+    const r = rngOf(seed);
+    const pick = <T>(xs: T[]) => xs[Math.floor(r() * xs.length)];
+    const n = 6 + Math.floor(r() * 6);
+    const words = Array.from({length: n}, (_, i) => `w${i}`);
+    const pre = words.map(() => (r() < 0.3 ? 1 << Math.floor(r() * 4) : 0));
+    const lines = r() < 0.5 ? 1 : 2;
+    const state = seedYState(config, () => {
+      const ps = Array.from({length: lines}, () => $createParagraphNode());
+      words.forEach((w, i) =>
+        ps[lines === 1 ? 0 : i < n / 2 ? 0 : 1].append(
+          $createTextNode(w + ' ').setFormat(pre[i]),
+        ),
+      );
+      $getRoot()
+        .clear()
+        .append(...ps);
+    });
+    const [ia, ib] = r() < 0.5 ? [1, 2] : [2, 1];
+    const a = client(state, ia);
+    const b = client(state, ib);
+    await Promise.resolve();
+    const format = pick(FORMATS);
+    const i1 = Math.floor(r() * (n - 1));
+    const j1 = Math.min(n - 1, i1 + Math.floor(r() * 2));
+    const i2 = Math.floor(r() * n);
+    const j2 = Math.min(n - 1, i2 + Math.floor(r() * 2));
+    // The second run is the writer's own just-typed plain word.
+    const ownWord = r() < 0.4;
+    const typedAfter = pick(words);
+    b.editor.update(() => $select(words[i1], words[j1]).formatText(format), {
+      discrete: true,
+    });
+    b.editor.update(() => $typePlain(typedAfter, typedAfter.length, ' zz'), {
+      discrete: true,
+    });
+    b.editor.update(
+      () =>
+        (ownWord
+          ? $select('zz', 'zz')
+          : $select(words[i2], words[j2])
+        ).formatText(format),
+      {discrete: true},
+    );
+    Y.applyUpdate(a.doc, Y.encodeStateAsUpdate(b.doc));
+    await Promise.resolve();
+    const before = formatsOf(a.editor);
+    const svB = Y.encodeStateVector(b.doc);
+    const svA = Y.encodeStateVector(a.doc);
+    const k = 1 + Math.floor(r() * 3);
+    const target = words[i1 + Math.floor(r() * (j1 - i1 + 1))];
+    a.editor.update(() => $typePlain(target, 1, 'X'), {discrete: true});
+    const binding = getExtensionDependencyFromEditor(b.editor, YCollabExtension)
+      .output.binding;
+    const undo = () => {
+      binding.undoManager?.stopCapturing();
+      binding.undo();
+    };
+    // The last undo after A's edit reached B.
+    const late = k > 1 && r() < 0.5;
+    for (let i = 0; i < (late ? k - 1 : k); i++) {
+      undo();
+    }
+    if (late) {
+      Y.applyUpdate(b.doc, Y.encodeStateAsUpdate(a.doc, svB));
+      await Promise.resolve();
+      undo();
+    }
+    const fromA = Y.encodeStateAsUpdate(a.doc, svA);
+    const fromB = Y.encodeStateAsUpdate(b.doc, svB);
+    Y.applyUpdate(a.doc, fromB);
+    Y.applyUpdate(b.doc, fromA);
+    await Promise.resolve();
+    const after = formatsOf(a.editor);
+    const afterB = formatsOf(b.editor);
+    const touched = new Set([
+      ...words.slice(i1, j1 + 1),
+      ...(ownWord ? [] : words.slice(i2, j2 + 1)),
+    ]);
+    const changed = words.filter(
+      w => !touched.has(w) && (after[w] ?? 0) !== (before[w] ?? 0),
+    );
+    if (
+      changed.length > 0 ||
+      JSON.stringify(after) !== JSON.stringify(afterB)
+    ) {
+      failing.push(seed);
+    }
+    a.editor.setRootElement(null);
+    b.editor.setRootElement(null);
+  }
+  expect(failing).toEqual(FAIL_ON_MAIN);
+}, 120000);
diff --git a/packages/lexical-y/src/internal/Cursor.ts b/packages/lexical-y/src/internal/Cursor.ts
index fa44c71c708..1b479e480d3 100644
--- a/packages/lexical-y/src/internal/Cursor.ts
+++ b/packages/lexical-y/src/internal/Cursor.ts
@@ -603,6 +603,9 @@ export class Cursor {
       this.forward();
     }
     for (const end of ends) {
+      if (this.endedInThisWrite(end)) {
+        continue;
+      }
       this.insertAfter(
         end,
         new ContentFormat(keyOf(end), null as unknown as object),
@@ -610,6 +613,27 @@ export class Cursor {
     }
   }
 
+  /**
+   * Whether this write already put a null of its own right after `end` (rule
+   * 5 of format): one is enough, as an undo removes them together, and a
+   * second one only pushes the end out of what a collaborator's collapse keeps
+   * (see collapseGap: it keeps a key's last items).
+   */
+  private endedInThisWrite(end: Item): boolean {
+    const key = keyOf(end);
+    for (let it = end.right; it !== null && isFormat(it); it = it.right) {
+      if (
+        keyOf(it) === key &&
+        valueOf(it) === null &&
+        !it.deleted &&
+        this.tr.insertSet.hasId(it.id)
+      ) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * For a restore of `key` to `value` written at the cursor: where the run it
    * restates was opened by another client's change (see runOpener; the item
@@ -643,9 +667,6 @@ export class Cursor {
       return null;
     }
     const opener = runOpener(doc, source);
-    if (opener.id.client === doc.clientID) {
-      return null;
-    }
     for (let it = this.right; it !== null; it = it.right) {
       if (
         it.deleted ||