xstate 5.0.0-beta.32 → 5.0.0-beta.34

package/dist/{raise-b4bfe138.development.cjs.js → raise-38b707c0.development.cjs.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var interpreter = require('./interpreter-a2236840.development.cjs.js');
+var interpreter = require('./interpreter-70ed62f2.development.cjs.js');
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -918,31 +918,33 @@ function microstep(transitions, currentState, actorCtx, event, isInitial) {
 }
 
 function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const actions = [];
   const historyValue = {
     ...currentState.historyValue
   };
   const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
   const internalQueue = [...currentState._internalQueue];
+  // TODO: this `cloneState` is really just a hack to prevent infinite loops
+  // we need to take another look at how internal queue is managed
+  let nextState = cloneState(currentState, {
+    _internalQueue: []
+  });
 
   // Exit states
   if (!isInitial) {
-    exitStates(filteredTransitions, mutConfiguration, historyValue, actions);
+    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
   }
 
   // Execute transition content
-  actions.push(...filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
 
   // Enter states
-  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorCtx);
+  nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
   const done = isInFinalState(nextConfiguration);
   if (done) {
-    const finalActions = nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit);
-    actions.push(...finalActions);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
   }
   try {
-    const nextState = resolveActionsAndContext(actions, event, currentState, actorCtx);
     const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
     internalQueue.push(...nextState._internalQueue);
     return cloneState(currentState, {
@@ -960,7 +962,8 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     throw e;
   }
 }
-function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorContext) {
+function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
+  let nextState = currentState;
   const statesToEnter = new Set();
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
@@ -971,24 +974,26 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
   }
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
     mutConfiguration.add(stateNodeToEnter);
-    for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
-    }
+    const actions = [];
 
     // Add entry actions
     actions.push(...stateNodeToEnter.entry);
+    for (const invokeDef of stateNodeToEnter.invoke) {
+      actions.push(invoke(invokeDef));
+    }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
       for (const stateNode of statesForDefaultEntry) {
         const initialActions = stateNode.initial.actions;
         actions.push(...initialActions);
       }
     }
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
       if (!parent.parent) {
         continue;
       }
-      internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
+      internalQueue.push(interpreter.createDoneStateEvent(parent.id, stateNodeToEnter.output ? interpreter.resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
@@ -999,6 +1004,7 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       }
     }
   }
+  return nextState;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1072,7 +1078,8 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(transitions, mutConfiguration, historyValue, actions) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+  let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
 
@@ -1091,27 +1098,24 @@ function exitStates(transitions, mutConfiguration, historyValue, actions) {
     }
   }
   for (const s of statesToExit) {
-    actions.push(...s.exit, ...s.invoke.map(def => stop(def.id)));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
     mutConfiguration.delete(s);
   }
+  return nextState;
 }
-function resolveActionsAndContext(actions, event, currentState, actorCtx) {
+function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
     machine
   } = currentState;
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let intermediateState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let intermediateState = currentState;
   for (const action of actions) {
     const isInline = typeof action === 'function';
-    const resolved = isInline ? action :
+    const resolvedAction = isInline ? action :
     // the existing type of `.actions` assumes non-nullable `TExpressionAction`
     // it's fine to cast this here to get a common type and lack of errors in the rest of the code
     // our logic below makes sure that we call those 2 "variants" correctly
     machine.implementations.actions[typeof action === 'string' ? action : action.type];
-    if (!resolved) {
+    if (!resolvedAction) {
       continue;
     }
     const actionArgs = {
@@ -1131,20 +1135,25 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       // TS isn't able to narrow it down here
       action
     };
-    if (!('resolve' in resolved)) {
+    if (!('resolve' in resolvedAction)) {
       if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
-        resolved(actionArgs);
+        resolvedAction(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(actionArgs));
+        actorCtx?.defer(() => {
+          resolvedAction(actionArgs);
+        });
       }
       continue;
     }
-    const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
-    );
-
+    const builtinAction = resolvedAction;
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    // this holds all params
+    extra);
     intermediateState = nextState;
