[core] feat(interpreter): allow to provide errorListeners

packages/core/src/interpreter.ts

@@ -1093,7 +1093,18 @@ export class Interpreter<
             // Send "error.platform.id" to this (parent).
             this.send(toSCXMLEvent(errorEvent as any, { origin: id }));
           } catch (error) {
-            reportUnhandledExceptionOnInvocation(errorData, error, id);
+            if (this.parent) {
+              this.parent.send(
+                {
+                  type: 'xstate.error',
+                  data: error
+                } as EventObject,
+                undefined,
+                true
+              );
+            } else {
+              reportUnhandledExceptionOnInvocation(errorData, error, id);
+            }
             if (this.devTools) {
               this.devTools.send(errorEvent, this.state, true);
             }

packages/core/test/interpreter.test.ts

@@ -1732,6 +1732,61 @@ Event: {\\"type\\":\\"SOME_EVENT\\"}"
       );
     });
 
+    it('should be handle child errors with errorListener', (done) => {
+      const failureMachine = Machine<typeof context>(
+        {
+          id: 'failure',
+          context,
+          initial: 'active',
+          states: {
+            active: {
+              after: {
+                100: {
+                  target: 'failure'
+                }
+              }
+            },
+            failure: {
+              invoke: {
+                src: 'failure'
+              }
+            }
+          }
+        },
+        {
+          services: {
+            failure: async () => {
+              throw new Error('error');
+            }
+          }
+        }
+      );
+
+      const parentMachine = Machine({
+        initial: 'foo',
+        states: {
+          foo: {
+            invoke: {
+              id: 'child',
+              src: failureMachine
+            }
+          }
+        }
+      });
+
+      const intervalService = interpret(parentMachine).start();
+
+      expect(isObservable(intervalService)).toBeTruthy();
+
+      intervalService.subscribe(
+        () => {},
+        (error) => {
+          expect(error.data).toBeInstanceOf(Error);
+          done();
+        }
+      );
+    });
+
     it('should be interoperable with RxJS, etc. via Symbol.observable', (done) => {
       let count = 0;
       const intervalService = interpret(intervalMachine).start();