xstate 6.0.0-alpha.46 → 6.0.0-alpha.48

package/README.md

@@ -11,7 +11,9 @@
   <br />
 </p>
 
-XState is a state management and orchestration solution for JavaScript and TypeScript apps. It has _zero_ dependencies, and is useful for frontend and backend application logic.
+<!-- runtime dependencies and public entry points from package.json -->
+
+XState is a state management and orchestration solution for JavaScript and TypeScript apps. The main `xstate` entry point has _zero_ runtime dependencies; the optional `xstate/scxml` entry point uses an XML parser. XState is useful for frontend and backend application logic.
 
 It uses event-driven programming, state machines, statecharts, and the actor model to handle complex logic in predictable, robust, and visual ways. XState provides a powerful and flexible way to manage application and workflow state by allowing developers to model logic as actors and state machines.
 
@@ -27,6 +29,10 @@ It uses event-driven programming, state machines, statecharts, and the actor mod
 
 📑 Inspired by the [SCXML specification](https://www.w3.org/TR/scxml/)
 
+<!-- public SCXML entry point from src/scxml/index.ts -->
+
+Create machines from SCXML documents with the opt-in `xstate/scxml` entry point. See the [SCXML guide](../../docs/scxml.md).
+
 💬 Chat on the [Stately Discord Community](https://discord.gg/xstate)
 
 ✍️ Browse through the many [XState examples](https://github.com/statelyai/xstate/tree/main/examples)

package/dist/{StateMachine-9509c0bd.esm.js → StateMachine-8329769a.esm.js}

@@ -1,5 +1,5 @@
-import { Q as resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-9523f716.esm.js';
-import { g as assertValid } from './index-c7431a16.esm.js';
+import { Q as resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-27287c65.esm.js';
+import { a as assertValid } from './validation-05f1d517.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -385,14 +385,17 @@ function formatTransitions(stateNode) {
 function formatInitialTransition(stateNode, _target) {
   const targetString = typeof _target === 'object' && _target !== null ? _target.target : _target;
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
-  const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
-  if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state "${targetString}" not found on "#${stateNode.id}"`);
+  const to = typeof _target === 'object' && _target !== null ? _target.to : undefined;
+  const targetStrings = Array.isArray(targetString) ? targetString : targetString ? [targetString] : [];
+  const resolvedTargets = targetStrings.map(target => target.startsWith('#') ? stateNode.machine.getStateNodeById(target.slice(1)) : stateNode.states[target]);
+  if (resolvedTargets.some(target => !target)) {
+    throw new Error(`Initial state not found on "#${stateNode.id}"`);
   }
   const transition = {
     source: stateNode,
-    target: resolvedTarget ? [resolvedTarget] : undefined,
-    input
+    target: resolvedTargets.length ? resolvedTargets : undefined,
+    input,
+    to
   };
   return transition;
 }
@@ -1018,7 +1021,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{StateMachine-a5ede014.development.esm.js → StateMachine-88b3c26a.development.esm.js}

@@ -1,5 +1,5 @@
-import { Q as resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-f5277b31.development.esm.js';
-import { g as assertValid } from './index-3907b7aa.development.esm.js';
+import { Q as resolveRegisteredActorSource, R as allocateChildId, S as assertChildIdFree, T as reserveChildId, U as STATE_DELIMITER, V as mapValues, t as toArray, W as createInvokeId, Y as getDelayedTransitions, Z as getEventDescriptorKey, _ as getCandidates, $ as evaluateCandidate, a0 as formatTransition, a1 as NULL_EVENT, a2 as toTransitionConfigArray, a3 as createInvokeTimeoutEventId, a4 as matchesActorSession, a5 as formatRouteTransitions, a6 as resolveStateValue, a7 as getAllStateNodes, x as getStateNodes, a8 as createMachineSnapshot, a9 as isInFinalState, aa as createInertActorScope, ab as setInertActorScopeSnapshot, a as beginSpawnAllocation, ac as attachSnapshotActorRef, ad as macrostep, ae as isInertActorScope, af as setSnapshotActorRef, ag as cloneMachineSnapshot, ah as transitionNode, g as XSTATE_TIMER, m as matchesEventDescriptor, ai as getTransitionResult, aj as hasEffect, ak as createErrorPlatformEvent, al as withActorSelf, r as resolveActionsWithContext, am as takeSpawnAllocationCounters, an as mergeActorIdCounters, K as createInitEvent, ao as createSpawnEffect, ap as initialMicrostep, aq as toStatePath, ar as isStateId, as as getStateNodeByPath, at as getPersistedSnapshot, au as createRemoteActorRef, av as resolveReferencedActor, aw as createInvokeTimeoutEvent, ax as parseGeneratedActorId, ay as ACTOR_REF_TYPE, k as createActor } from './createActor-309d77eb.development.esm.js';
+import { a as assertValid } from './validation-e69470ad.development.esm.js';
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -403,14 +403,17 @@ function formatTransitions(stateNode) {
 function formatInitialTransition(stateNode, _target) {
   const targetString = typeof _target === 'object' && _target !== null ? _target.target : _target;
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
-  const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
-  if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}` );
+  const to = typeof _target === 'object' && _target !== null ? _target.to : undefined;
+  const targetStrings = Array.isArray(targetString) ? targetString : targetString ? [targetString] : [];
+  const resolvedTargets = targetStrings.map(target => target.startsWith('#') ? stateNode.machine.getStateNodeById(target.slice(1)) : stateNode.states[target]);
+  if (resolvedTargets.some(target => !target)) {
+    throw new Error(`Initial state node "${targetStrings.find((_, index) => !resolvedTargets[index])}" not found on parent state node #${stateNode.id}` );
   }
   const transition = {
     source: stateNode,
-    target: resolvedTarget ? [resolvedTarget] : undefined,
-    input
+    target: resolvedTargets.length ? resolvedTargets : undefined,
+    input,
+    to
   };
   return transition;
 }
@@ -1047,7 +1050,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{StateMachine-756e1335.cjs.js → StateMachine-b09d2b00.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-0816a84b.cjs.js');
-var dist_xstateActors = require('./index-7b9c4f77.cjs.js');
+var createActor = require('./createActor-9b41ade9.cjs.js');
+var validation = require('./validation-4561b43c.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -387,14 +387,17 @@ function formatTransitions(stateNode) {
 function formatInitialTransition(stateNode, _target) {
   const targetString = typeof _target === 'object' && _target !== null ? _target.target : _target;
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
-  const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
-  if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state "${targetString}" not found on "#${stateNode.id}"`);
+  const to = typeof _target === 'object' && _target !== null ? _target.to : undefined;
+  const targetStrings = Array.isArray(targetString) ? targetString : targetString ? [targetString] : [];
+  const resolvedTargets = targetStrings.map(target => target.startsWith('#') ? stateNode.machine.getStateNodeById(target.slice(1)) : stateNode.states[target]);
+  if (resolvedTargets.some(target => !target)) {
+    throw new Error(`Initial state not found on "#${stateNode.id}"`);
   }
   const transition = {
     source: stateNode,
-    target: resolvedTarget ? [resolvedTarget] : undefined,
-    input
+    target: resolvedTargets.length ? resolvedTargets : undefined,
+    input,
+    to
   };
   return transition;
 }
@@ -712,7 +715,7 @@ class StateMachine {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this, snapshot);
     if (this.validator) {
-      dist_xstateActors.assertValid(this.validator, {
+      validation.assertValid(this.validator, {
         kind: 'event',
         logic: this,
         event,
@@ -730,7 +733,7 @@ class StateMachine {
       }
       const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? createActor.attachSnapshotActorRef(resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
       if (this.validator) {
-        dist_xstateActors.assertValid(this.validator, {
+        validation.assertValid(this.validator, {
           kind: 'result',
           logic: this,
           snapshot: returnedSnapshot,
@@ -749,7 +752,7 @@ class StateMachine {
     const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : createActor.attachSnapshotActorRef(resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
     const effects = this._collectEffects(microsteps);
     if (this.validator) {
-      dist_xstateActors.assertValid(this.validator, {
+      validation.assertValid(this.validator, {
         kind: 'result',
         logic: this,
         snapshot: returnedSnapshot,
@@ -941,7 +944,7 @@ class StateMachine {
   }
   initialTransition(input, actorScope) {
     if (this.validator) {
-      dist_xstateActors.assertValid(this.validator, {
+      validation.assertValid(this.validator, {
         kind: 'input',
         logic: this,
         input
@@ -961,7 +964,7 @@ class StateMachine {
       const returnedSnapshot = usesInertScope ? createActor.attachSnapshotActorRef(resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope, true);
       const effects = this._collectEffects(microsteps);
       if (this.validator) {
-        dist_xstateActors.assertValid(this.validator, {
+        validation.assertValid(this.validator, {
           kind: 'result',
           logic: this,
           snapshot: returnedSnapshot,
@@ -1020,7 +1023,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{StateMachine-fa133051.development.cjs.js → StateMachine-b3a890bf.development.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-f6e6146f.development.cjs.js');
-var dist_xstateActors = require('./index-1e1e1cba.development.cjs.js');
+var createActor = require('./createActor-cc3d6dde.development.cjs.js');
+var validation = require('./validation-f2714a35.development.cjs.js');
 
 function createSpawner(actorScope, actors, spawnedChildren) {
   return (src, options) => {
@@ -405,14 +405,17 @@ function formatTransitions(stateNode) {
 function formatInitialTransition(stateNode, _target) {
   const targetString = typeof _target === 'object' && _target !== null ? _target.target : _target;
   const input = typeof _target === 'object' && _target !== null ? _target.input : undefined;
-  const resolvedTarget = typeof targetString === 'string' ? stateNode.states[targetString] : undefined;
-  if (!resolvedTarget && targetString) {
-    throw new Error(`Initial state node "${targetString}" not found on parent state node #${stateNode.id}` );
+  const to = typeof _target === 'object' && _target !== null ? _target.to : undefined;
+  const targetStrings = Array.isArray(targetString) ? targetString : targetString ? [targetString] : [];
+  const resolvedTargets = targetStrings.map(target => target.startsWith('#') ? stateNode.machine.getStateNodeById(target.slice(1)) : stateNode.states[target]);
+  if (resolvedTargets.some(target => !target)) {
+    throw new Error(`Initial state node "${targetStrings.find((_, index) => !resolvedTargets[index])}" not found on parent state node #${stateNode.id}` );
   }
   const transition = {
     source: stateNode,
-    target: resolvedTarget ? [resolvedTarget] : undefined,
-    input
+    target: resolvedTargets.length ? resolvedTargets : undefined,
+    input,
+    to
   };
   return transition;
 }
@@ -741,7 +744,7 @@ class StateMachine {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this, snapshot);
     if (this.validator) {
-      dist_xstateActors.assertValid(this.validator, {
+      validation.assertValid(this.validator, {
         kind: 'event',
         logic: this,
         event,
@@ -759,7 +762,7 @@ class StateMachine {
       }
       const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? createActor.attachSnapshotActorRef(resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
       if (this.validator) {
-        dist_xstateActors.assertValid(this.validator, {
+        validation.assertValid(this.validator, {
           kind: 'result',
           logic: this,
           snapshot: returnedSnapshot,
@@ -778,7 +781,7 @@ class StateMachine {
     const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : createActor.attachSnapshotActorRef(resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
     const effects = this._collectEffects(microsteps);
     if (this.validator) {
-      dist_xstateActors.assertValid(this.validator, {
+      validation.assertValid(this.validator, {
         kind: 'result',
         logic: this,
         snapshot: returnedSnapshot,
@@ -970,7 +973,7 @@ class StateMachine {
   }
   initialTransition(input, actorScope) {
     if (this.validator) {
-      dist_xstateActors.assertValid(this.validator, {
+      validation.assertValid(this.validator, {
         kind: 'input',
         logic: this,
         input
@@ -990,7 +993,7 @@ class StateMachine {
       const returnedSnapshot = usesInertScope ? createActor.attachSnapshotActorRef(resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope, true);
       const effects = this._collectEffects(microsteps);
       if (this.validator) {
-        dist_xstateActors.assertValid(this.validator, {
+        validation.assertValid(this.validator, {
           kind: 'result',
           logic: this,
           snapshot: returnedSnapshot,
@@ -1049,7 +1052,11 @@ class StateMachine {
   restoreSnapshot(snapshot, actorScope) {
     const usesInertScope = !actorScope;
     const resolvedActorScope = actorScope ?? createActor.createInertActorScope(this);
-    const persistedMachine = snapshot.machine;
+    const snapshotMachine = snapshot.machine;
+    // A live machine snapshot carries its producing machine so helpers such as
+    // `matches()` can resolve state nodes. That runtime association is not the
+    // persisted `{ id, version }` identity written by getPersistedSnapshot().
+    const persistedMachine = snapshotMachine && typeof snapshotMachine === 'object' && typeof snapshotMachine.transition === 'function' && 'root' in snapshotMachine ? undefined : snapshotMachine;
     const legacyPersistedVersion = snapshot.version;
     const persistedVersion = typeof persistedMachine?.version === 'string' ? persistedMachine.version : legacyPersistedVersion;
     if (legacyPersistedVersion !== undefined && persistedMachine?.version !== undefined && persistedMachine.version !== legacyPersistedVersion) {

package/dist/{createActor-9523f716.esm.js → createActor-27287c65.esm.js}

@@ -898,12 +898,15 @@ function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubsc
     },
     stop: actor => {
       if (actor) {
-        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actor);
+        // enq.stop accepts the consumer ActorRef contract; refs handed to
+        // machine code are always full actor instances at runtime.
+        const actorInstance = actor;
+        const action = pushBuiltInAction(actions, builtInActions['@xstate.stop'], actorScope, actorInstance);
         action.childUpdate = {
           type: 'remove',
-          actor
+          actor: actorInstance
         };
-        recordStoppedChild(actorScope, actor);
+        recordStoppedChild(actorScope, actorInstance);
       }
     }
   };
@@ -2277,7 +2280,8 @@ function resolveHistoryDefaultTransition(stateNode) {
     target,
     source: stateNode,
     reenter: false,
-    eventType: ''
+    eventType: '',
+    to: stateNode.config._historyDefaultTransition
   };
 }
 function isHistoryNode(stateNode) {
@@ -2291,7 +2295,9 @@ function getInitialStateNodes(stateNode) {
     }
     set.add(descStateNode);
     if (descStateNode.type === 'compound') {
-      iter(descStateNode.initial.target[0]);
+      for (const target of descStateNode.initial.target ?? []) {
+        iter(target);
+      }
     } else if (descStateNode.type === 'parallel') {
       for (const child of getChildren(descStateNode)) {
         iter(child);
@@ -2544,6 +2550,18 @@ function getTransitionDomain(transition, snapshot, resolveTransition) {
     targets,
     reenter
   } = resolveTransition(transition);
+  if (transition._transitionDomain) {
+    if (transition._transitionDomain === 'internal' && transition.source.type === 'compound' && targetStates.every(target => isDescendant(target, transition.source))) {
+      return transition.source;
+    }
+    const [head, ...tail] = targetStates.concat(transition.source);
+    for (const ancestor of getProperAncestors(head, undefined)) {
+      if (ancestor.type === 'compound' && tail.every(stateNode => isDescendant(stateNode, ancestor))) {
+        return ancestor;
+      }
+    }
+    return;
+  }
 
   // A history target that restores the source itself must exit and reenter
   // the source (SCXML domain = the source's ancestor), unlike a plain
@@ -2596,12 +2614,28 @@ function computeExitSet(transitions, stateNodeSet, snapshot, resolveTransition)
   return [...statesToExit];
 }
 function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+  const initialStateNodes = [...getInitialStateNodes(root)];
+  const statesForDefaultEntry = new Set();
+  const collectDefaultEntryStates = stateNode => {
+    if (stateNode.type === 'compound') {
+      statesForDefaultEntry.add(stateNode);
+      for (const target of stateNode.initial.target ?? []) {
+        collectDefaultEntryStates(target);
+      }
+    } else if (stateNode.type === 'parallel') {
+      for (const child of getChildren(stateNode)) {
+        collectDefaultEntryStates(child);
+      }
+    }
+  };
+  collectDefaultEntryStates(root);
   return microstep([{
-    target: [...getInitialStateNodes(root)],
+    target: initialStateNodes.filter(stateNode => !initialStateNodes.some(other => other !== stateNode && isDescendant(other, stateNode))),
     source: root,
     reenter: true,
     eventType: null,
-    toJSON: null
+    toJSON: null,
+    _statesForDefaultEntry: [...statesForDefaultEntry]
   }], preInitialState, actorScope, initEvent, true, internalQueue);
 }
 
@@ -2780,6 +2814,7 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
       // in other words, those are states for which initial actions should be executed
       // when we target `#deep_child` initial actions of its ancestors shouldn't be executed
       const statesForDefaultEntry = new Set();
+      const historyDefaultsByParent = new Map();
       const addAncestorStatesToEnter = (ancestors, reentrancyDomain) => {
         for (const anc of ancestors) {
           if (!reentrancyDomain || isDescendant(anc, reentrancyDomain)) {
@@ -2808,6 +2843,11 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
             }
           } else {
             const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
+            const historyParent = stateNode.parent;
+            statesForDefaultEntry.add(historyParent);
+            const defaults = historyDefaultsByParent.get(historyParent) ?? [];
+            defaults.push(historyDefaultTransition);
+            historyDefaultsByParent.set(historyParent, defaults);
             const {
               targets
             } = getCurrentTransitionResult(historyDefaultTransition);
@@ -2825,13 +2865,19 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           return;
         }
         if (stateNode.type === 'compound') {
-          const [initialState] = getCurrentTransitionResult(stateNode.initial).targets;
-          if (!isHistoryNode(initialState)) {
-            statesToEnter.add(initialState);
-            statesForDefaultEntry.add(initialState);
+          const initialStates = getCurrentTransitionResult(stateNode.initial).targets ?? [];
+          for (const initialState of initialStates) {
+            if (!isHistoryNode(initialState)) {
+              statesToEnter.add(initialState);
+            }
+          }
+          statesForDefaultEntry.add(stateNode);
+          for (const initialState of initialStates) {
+            addDescendantStatesToEnter(initialState);
+          }
+          for (const initialState of initialStates) {
+            addAncestorStatesToEnter(getProperAncestors(initialState, stateNode), undefined);
           }
-          addDescendantStatesToEnter(initialState);
-          addAncestorStatesToEnter(getProperAncestors(initialState, stateNode), undefined);
           return;
         }
         if (stateNode.type === 'parallel') {
@@ -2873,7 +2919,9 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
         }
       }
       if (isInitial) {
-        statesForDefaultEntry.add(currentSnapshot.machine.root);
+        for (const stateNode of filteredTransitions[0]._statesForDefaultEntry ?? [currentSnapshot.machine.root]) {
+          statesForDefaultEntry.add(stateNode);
+        }
       }
       const stateInputMap = {
         ...currentSnapshot._stateInputs
@@ -2958,17 +3006,28 @@ function microstep(transitions, currentSnapshot, actorScope, event, isInitial, i
           nextState.context = context;
         }
         if (statesForDefaultEntry.has(stateNodeToEnter)) {
-          const {
-            actions: initialActions,
-            input: initialInput
-          } = getTransitionResult(stateNodeToEnter.initial, nextState, event, actorScope);
-          if (initialActions) {
-            actions.push(...initialActions);
-          }
-          if (initialInput && stateNodeToEnter.initial?.target) {
-            for (const targetNode of stateNodeToEnter.initial.target) {
-              stateInputMap[targetNode.id] = initialInput;
-              stateInputsChanged = true;
+          const defaultTransitions = [stateNodeToEnter.initial, ...(historyDefaultsByParent.get(stateNodeToEnter) ?? [])].filter(Boolean);
+          for (const defaultTransition of defaultTransitions) {
+            const {
+              actions: initialActions,
+              context: initialContext,
+              input: initialInput,
+              internalEvents: initialInternalEvents
+            } = getTransitionResult(defaultTransition, nextState, event, actorScope);
+            if (initialActions) {
+              actions.push(...initialActions);
+            }
+            if (initialInternalEvents?.length) {
+              internalQueue.push(...initialInternalEvents);
+            }
+            if (initialContext !== undefined) {
+              nextState.context = mergeContextPatch(nextState.context, initialContext);
+            }
+            if (initialInput && defaultTransition.target) {
+              for (const targetNode of defaultTransition.target) {
+                stateInputMap[targetNode.id] = initialInput;
+                stateInputsChanged = true;
+              }
             }
           }
         }