-    if ('execute' in resolved) {
+    if ('retryResolve' in builtinAction) {
+      retries?.push([builtinAction, params]);
+    }
+    if ('execute' in builtinAction) {
       if (actorCtx?.self.status === interpreter.ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1152,11 +1161,21 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       }
     }
     if (actions) {
-      intermediateState = resolveActionsAndContext(actions, event, intermediateState, actorCtx);
+      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorCtx, actions, extra, retries);
     }
   }
   return intermediateState;
 }
+function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+  const retries = deferredActorIds ? [] : undefined;
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+    deferredActorIds
+  }, retries);
+  retries?.forEach(([builtinAction, params]) => {
+    builtinAction.retryResolve(actorCtx, nextState, params);
+  });
+  return nextState;
+}
 function macrostep(state, event, actorCtx) {
   if (event.type === interpreter.WILDCARD) {
     throw new Error(`An event cannot have the wildcard type ('${interpreter.WILDCARD}')`);
@@ -1216,7 +1235,7 @@ function stopStep(event, nextState, actorCtx) {
   for (const child of Object.values(nextState.children)) {
     actions.push(stop(child));
   }
-  return resolveActionsAndContext(actions, event, nextState, actorCtx);
+  return resolveActionsAndContext(nextState, event, actorCtx, actions);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);

package/dist/{raise-6a68d0cc.esm.js → raise-b5cfe1bb.esm.js}

@@ -1,4 +1,4 @@
-import { r as resolveReferencedActor, d as createActor, f as ActorStatus, k as createErrorActorEvent, l as toStateValue, n as STATE_IDENTIFIER, o as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, q as toStatePath, s as createDoneStateEvent, u as resolveOutput, j as XSTATE_STOP, X as XSTATE_INIT, W as WILDCARD, v as isArray, w as createAfterEvent, x as flatten, e as matchesState } from './interpreter-d5fa7ce0.esm.js';
+import { r as resolveReferencedActor, d as createActor, f as ActorStatus, j as createErrorActorEvent, k as toStateValue, l as STATE_IDENTIFIER, n as normalizeTarget, t as toArray, N as NULL_EVENT, a as toTransitionConfigArray, S as STATE_DELIMITER, o as toStatePath, q as createDoneStateEvent, s as resolveOutput, X as XSTATE_STOP, u as XSTATE_INIT, W as WILDCARD, v as isArray, w as createAfterEvent, x as flatten, e as matchesState } from './interpreter-83f7f2d4.esm.js';
 
 const cache = new WeakMap();
 function memo(object, key, fn) {
@@ -885,31 +885,33 @@ function microstep(transitions, currentState, actorCtx, event, isInitial) {
 }
 
 function microstepProcedure(transitions, currentState, mutConfiguration, event, actorCtx, isInitial) {
-  const actions = [];
   const historyValue = {
     ...currentState.historyValue
   };
   const filteredTransitions = removeConflictingTransitions(transitions, mutConfiguration, historyValue);
   const internalQueue = [...currentState._internalQueue];
+  // TODO: this `cloneState` is really just a hack to prevent infinite loops
+  // we need to take another look at how internal queue is managed
+  let nextState = cloneState(currentState, {
+    _internalQueue: []
+  });
 
   // Exit states
   if (!isInitial) {
-    exitStates(filteredTransitions, mutConfiguration, historyValue, actions);
+    nextState = exitStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, historyValue);
   }
 
   // Execute transition content
-  actions.push(...filteredTransitions.flatMap(t => t.actions));
+  nextState = resolveActionsAndContext(nextState, event, actorCtx, filteredTransitions.flatMap(t => t.actions));
 
   // Enter states
-  enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorCtx);
+  nextState = enterStates(nextState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial);
   const nextConfiguration = [...mutConfiguration];
   const done = isInFinalState(nextConfiguration);
   if (done) {
-    const finalActions = nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit);
-    actions.push(...finalActions);
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, nextConfiguration.sort((a, b) => b.order - a.order).flatMap(state => state.exit));
   }
   try {
-    const nextState = resolveActionsAndContext(actions, event, currentState, actorCtx);
     const output = done ? getOutput(nextConfiguration, nextState.context, event, actorCtx.self) : undefined;
     internalQueue.push(...nextState._internalQueue);
     return cloneState(currentState, {
@@ -927,7 +929,8 @@ function microstepProcedure(transitions, currentState, mutConfiguration, event,
     throw e;
   }
 }
-function enterStates(event, filteredTransitions, mutConfiguration, actions, internalQueue, currentState, historyValue, isInitial, actorContext) {
+function enterStates(currentState, event, actorCtx, filteredTransitions, mutConfiguration, internalQueue, historyValue, isInitial) {
+  let nextState = currentState;
   const statesToEnter = new Set();
   const statesForDefaultEntry = new Set();
   computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
@@ -938,24 +941,26 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
   }
   for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
     mutConfiguration.add(stateNodeToEnter);
-    for (const invokeDef of stateNodeToEnter.invoke) {
-      actions.push(invoke(invokeDef));
-    }
+    const actions = [];
 
     // Add entry actions
     actions.push(...stateNodeToEnter.entry);
+    for (const invokeDef of stateNodeToEnter.invoke) {
+      actions.push(invoke(invokeDef));
+    }
     if (statesForDefaultEntry.has(stateNodeToEnter)) {
       for (const stateNode of statesForDefaultEntry) {
         const initialActions = stateNode.initial.actions;
         actions.push(...initialActions);
       }
     }
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, actions, stateNodeToEnter.invoke.map(invokeDef => invokeDef.id));
     if (stateNodeToEnter.type === 'final') {
       const parent = stateNodeToEnter.parent;
       if (!parent.parent) {
         continue;
       }
-      internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, currentState.context, event, actorContext.self) : undefined));
+      internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output ? resolveOutput(stateNodeToEnter.output, nextState.context, event, actorCtx.self) : undefined));
       if (parent.parent) {
         const grandparent = parent.parent;
         if (grandparent.type === 'parallel') {
@@ -966,6 +971,7 @@ function enterStates(event, filteredTransitions, mutConfiguration, actions, inte
       }
     }
   }
