xstate 6.0.0-alpha.47 → 6.0.0-alpha.49

package/README.md

@@ -11,10 +11,35 @@
   <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.
 
+For flat finite state machines, `xstate/fsm` provides a self-contained compact
+runtime and a specialized actor:
+
+<!-- public exports from packages/core/src/fsm/index.ts; exact capabilities documented in docs/fsm.md -->
+
+```ts
+import { createFSM, createFSMActor } from 'xstate/fsm';
+
+const logic = createFSM({
+  initial: 'inactive',
+  states: {
+    inactive: { on: { toggle: { target: 'active' } } },
+    active: { on: { toggle: { target: 'inactive' } } }
+  }
+});
+
+const actor = createFSMActor(logic).start();
+```
+
+See the [exact supported surface](https://stately.ai/docs/fsm). Use the root `xstate`
+entry point for compound or parallel statecharts, invocation, named sources,
+schemas, serialization and inspection.
+
 ### ✨ Create state machines visually in Stately Studio → [state.new](https://state.new)
 
 ---
@@ -27,6 +52,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-7046f677.cjs.js → StateMachine-0adb3a70.cjs.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-bfe8b6bd.cjs.js');
-var dist_xstateActors = require('./index-b3fe59bc.cjs.js');
+var createActor = require('./createActor-b4dd05ae.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,

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

@@ -1,7 +1,7 @@
 'use strict';
 
-var createActor = require('./createActor-6736cbbe.development.cjs.js');
-var dist_xstateActors = require('./index-0f498ef2.development.cjs.js');
+var createActor = require('./createActor-a1e0dffb.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,

package/dist/{StateMachine-74929087.esm.js → StateMachine-2af31c11.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-915ea40c.esm.js';
-import { g as assertValid } from './index-b051c924.esm.js';
+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 { 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;
 }

package/dist/{StateMachine-ee10f67e.development.esm.js → StateMachine-faf50c5c.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-ff132afa.development.esm.js';
-import { g as assertValid } from './index-70d56425.development.esm.js';
+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 { 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;
 }

package/dist/{createActor-915ea40c.esm.js → createActor-268165d4.esm.js}

@@ -2280,7 +2280,8 @@ function resolveHistoryDefaultTransition(stateNode) {
     target,
     source: stateNode,
     reenter: false,
-    eventType: ''
+    eventType: '',
+    to: stateNode.config._historyDefaultTransition
   };
 }
 function isHistoryNode(stateNode) {
@@ -2294,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);
@@ -2547,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
@@ -2599,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);
 }
 
@@ -2783,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)) {
@@ -2811,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);
@@ -2828,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') {
@@ -2876,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
@@ -2961,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;
+              }
             }
           }
         }
@@ -5699,4 +5755,4 @@ function createActor(logic, options) {
   return new Actor(logic, options);
 }
 
-export { evaluateCandidate as $, Actor as A, checkStateIn as B, pathToStateValue as C, toObserver as D, executeEffects as E, isBuiltInExecutableAction as F, deliverEvent as G, runStep as H, stopActor as I, terminateActor as J, createInitEvent as K, createCustomEffect as L, XSTATE_LOGIC_EFFECT_START as M, XSTATE_LOGIC_EFFECT_RESOLVE as N, XSTATE_LOGIC_EFFECT_REJECT as O, createEmitEffect as P, resolveRegisteredActorSource as Q, allocateChildId as R, assertChildIdFree as S, reserveChildId as T, STATE_DELIMITER as U, mapValues as V, createInvokeId as W, XSTATE_INIT as X, getDelayedTransitions as Y, getEventDescriptorKey as Z, getCandidates as _, beginSpawnAllocation as a, formatTransition as a0, NULL_EVENT as a1, toTransitionConfigArray as a2, createInvokeTimeoutEventId as a3, matchesActorSession as a4, formatRouteTransitions as a5, resolveStateValue as a6, getAllStateNodes as a7, createMachineSnapshot as a8, isInFinalState as a9, getProperAncestors as aA, isRemoteActorRef as aB, getActorIdPrefix as aC, getAllOwnEvents as aD, matchesEvent as aE, encodeAddressSegment as aF, getRootActorId as aG, RUNTIME_OPERATIONS as aH, withSystemInspector as aI, getSnapshotActorRef as aJ, withExecutionIdentity as aK, createInertActorScope as aa, setInertActorScopeSnapshot as ab, attachSnapshotActorRef as ac, macrostep as ad, isInertActorScope as ae, setSnapshotActorRef as af, cloneMachineSnapshot as ag, transitionNode as ah, getTransitionResult as ai, hasEffect as aj, createErrorPlatformEvent as ak, withActorSelf as al, takeSpawnAllocationCounters as am, mergeActorIdCounters as an, createSpawnEffect as ao, initialMicrostep as ap, toStatePath as aq, isStateId as ar, getStateNodeByPath as as, getPersistedSnapshot as at, createRemoteActorRef as au, resolveReferencedActor as av, createInvokeTimeoutEvent as aw, parseGeneratedActorId as ax, ACTOR_REF_TYPE as ay, hasAmbientInspector as az, builtInActions as b, createTransitionEnqueue as c, deriveDeferredStarts as d, XSTATE_STOP as e, finalizeTransitionResult as f, XSTATE_TIMER as g, createSendToEffect as h, isLazyActorScope as i, isAtomicStateNode as j, createActor as k, createListenerLogic as l, matchesEventDescriptor as m, createSubscriptionLogic as n, listenerLogic as o, parseDelayToMilliseconds as p, getInitialSnapshot as q, resolveActionsWithContext as r, subscriptionLogic as s, toArray as t, getNextSnapshot as u, isMachineSnapshot as v, withActorScope as w, getStateNodes as x, getAllOwnEventDescriptors as y, matchesState as z };
+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 };