Unregister systemIds eagerly (#4405)

* Unregister `systemId`s eagerly

* fixed test title

.changeset/green-fishes-shave.md

@@ -0,0 +1,5 @@
+---
+'xstate': patch
+---
+
+Fixed crash on a `systemId` synchronous re-registration attempt that could happen, for example, when dealing with reentering transitions.

packages/core/src/actions/stop.ts

@@ -55,6 +55,12 @@ function executeStop(
   if (!actorRef) {
     return;
   }
+
+  // we need to eagerly unregister it here so a new actor with the same systemId can be registered immediately
+  // since we defer actual stopping of the actor but we don't defer actor creations (and we can't do that)
+  // this could throw on `systemId` collision, for example, when dealing with reentering transitions
+  actorContext.system._unregister(actorRef);
+
   // this allows us to prevent an actor from being started if it gets stopped within the same macrostep
   // this can happen, for example, when the invoking state is being exited immediately by an always transition
   if (actorRef.status !== ActorStatus.Running) {

packages/core/test/system.test.ts

@@ -424,4 +424,49 @@ describe('system', () => {
 
     expect(actor.system.get('test')).toBeDefined();
   });
+
+  it('should gracefully handle re-registration of a `systemId` during a reentering transition', () => {
+    const spy = jest.fn();
+
+    let counter = 0;
+
+    const machine = createMachine({
+      initial: 'listening',
+      states: {
+        listening: {
+          invoke: {
+            systemId: 'listener',
+            src: fromCallback(({ receive }) => {
+              const localId = counter++;
+
+              receive((event) => {
+                spy(localId, event);
+              });
+
+              return () => {};
+            })
+          }
+        }
+      },
+      on: {
+        RESTART: {
+          target: '.listening'
+        }
+      }
+    });
+
+    const actorRef = createActor(machine).start();
+
+    actorRef.send({ type: 'RESTART' });
+    actorRef.system.get('listener')!.send({ type: 'a' });
+
+    expect(spy.mock.calls).toEqual([
+      [
+        1,
+        {
+          type: 'a'
+        }
+      ]
+    ]);
+  });
 });