+  return nextState;
 }
 function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
   for (const t of transitions) {
@@ -1039,7 +1045,8 @@ function addAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, history
     }
   }
 }
-function exitStates(transitions, mutConfiguration, historyValue, actions) {
+function exitStates(currentState, event, actorCtx, transitions, mutConfiguration, historyValue) {
+  let nextState = currentState;
   const statesToExit = computeExitSet(transitions, mutConfiguration, historyValue);
   statesToExit.sort((a, b) => b.order - a.order);
 
@@ -1058,27 +1065,24 @@ function exitStates(transitions, mutConfiguration, historyValue, actions) {
     }
   }
   for (const s of statesToExit) {
-    actions.push(...s.exit, ...s.invoke.map(def => stop(def.id)));
+    nextState = resolveActionsAndContext(nextState, event, actorCtx, [...s.exit, ...s.invoke.map(def => stop(def.id))]);
     mutConfiguration.delete(s);
   }
+  return nextState;
 }
-function resolveActionsAndContext(actions, event, currentState, actorCtx) {
+function resolveActionsAndContextWorker(currentState, event, actorCtx, actions, extra, retries) {
   const {
     machine
   } = currentState;
-  // TODO: this `cloneState` is really just a hack to prevent infinite loops
-  // we need to take another look at how internal queue is managed
-  let intermediateState = cloneState(currentState, {
-    _internalQueue: []
-  });
+  let intermediateState = currentState;
   for (const action of actions) {
     const isInline = typeof action === 'function';
-    const resolved = isInline ? action :
+    const resolvedAction = isInline ? action :
     // the existing type of `.actions` assumes non-nullable `TExpressionAction`
     // it's fine to cast this here to get a common type and lack of errors in the rest of the code
     // our logic below makes sure that we call those 2 "variants" correctly
     machine.implementations.actions[typeof action === 'string' ? action : action.type];
-    if (!resolved) {
+    if (!resolvedAction) {
       continue;
     }
     const actionArgs = {
@@ -1098,20 +1102,25 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       // TS isn't able to narrow it down here
       action
     };
-    if (!('resolve' in resolved)) {
+    if (!('resolve' in resolvedAction)) {
       if (actorCtx?.self.status === ActorStatus.Running) {
-        resolved(actionArgs);
+        resolvedAction(actionArgs);
       } else {
-        actorCtx?.defer(() => resolved(actionArgs));
+        actorCtx?.defer(() => {
+          resolvedAction(actionArgs);
+        });
       }
       continue;
     }
-    const builtinAction = resolved;
-    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolved // this holds all params
-    );
-
+    const builtinAction = resolvedAction;
+    const [nextState, params, actions] = builtinAction.resolve(actorCtx, intermediateState, actionArgs, resolvedAction,
+    // this holds all params
+    extra);
     intermediateState = nextState;
-    if ('execute' in resolved) {
+    if ('retryResolve' in builtinAction) {
+      retries?.push([builtinAction, params]);
+    }
+    if ('execute' in builtinAction) {
       if (actorCtx?.self.status === ActorStatus.Running) {
         builtinAction.execute(actorCtx, params);
       } else {
@@ -1119,11 +1128,21 @@ function resolveActionsAndContext(actions, event, currentState, actorCtx) {
       }
     }
     if (actions) {
-      intermediateState = resolveActionsAndContext(actions, event, intermediateState, actorCtx);
+      intermediateState = resolveActionsAndContextWorker(intermediateState, event, actorCtx, actions, extra, retries);
     }
   }
   return intermediateState;
 }
+function resolveActionsAndContext(currentState, event, actorCtx, actions, deferredActorIds) {
+  const retries = deferredActorIds ? [] : undefined;
+  const nextState = resolveActionsAndContextWorker(currentState, event, actorCtx, actions, deferredActorIds && {
+    deferredActorIds
+  }, retries);
+  retries?.forEach(([builtinAction, params]) => {
+    builtinAction.retryResolve(actorCtx, nextState, params);
+  });
+  return nextState;
+}
 function macrostep(state, event, actorCtx) {
   let nextState = state;
   const states = [];
@@ -1180,7 +1199,7 @@ function stopStep(event, nextState, actorCtx) {
   for (const child of Object.values(nextState.children)) {
     actions.push(stop(child));
   }
-  return resolveActionsAndContext(actions, event, nextState, actorCtx);
+  return resolveActionsAndContext(nextState, event, actorCtx, actions);
 }
 function selectTransitions(event, nextState) {
   return nextState.machine.getTransitionData(nextState, event);

package/dist/{send-e5f0f3f6.esm.js → send-0b5eda0c.esm.js}

@@ -1,5 +1,5 @@
-import { j as cloneState, e as evaluateGuard } from './raise-6a68d0cc.esm.js';
-import { f as ActorStatus, k as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-d5fa7ce0.esm.js';
+import { j as cloneState, e as evaluateGuard } from './raise-b5cfe1bb.esm.js';
+import { f as ActorStatus, j as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-83f7f2d4.esm.js';
 
 function createSpawner(actorContext, {
   machine,
@@ -256,7 +256,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -281,7 +281,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -296,17 +296,22 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
-    to.send(event.type === XSTATE_ERROR ? createErrorActorEvent(actorContext.self.id, event.data) : event);
+    const {
+      to,
+      event
+    } = params;
+    actorContext?.system._relay(actorContext.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
 /**
@@ -327,6 +332,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }

package/dist/{send-4163d2af.development.cjs.js → send-3764c866.development.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-b4bfe138.development.cjs.js');
-var interpreter = require('./interpreter-a2236840.development.cjs.js');
+var guards_dist_xstateGuards = require('./raise-38b707c0.development.cjs.js');
+var interpreter = require('./interpreter-70ed62f2.development.cjs.js');
 
 function createSpawner(actorContext, {
   machine,
@@ -270,7 +270,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -295,7 +295,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -310,17 +310,22 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
-    to.send(event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorContext.self.id, event.data) : event);
+    const {
+      to,
+      event
+    } = params;
+    actorContext?.system._relay(actorContext.self, to, event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
 /**
@@ -344,6 +349,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }

package/dist/{send-7baeedcb.development.esm.js → send-9526366e.development.esm.js}

@@ -1,5 +1,5 @@
-import { j as cloneState, e as evaluateGuard } from './raise-6fbd4513.development.esm.js';
-import { f as ActorStatus, k as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-e4d2487f.development.esm.js';
+import { j as cloneState, e as evaluateGuard } from './raise-05f8b2a6.development.esm.js';
+import { f as ActorStatus, j as createErrorActorEvent, r as resolveReferencedActor, d as createActor, t as toArray, y as XSTATE_ERROR } from './interpreter-dee56dc8.development.esm.js';
 
 function createSpawner(actorContext, {
   machine,
@@ -268,7 +268,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -293,7 +293,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -308,17 +308,22 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
-    to.send(event.type === XSTATE_ERROR ? createErrorActorEvent(actorContext.self.id, event.data) : event);
+    const {
+      to,
+      event
+    } = params;
+    actorContext?.system._relay(actorContext.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
 /**
@@ -342,6 +347,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }

package/dist/{send-72e85cc6.cjs.js → send-fe94de2b.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var guards_dist_xstateGuards = require('./raise-90808d65.cjs.js');
-var interpreter = require('./interpreter-05e11c15.cjs.js');
+var guards_dist_xstateGuards = require('./raise-1dd65455.cjs.js');
+var interpreter = require('./interpreter-1301970f.cjs.js');
 
 function createSpawner(actorContext, {
   machine,
@@ -258,7 +258,7 @@ function resolveSendTo(actorContext, state, args, {
   event: eventOrExpr,
   id,
   delay
-}) {
+}, extra) {
   const delaysMap = state.machine.implementations.delays;
   if (typeof eventOrExpr === 'string') {
     throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
@@ -283,7 +283,7 @@ function resolveSendTo(actorContext, state, args, {
       // #_invokeid. If the target is the special term '#_invokeid', where invokeid is the invokeid of an SCXML session that the sending session has created by <invoke>, the Processor must add the event to the external queue of that session.
       targetActorRef = state.children[resolvedTarget.slice(2)];
     } else {
-      targetActorRef = state.children[resolvedTarget];
+      targetActorRef = extra?.deferredActorIds.includes(resolvedTarget) ? resolvedTarget : state.children[resolvedTarget];
     }
     if (!targetActorRef) {
       throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${state.machine.id}'.`);
@@ -298,17 +298,22 @@ function resolveSendTo(actorContext, state, args, {
     delay: resolvedDelay
   }];
 }
+function retryResolveSendTo(_, state, params) {
+  if (typeof params.to === 'string') {
+    params.to = state.children[params.to];
+  }
+}
 function executeSendTo(actorContext, params) {
   if (typeof params.delay === 'number') {
     actorContext.self.delaySend(params);
     return;
   }
-  const {
-    to,
-    event
-  } = params;
   actorContext.defer(() => {
-    to.send(event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorContext.self.id, event.data) : event);
+    const {
+      to,
+      event
+    } = params;
+    actorContext?.system._relay(actorContext.self, to, event.type === interpreter.XSTATE_ERROR ? interpreter.createErrorActorEvent(actorContext.self.id, event.data) : event);
   });
 }
 /**
@@ -329,6 +334,7 @@ function sendTo(to, eventOrExpr, options) {
   sendTo.id = options?.id;
   sendTo.delay = options?.delay;
   sendTo.resolve = resolveSendTo;
+  sendTo.retryResolve = retryResolveSendTo;
   sendTo.execute = executeSendTo;
   return sendTo;
 }