xstate 6.0.0-alpha.49 → 6.0.0-alpha.50

package/dist/{StateMachine-0adb3a70.cjs.js → StateMachine-1e6ee14a.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-b4dd05ae.cjs.js');
+var createActor = require('./createActor-27fd819f.cjs.js');
 var validation = require('./validation-4561b43c.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -714,16 +714,28 @@ class StateMachine {
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      createActor.setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
     if (this.validator) {
-      validation.assertValid(this.validator, {
+      const sourceRef = actorScope && actorScope.self._lastSourceRef;
+      const eventOrigin = sourceRef ? 'actor' : 'external';
+      const error = this.validator.check({
         kind: 'event',
         logic: this,
         event,
-        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+        eventOrigin
       });
-    }
-    if (usesInertScope) {
-      createActor.setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+      if (error) {
+        // Boundary fault: an invalid event arriving from outside the machine
+        // is rejected (never delivered), not routed to the error channel. The
+        // snapshot is returned unchanged; the rejection is represented as an
+        // effect so hosts and the actor runtime can report it.
+        return [snapshot, [createActor.createDeadLetterEffect(resolvedActorScope, sourceRef, event, 'invalidEvent', {
+          issues: error.issues,
+          error
+        })]];
+      }
     }
     createActor.beginSpawnAllocation(resolvedActorScope);
     const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);

package/dist/{StateMachine-29450e6d.development.cjs.js → StateMachine-70df737c.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var createActor = require('./createActor-a1e0dffb.development.cjs.js');
+var createActor = require('./createActor-ea9a560c.development.cjs.js');
 var validation = require('./validation-f2714a35.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -743,16 +743,28 @@ class StateMachine {
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      createActor.setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
     if (this.validator) {
-      validation.assertValid(this.validator, {
+      const sourceRef = actorScope && actorScope.self._lastSourceRef;
+      const eventOrigin = sourceRef ? 'actor' : 'external';
+      const error = this.validator.check({
         kind: 'event',
         logic: this,
         event,
-        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+        eventOrigin
       });
-    }
-    if (usesInertScope) {
-      createActor.setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+      if (error) {
+        // Boundary fault: an invalid event arriving from outside the machine
+        // is rejected (never delivered), not routed to the error channel. The
+        // snapshot is returned unchanged; the rejection is represented as an
+        // effect so hosts and the actor runtime can report it.
+        return [snapshot, [createActor.createDeadLetterEffect(resolvedActorScope, sourceRef, event, 'invalidEvent', {
+          issues: error.issues,
+          error
+        })]];
+      }
     }
     createActor.beginSpawnAllocation(resolvedActorScope);
     const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);

package/dist/{StateMachine-2af31c11.esm.js → StateMachine-8cea8974.esm.js}

@@ -1,4 +1,4 @@
-import { L as resolveRegisteredActorSource, M as allocateChildId, N as assertChildIdFree, O as reserveChildId, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, T as getEventDescriptorKey, U as getCandidates, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as matchesActorSession, a0 as formatRouteTransitions, a1 as resolveStateValue, a2 as getAllStateNodes, f as getStateNodes, a3 as createMachineSnapshot, a4 as isInFinalState, a5 as createInertActorScope, a6 as setInertActorScopeSnapshot, a7 as beginSpawnAllocation, a8 as attachSnapshotActorRef, a9 as macrostep, aa as isInertActorScope, ab as setSnapshotActorRef, ac as cloneMachineSnapshot, ad as transitionNode, J as XSTATE_TIMER, m as matchesEventDescriptor, ae as getTransitionResult, af as hasEffect, ag as createErrorPlatformEvent, ah as withActorSelf, ai as resolveActionsWithContext, aj as takeSpawnAllocationCounters, ak as mergeActorIdCounters, y as createInitEvent, al as createSpawnEffect, am as initialMicrostep, an as toStatePath, ao as isStateId, ap as getStateNodeByPath, aq as getPersistedSnapshot, ar as createRemoteActorRef, as as resolveReferencedActor, at as createInvokeTimeoutEvent, au as parseGeneratedActorId, av as ACTOR_REF_TYPE, c as createActor } from './createActor-268165d4.esm.js';
+import { M as resolveRegisteredActorSource, N as allocateChildId, O as assertChildIdFree, P as reserveChildId, S as STATE_DELIMITER, Q as mapValues, t as toArray, R as createInvokeId, T as getDelayedTransitions, U as getEventDescriptorKey, V as getCandidates, W as evaluateCandidate, Y as formatTransition, Z as NULL_EVENT, _ as toTransitionConfigArray, $ as createInvokeTimeoutEventId, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, f as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as createInertActorScope, a7 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a8 as beginSpawnAllocation, a9 as attachSnapshotActorRef, aa as macrostep, ab as isInertActorScope, ac as setSnapshotActorRef, ad as cloneMachineSnapshot, ae as transitionNode, K as XSTATE_TIMER, m as matchesEventDescriptor, af as getTransitionResult, ag as hasEffect, ah as createErrorPlatformEvent, ai as withActorSelf, aj as resolveActionsWithContext, ak as takeSpawnAllocationCounters, al as mergeActorIdCounters, y as createInitEvent, am as createSpawnEffect, an as initialMicrostep, ao as toStatePath, ap as isStateId, aq as getStateNodeByPath, ar as getPersistedSnapshot, as as createRemoteActorRef, at as resolveReferencedActor, au as createInvokeTimeoutEvent, av as parseGeneratedActorId, aw as ACTOR_REF_TYPE, c as createActor } from './createActor-ad3a1abe.esm.js';
 import { a as assertValid } from './validation-05f1d517.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -712,16 +712,28 @@ class StateMachine {
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
     if (this.validator) {
-      assertValid(this.validator, {
+      const sourceRef = actorScope && actorScope.self._lastSourceRef;
+      const eventOrigin = sourceRef ? 'actor' : 'external';
+      const error = this.validator.check({
         kind: 'event',
         logic: this,
         event,
-        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+        eventOrigin
       });
-    }
-    if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+      if (error) {
+        // Boundary fault: an invalid event arriving from outside the machine
+        // is rejected (never delivered), not routed to the error channel. The
+        // snapshot is returned unchanged; the rejection is represented as an
+        // effect so hosts and the actor runtime can report it.
+        return [snapshot, [createDeadLetterEffect(resolvedActorScope, sourceRef, event, 'invalidEvent', {
+          issues: error.issues,
+          error
+        })]];
+      }
     }
     beginSpawnAllocation(resolvedActorScope);
     const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);

package/dist/{StateMachine-faf50c5c.development.esm.js → StateMachine-bc28e207.development.esm.js}

@@ -1,4 +1,4 @@
-import { L as resolveRegisteredActorSource, M as allocateChildId, N as assertChildIdFree, O as reserveChildId, S as STATE_DELIMITER, P as mapValues, t as toArray, Q as createInvokeId, R as getDelayedTransitions, T as getEventDescriptorKey, U as getCandidates, V as evaluateCandidate, W as formatTransition, Y as NULL_EVENT, Z as toTransitionConfigArray, _ as createInvokeTimeoutEventId, $ as matchesActorSession, a0 as formatRouteTransitions, a1 as resolveStateValue, a2 as getAllStateNodes, f as getStateNodes, a3 as createMachineSnapshot, a4 as isInFinalState, a5 as createInertActorScope, a6 as setInertActorScopeSnapshot, a7 as beginSpawnAllocation, a8 as attachSnapshotActorRef, a9 as macrostep, aa as isInertActorScope, ab as setSnapshotActorRef, ac as cloneMachineSnapshot, ad as transitionNode, J as XSTATE_TIMER, m as matchesEventDescriptor, ae as getTransitionResult, af as hasEffect, ag as createErrorPlatformEvent, ah as withActorSelf, ai as resolveActionsWithContext, aj as takeSpawnAllocationCounters, ak as mergeActorIdCounters, y as createInitEvent, al as createSpawnEffect, am as initialMicrostep, an as toStatePath, ao as isStateId, ap as getStateNodeByPath, aq as getPersistedSnapshot, ar as createRemoteActorRef, as as resolveReferencedActor, at as createInvokeTimeoutEvent, au as parseGeneratedActorId, av as ACTOR_REF_TYPE, c as createActor } from './createActor-88709f74.development.esm.js';
+import { M as resolveRegisteredActorSource, N as allocateChildId, O as assertChildIdFree, P as reserveChildId, S as STATE_DELIMITER, Q as mapValues, t as toArray, R as createInvokeId, T as getDelayedTransitions, U as getEventDescriptorKey, V as getCandidates, W as evaluateCandidate, Y as formatTransition, Z as NULL_EVENT, _ as toTransitionConfigArray, $ as createInvokeTimeoutEventId, a0 as matchesActorSession, a1 as formatRouteTransitions, a2 as resolveStateValue, a3 as getAllStateNodes, f as getStateNodes, a4 as createMachineSnapshot, a5 as isInFinalState, a6 as createInertActorScope, a7 as setInertActorScopeSnapshot, z as createDeadLetterEffect, a8 as beginSpawnAllocation, a9 as attachSnapshotActorRef, aa as macrostep, ab as isInertActorScope, ac as setSnapshotActorRef, ad as cloneMachineSnapshot, ae as transitionNode, K as XSTATE_TIMER, m as matchesEventDescriptor, af as getTransitionResult, ag as hasEffect, ah as createErrorPlatformEvent, ai as withActorSelf, aj as resolveActionsWithContext, ak as takeSpawnAllocationCounters, al as mergeActorIdCounters, y as createInitEvent, am as createSpawnEffect, an as initialMicrostep, ao as toStatePath, ap as isStateId, aq as getStateNodeByPath, ar as getPersistedSnapshot, as as createRemoteActorRef, at as resolveReferencedActor, au as createInvokeTimeoutEvent, av as parseGeneratedActorId, aw as ACTOR_REF_TYPE, c as createActor } from './createActor-74e185ee.development.esm.js';
 import { a as assertValid } from './validation-e69470ad.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
@@ -741,16 +741,28 @@ class StateMachine {
   transition(snapshot, event, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+    if (usesInertScope) {
+      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+    }
     if (this.validator) {
-      assertValid(this.validator, {
+      const sourceRef = actorScope && actorScope.self._lastSourceRef;
+      const eventOrigin = sourceRef ? 'actor' : 'external';
+      const error = this.validator.check({
         kind: 'event',
         logic: this,
         event,
-        eventOrigin: actorScope && actorScope.self._lastSourceRef ? 'actor' : 'external'
+        eventOrigin
       });
-    }
-    if (usesInertScope) {
-      setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+      if (error) {
+        // Boundary fault: an invalid event arriving from outside the machine
+        // is rejected (never delivered), not routed to the error channel. The
+        // snapshot is returned unchanged; the rejection is represented as an
+        // effect so hosts and the actor runtime can report it.
+        return [snapshot, [createDeadLetterEffect(resolvedActorScope, sourceRef, event, 'invalidEvent', {
+          issues: error.issues,
+          error
+        })]];
+      }
     }
     beginSpawnAllocation(resolvedActorScope);
     const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);

package/dist/{createActor-b4dd05ae.cjs.js → createActor-27fd819f.cjs.js}

@@ -500,6 +500,25 @@ function createEmitEffect(actorScope, event) {
     args: []
   };
 }
+function execDeadLetterEffect(runtime = this.target.system) {
+  return runtime.deadLetter(this.source, this.target, this.event, this.reason, this.detail);
+}
+
+/** @internal Creates a dead-letter effect for a boundary-rejected event. */
+function createDeadLetterEffect(actorScope, source, event, reason, detail) {
+  return {
+    kind: 'builtin',
+    type: '@xstate.deadLetter',
+    exec: execDeadLetterEffect,
+    source,
+    target: actorScope.self,
+    event,
+    reason,
+    detail,
+    params: undefined,
+    args: []
+  };
+}
 
 /** @internal Creates a directly executable user effect. */
 function createCustomEffect(type, action, params) {
@@ -4227,21 +4246,42 @@ async function runStep(actor, key, exec, sendSelf = event => void actor.system.s
  * @experimental
  */
 function deliverEvent(source, target, event) {
-  assertEventCanBeSent(source, target, event);
+  if (rejectUndeliverableEvent(source, target, event)) {
+    return;
+  }
   const runtimeTarget = target;
   runtimeTarget._lastSourceRef = source;
   runtimeTarget._send(event);
 }
 
 /**
- * Ensures internal events cannot cross an actor boundary from an external
- * sender. Host runtimes must call this before taking ownership of delivery.
+ * Returns the boundary error preventing this delivery, if any: an internal
+ * event type cannot cross an actor boundary from an external sender.
  */
-function assertEventCanBeSent(source, target, event) {
+function getEventBoundaryError(source, target, event) {
   const runtimeTarget = target;
   if (source !== target && runtimeTarget.logic?.isInternalEventType?.(event.type)) {
-    throw new Error(`Internal event "${event.type}" cannot be sent to actor "${target.id}" from outside.`);
+    return new Error(`Internal event "${event.type}" cannot be sent to actor "${target.id}" from outside.`);
+  }
+  return undefined;
+}
+
+/**
+ * Rejects an event that must not cross the delivery boundary — an internal
+ * event type sent from outside its owning actor — by reporting it as a dead
+ * letter. Returns `true` when the event was rejected and must not be
+ * delivered. Host runtimes must call this before taking ownership of
+ * delivery.
+ */
+function rejectUndeliverableEvent(source, target, event) {
+  const error = getEventBoundaryError(source, target, event);
+  if (error) {
+    void target.system.deadLetter(source, target, event, 'internalEvent', {
+      error
+    });
+    return true;
   }
+  return false;
 }
 
 /**
@@ -4442,6 +4482,19 @@ function bookSessionId(system) {
  * other: install a different one via `system.runtime` (for durable hosts,
  * through `createDurable`'s adapter runtime operations).
  */
+/**
+ * Why an event was not delivered: `'invalidEvent'` (payload failed its
+ * declared schema), `'internalEvent'` (an internal event type sent from
+ * outside its owning actor) or `'stopped'` (the target actor already
+ * stopped). Hosts may report additional reasons.
+ */
+
+/** Extra detail attached to a dead letter. */
+
+/**
+ * Describes an event that was rejected at the delivery boundary instead of
+ * being delivered to its target actor (a dead letter).
+ */
 
 /** @internal Every operation of `ActorSystemRuntime`, for runtime wrappers. */
 const RUNTIME_OPERATIONS = ['spawnActor', 'startActor', 'stopActor', 'terminateActor', 'emitEvent', 'scheduleTimer', 'cancelTimer', 'cancelAllTimers', 'deadLetter'
@@ -4504,6 +4557,7 @@ class RuntimeSystem {
     this._clock = void 0;
     this._logger = void 0;
     this.createActorRef = void 0;
+    this._onRejectedEvent = options.onRejectedEvent;
     const restoredSnapshot = typeof options.snapshot === 'object' && options.snapshot !== null ? options.snapshot : undefined;
     this._clock = options.clock;
     this._logger = options.logger;
@@ -4702,7 +4756,9 @@ class RuntimeSystem {
     terminateActor(actor, termination);
   }
   sendEvent(source, target, event) {
-    assertEventCanBeSent(source, target, event);
+    if (rejectUndeliverableEvent(source, target, event)) {
+      return;
+    }
     // Record for the inspection `sent[]` facet regardless of which runtime
     // delivers, so host runtimes keep inspection parity.
     this._recordSent(source, target, event);
@@ -4719,17 +4775,29 @@ class RuntimeSystem {
     }
     source._emit(event);
   }
-  deadLetter(source, target, event, reason) {
+  deadLetter(source, target, event, reason, detail) {
     this._sendInspectionEvent({
       type: '@xstate.deadletter',
       actorRef: target,
       sourceRef: source,
       event,
-      reason
+      reason,
+      issues: detail?.issues,
+      error: detail?.error
+    });
+    this._onRejectedEvent?.({
+      event,
+      targetRef: target,
+      targetId: target.id,
+      sourceRef: source,
+      eventOrigin: source ? 'actor' : 'external',
+      reason,
+      issues: detail?.issues,
+      error: detail?.error
     });
     const override = this.runtime?.deadLetter;
     if (override) {
-      return override(source, target, event, reason);
+      return override(source, target, event, reason, detail);
     }
   }
   runStep(actor, key, exec) {
@@ -4976,7 +5044,8 @@ class Actor {
       clock,
       logger,
       snapshot: resolvedOptions.snapshot ?? resolvedOptions.state,
-      createActorRef
+      createActorRef,
+      onRejectedEvent: resolvedOptions.onRejectedEvent
     });
     if (!parent && resolvedOptions._systemRef && !resolvedOptions._systemRef.current) {
       resolvedOptions._systemRef.current = this.system;
@@ -5776,6 +5845,7 @@ exports.checkStateIn = checkStateIn;
 exports.cloneMachineSnapshot = cloneMachineSnapshot;
 exports.createActor = createActor;
 exports.createCustomEffect = createCustomEffect;
+exports.createDeadLetterEffect = createDeadLetterEffect;
 exports.createEmitEffect = createEmitEffect;
 exports.createErrorPlatformEvent = createErrorPlatformEvent;
 exports.createInertActorScope = createInertActorScope;

package/dist/{createActor-88709f74.development.esm.js → createActor-74e185ee.development.esm.js}

@@ -499,6 +499,25 @@ function createEmitEffect(actorScope, event) {
     args: []
   };
 }
+function execDeadLetterEffect(runtime = this.target.system) {
+  return runtime.deadLetter(this.source, this.target, this.event, this.reason, this.detail);
+}
+
+/** @internal Creates a dead-letter effect for a boundary-rejected event. */
+function createDeadLetterEffect(actorScope, source, event, reason, detail) {
+  return {
+    kind: 'builtin',
+    type: '@xstate.deadLetter',
+    exec: execDeadLetterEffect,
+    source,
+    target: actorScope.self,
+    event,
+    reason,
+    detail,
+    params: undefined,
+    args: []
+  };
+}
 
 /** @internal Creates a directly executable user effect. */
 function createCustomEffect(type, action, params) {
@@ -4255,21 +4274,42 @@ async function runStep(actor, key, exec, sendSelf = event => void actor.system.s
  * @experimental
  */
 function deliverEvent(source, target, event) {
-  assertEventCanBeSent(source, target, event);
+  if (rejectUndeliverableEvent(source, target, event)) {
+    return;
+  }
   const runtimeTarget = target;
   runtimeTarget._lastSourceRef = source;
   runtimeTarget._send(event);
 }
 
 /**
- * Ensures internal events cannot cross an actor boundary from an external
- * sender. Host runtimes must call this before taking ownership of delivery.
+ * Returns the boundary error preventing this delivery, if any: an internal
+ * event type cannot cross an actor boundary from an external sender.
  */
-function assertEventCanBeSent(source, target, event) {
+function getEventBoundaryError(source, target, event) {
   const runtimeTarget = target;
   if (source !== target && runtimeTarget.logic?.isInternalEventType?.(event.type)) {
-    throw new Error(`Internal event "${event.type}" cannot be sent to actor "${target.id}" from outside.`);
+    return new Error(`Internal event "${event.type}" cannot be sent to actor "${target.id}" from outside.`);
+  }
+  return undefined;
+}
+
+/**
+ * Rejects an event that must not cross the delivery boundary — an internal
+ * event type sent from outside its owning actor — by reporting it as a dead
+ * letter. Returns `true` when the event was rejected and must not be
+ * delivered. Host runtimes must call this before taking ownership of
+ * delivery.
+ */
+function rejectUndeliverableEvent(source, target, event) {
+  const error = getEventBoundaryError(source, target, event);
+  if (error) {
+    void target.system.deadLetter(source, target, event, 'internalEvent', {
+      error
+    });
+    return true;
   }
+  return false;
 }
 
 /**
@@ -4470,6 +4510,19 @@ function bookSessionId(system) {
  * other: install a different one via `system.runtime` (for durable hosts,
  * through `createDurable`'s adapter runtime operations).
  */
+/**
+ * Why an event was not delivered: `'invalidEvent'` (payload failed its
+ * declared schema), `'internalEvent'` (an internal event type sent from
+ * outside its owning actor) or `'stopped'` (the target actor already
+ * stopped). Hosts may report additional reasons.
+ */
+
+/** Extra detail attached to a dead letter. */
+
+/**
+ * Describes an event that was rejected at the delivery boundary instead of
+ * being delivered to its target actor (a dead letter).
+ */
 
 /** @internal Every operation of `ActorSystemRuntime`, for runtime wrappers. */
 const RUNTIME_OPERATIONS = ['spawnActor', 'startActor', 'stopActor', 'terminateActor', 'emitEvent', 'scheduleTimer', 'cancelTimer', 'cancelAllTimers', 'deadLetter'
@@ -4532,6 +4585,7 @@ class RuntimeSystem {
     this._clock = void 0;
     this._logger = void 0;
     this.createActorRef = void 0;
+    this._onRejectedEvent = options.onRejectedEvent;
     const restoredSnapshot = typeof options.snapshot === 'object' && options.snapshot !== null ? options.snapshot : undefined;
     this._clock = options.clock;
     this._logger = options.logger;
@@ -4730,7 +4784,9 @@ class RuntimeSystem {
     terminateActor(actor, termination);
   }
   sendEvent(source, target, event) {
-    assertEventCanBeSent(source, target, event);
+    if (rejectUndeliverableEvent(source, target, event)) {
+      return;
+    }
     // Record for the inspection `sent[]` facet regardless of which runtime
     // delivers, so host runtimes keep inspection parity.
     this._recordSent(source, target, event);
@@ -4747,17 +4803,29 @@ class RuntimeSystem {
     }
     source._emit(event);
   }
-  deadLetter(source, target, event, reason) {
+  deadLetter(source, target, event, reason, detail) {
     this._sendInspectionEvent({
       type: '@xstate.deadletter',
       actorRef: target,
       sourceRef: source,
       event,
-      reason
+      reason,
+      issues: detail?.issues,
+      error: detail?.error
+    });
+    this._onRejectedEvent?.({
+      event,
+      targetRef: target,
+      targetId: target.id,
+      sourceRef: source,
+      eventOrigin: source ? 'actor' : 'external',
+      reason,
+      issues: detail?.issues,
+      error: detail?.error
     });
     const override = this.runtime?.deadLetter;
     if (override) {
-      return override(source, target, event, reason);
+      return override(source, target, event, reason, detail);
     }
     {
       console.warn(`Event "${event.type}" to actor "${target.id}" was not delivered (${reason}).`);
@@ -5007,7 +5075,8 @@ class Actor {
       clock,
       logger,
       snapshot: resolvedOptions.snapshot ?? resolvedOptions.state,
-      createActorRef
+      createActorRef,
+      onRejectedEvent: resolvedOptions.onRejectedEvent
     });
     if (!parent && resolvedOptions._systemRef && !resolvedOptions._systemRef.current) {
       resolvedOptions._systemRef.current = this.system;
@@ -5794,4 +5863,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { matchesActorSession as $, Actor as A, XSTATE_LOGIC_EFFECT_START as B, XSTATE_LOGIC_EFFECT_RESOLVE as C, XSTATE_LOGIC_EFFECT_REJECT as D, finalizeTransitionResult as E, createEmitEffect as F, createSendToEffect as G, XSTATE_INIT as H, withActorScope as I, XSTATE_TIMER as J, isLazyActorScope as K, resolveRegisteredActorSource as L, allocateChildId as M, assertChildIdFree as N, reserveChildId as O, mapValues as P, createInvokeId as Q, getDelayedTransitions as R, STATE_DELIMITER as S, getEventDescriptorKey as T, getCandidates as U, evaluateCandidate as V, formatTransition as W, XSTATE_STOP as X, NULL_EVENT as Y, toTransitionConfigArray as Z, createInvokeTimeoutEventId as _, createListenerLogic as a, formatRouteTransitions as a0, resolveStateValue as a1, getAllStateNodes as a2, createMachineSnapshot as a3, isInFinalState as a4, createInertActorScope as a5, setInertActorScopeSnapshot as a6, beginSpawnAllocation as a7, attachSnapshotActorRef as a8, macrostep as a9, getAllOwnEvents as aA, matchesEvent as aB, encodeAddressSegment as aC, getRootActorId as aD, RUNTIME_OPERATIONS as aE, withSystemInspector as aF, getSnapshotActorRef as aG, withExecutionIdentity as aH, isInertActorScope as aa, setSnapshotActorRef as ab, cloneMachineSnapshot as ac, transitionNode as ad, getTransitionResult as ae, hasEffect as af, createErrorPlatformEvent as ag, withActorSelf as ah, resolveActionsWithContext as ai, takeSpawnAllocationCounters as aj, mergeActorIdCounters as ak, createSpawnEffect as al, initialMicrostep as am, toStatePath as an, isStateId as ao, getStateNodeByPath as ap, getPersistedSnapshot as aq, createRemoteActorRef as ar, resolveReferencedActor as as, createInvokeTimeoutEvent as at, parseGeneratedActorId as au, ACTOR_REF_TYPE as av, hasAmbientInspector as aw, getProperAncestors as ax, isRemoteActorRef as ay, getActorIdPrefix as az, createSubscriptionLogic as b, createActor as c, getNextSnapshot as d, isMachineSnapshot as e, getStateNodes as f, getInitialSnapshot as g, getAllOwnEventDescriptors as h, isAtomicStateNode as i, matchesState as j, checkStateIn as k, listenerLogic as l, matchesEventDescriptor as m, pathToStateValue as n, toObserver as o, parseDelayToMilliseconds as p, executeEffects as q, isBuiltInExecutableAction as r, subscriptionLogic as s, toArray as t, deliverEvent as u, runStep as v, stopActor as w, terminateActor as x, createInitEvent as y, createCustomEffect as z };
+export { createInvokeTimeoutEventId as $, Actor as A, createCustomEffect as B, XSTATE_LOGIC_EFFECT_START as C, XSTATE_LOGIC_EFFECT_RESOLVE as D, XSTATE_LOGIC_EFFECT_REJECT as E, finalizeTransitionResult as F, createEmitEffect as G, createSendToEffect as H, XSTATE_INIT as I, withActorScope as J, XSTATE_TIMER as K, isLazyActorScope as L, resolveRegisteredActorSource as M, allocateChildId as N, assertChildIdFree as O, reserveChildId as P, mapValues as Q, createInvokeId as R, STATE_DELIMITER as S, getDelayedTransitions as T, getEventDescriptorKey as U, getCandidates as V, evaluateCandidate as W, XSTATE_STOP as X, formatTransition as Y, NULL_EVENT as Z, toTransitionConfigArray as _, createListenerLogic as a, matchesActorSession as a0, formatRouteTransitions as a1, resolveStateValue as a2, getAllStateNodes as a3, createMachineSnapshot as a4, isInFinalState as a5, createInertActorScope as a6, setInertActorScopeSnapshot as a7, beginSpawnAllocation as a8, attachSnapshotActorRef as a9, getActorIdPrefix as aA, getAllOwnEvents as aB, matchesEvent as aC, encodeAddressSegment as aD, getRootActorId as aE, RUNTIME_OPERATIONS as aF, withSystemInspector as aG, getSnapshotActorRef as aH, withExecutionIdentity as aI, macrostep as aa, isInertActorScope as ab, setSnapshotActorRef as ac, cloneMachineSnapshot as ad, transitionNode as ae, getTransitionResult as af, hasEffect as ag, createErrorPlatformEvent as ah, withActorSelf as ai, resolveActionsWithContext as aj, takeSpawnAllocationCounters as ak, mergeActorIdCounters as al, createSpawnEffect as am, initialMicrostep as an, toStatePath as ao, isStateId as ap, getStateNodeByPath as aq, getPersistedSnapshot as ar, createRemoteActorRef as as, resolveReferencedActor as at, createInvokeTimeoutEvent as au, parseGeneratedActorId as av, ACTOR_REF_TYPE as aw, hasAmbientInspector as ax, getProperAncestors as ay, isRemoteActorRef as az, createSubscriptionLogic as b, createActor as c, getNextSnapshot as d, isMachineSnapshot as e, getStateNodes as f, getInitialSnapshot as g, getAllOwnEventDescriptors as h, isAtomicStateNode as i, matchesState as j, checkStateIn as k, listenerLogic as l, matchesEventDescriptor as m, pathToStateValue as n, toObserver as o, parseDelayToMilliseconds as p, executeEffects as q, isBuiltInExecutableAction as r, subscriptionLogic as s, toArray as t, deliverEvent as u, runStep as v, stopActor as w, terminateActor as x, createInitEvent as y, createDeadLetterEffect as z };