[lexical][lexical-y] Bug Fix: Continue notifying update listeners after failures

.changeset/lexical-update-listener-errors.md

@@ -0,0 +1,9 @@
+---
+'lexical': patch
+---
+
+[fix] Continue notifying update listeners after listener or cleanup errors
+
+As before, a listener whose own cleanup throws is skipped for that commit. Updates queued by update listeners run after a listener error without waiting for another external update. An update listener's previous cleanup is not repeated when the cleanup throws, the listener throws on its next call, or the listener unregisters itself.
+
+Verify: Register a throwing update listener before a history or collaboration listener. Later listeners must receive the same committed state, the first error must still reach the caller, and `onError` remains unused for listener errors. Queue an update from a later listener and verify it commits without another external update.

packages/lexical-y/src/__tests__/unit/UpdateErrors.test.ts

@@ -315,35 +315,4 @@ describe('the binding writes every committed change', () => {
       'paragraph("t1z t2z  t6z  t9z") / paragraph("tail line")',
     );
   });
-
-  // Open, #9514 (not caused by an update that throws): Lexical stops
-  // notifying a commit's update listeners when one of them throws, so a
-  // binding registered after the listener that threw never writes that
-  // commit.
-  test.fails(
-    "a commit whose update listeners stopped before the binding's is not written (#9514)",
-    async () => {
-      let armed = false;
-      const t = await setup($doc, {
-        prepare: (editor: LexicalEditor) => {
-          editor.registerUpdateListener(() => {
-            if (armed) {
-              armed = false;
-              throw new Error('listener bug');
-            }
-          });
-        },
-      });
-      armed = true;
-      expect(() =>
-        t.a.update(() => void $selectWords('t2z').removeText()),
-      ).toThrow('listener bug');
-      t.a.update(() => void $selectIn([1], 9).insertText('!'));
-      await t.sync();
-      await expectConverged(
-        t.peers,
-        'paragraph("t1z  t3z t4z t5z t6z t7z t8z t9z") / paragraph("tail line!")',
-      );
-    },
-  );
 });

packages/lexical-y/src/__tests__/unit/regressions/ThrowingUpdateListener.test.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 {$getRoot, type LexicalEditor} from 'lexical';
+import {describe, expect, test} from 'vitest';
+
+import {
+  $block,
+  $p,
+  $selectIn,
+  expectConverged,
+  setup,
+} from '../../utils/harness';
+
+// #9514: a throwing application listener registered before the binding must
+// not prevent the binding from writing an already committed delete.
+describe.each(['reports', 'rethrows'] as const)(
+  'a throwing update listener, onError %s',
+  mode => {
+    test('the binding writes the delete and every later edit', async () => {
+      let armed = false;
+      const reported: Error[] = [];
+      const failure = new Error('listener bug');
+      const t = await setup(
+        () =>
+          $getRoot().append(
+            $p('t1z t2z t3z t4z t5z t6z t7z t8z t9z'),
+            $p('tail line'),
+          ),
+        {
+          prepare: (editor: LexicalEditor) => {
+            editor._onError = error => {
+              reported.push(error);
+              if (mode === 'rethrows') {
+                throw error;
+              }
+            };
+            editor.registerUpdateListener(() => {
+              if (armed) {
+                armed = false;
+                throw failure;
+              }
+            });
+          },
+        },
+      );
+      armed = true;
+      expect(() =>
+        t.a.update(() => {
+          const at = $block([0]).getTextContent().indexOf('t2z');
+          $selectIn([0], at, at + 3).removeText();
+        }),
+      ).toThrow(failure);
+      t.a.update(() => void $selectIn([1], 9).insertText('!'));
+      await t.sync();
+      await expectConverged(
+        t.peers,
+        'paragraph("t1z  t3z t4z t5z t6z t7z t8z t9z") / paragraph("tail line!")',
+      );
+      expect(reported).toEqual([]);
+    });
+  },
+);

packages/lexical/src/LexicalUpdates.ts

@@ -938,6 +938,7 @@ export function triggerListeners<T extends keyof MapListeners>(
   isCurrentlyEnqueuingUpdates: boolean,
   ...payload: MapListeners[T]
 ): void {
+  let rethrown: null | {error: unknown} = null;
   const previouslyUpdating = editor._updating;
   editor._updating = isCurrentlyEnqueuingUpdates;
 
@@ -948,23 +949,44 @@ export function triggerListeners<T extends keyof MapListeners>(
     >;
     const listeners = Array.from(listenerMap);
     for (const [listener, unregister] of listeners) {
-      if (unregister) {
-        unregister();
-      }
-      // TypeScript's void-return rule lets a `=> void` callback return any value,
-      // so a listener like `() => arr.push(x)` hands back a number. Only a
-      // function is an unregister callback.
-      const result = listener(...payload);
-      const nextUnregister = typeof result === 'function' ? result : undefined;
-      if (listenerMap.has(listener)) {
-        listenerMap.set(listener, nextUnregister);
-      } else if (nextUnregister) {
-        nextUnregister();
+      try {
+        if (unregister) {
+          if (type === 'update' && listenerMap.has(listener)) {
+            // A cleanup that throws, or whose next listener throws, has still
+            // been called. Do not call it again on the next commit.
+            listenerMap.set(listener, undefined);
+          }
+          unregister();
+        }
+        // TypeScript's void-return rule lets a `=> void` callback return any value,
+        // so a listener like `() => arr.push(x)` hands back a number. Only a
+        // function is an unregister callback.
+        const result = listener(...payload);
+        const nextUnregister =
+          typeof result === 'function' ? result : undefined;
+        if (listenerMap.has(listener)) {
+          listenerMap.set(listener, nextUnregister);
+        } else if (nextUnregister) {
+          nextUnregister();
+        }
+      } catch (error) {
+        if (type !== 'update') {
+          throw error;
+        }
+        // Every update listener must see the committed state, even if an
+        // earlier listener throws. Keep the existing error contract: callers
+        // receive the first error and onError is not called for listeners.
+        rethrown ??= {error};
       }
     }
   } finally {
     editor._updating = previouslyUpdating;
   }
+  if (rethrown !== null) {
+    // A listener may have queued updates before the commit was interrupted.
+    scheduleMicroTask(() => $triggerEnqueuedUpdates(editor));
+    throw rethrown.error;
+  }
 }
 
 function hasSelectionChanged(