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

package/dist/xstate.development.esm.js

@@ -1,9 +1,13 @@
-export { T as TimeoutError, c as createAsyncLogic, a as createCallbackLogic, b as createEmptyActor, d as createEventObservableLogic, e as createLogic, f as createObservableLogic } from './index-70d56425.development.esm.js';
-import { m as matchesEventDescriptor, t as toArray$1, b as builtInActions, a as beginSpawnAllocation, X as XSTATE_INIT, f as finalizeTransitionResult, d as deriveDeferredStarts, c as createTransitionEnqueue, w as withActorScope, e as XSTATE_STOP, r as resolveActionsWithContext, g as XSTATE_TIMER, h as createSendToEffect, i as isLazyActorScope, p as parseDelayToMilliseconds, j as isAtomicStateNode, k as createActor } from './createActor-ff132afa.development.esm.js';
-export { A as Actor, y as __unsafe_getAllOwnEventDescriptors, B as checkStateIn, k as createActor, l as createListenerLogic, n as createSubscriptionLogic, G as deliverEvent, E as executeEffects, q as getInitialSnapshot, u as getNextSnapshot, x as getStateNodes, F as isBuiltInExecutableAction, v as isMachineSnapshot, o as listenerLogic, z as matchesState, C as pathToStateValue, H as runStep, I as stopActor, s as subscriptionLogic, J as terminateActor, D as toObserver } from './createActor-ff132afa.development.esm.js';
-import { S as StateMachine } from './StateMachine-ee10f67e.development.esm.js';
-export { S as StateMachine, a as StateNode } from './StateMachine-ee10f67e.development.esm.js';
-export { c as getEffectDescriptor, a as getInitialMicrosteps, g as getMicrosteps, b as getNextTransitions, i as initialTransition, t as transition } from './effectDescriptor-fbe67d5a.development.esm.js';
+export { TimeoutError, createAsyncLogic, createCallbackLogic, createEmptyActor, createEventObservableLogic, createLogic, createObservableLogic } from './xstate-actors.development.esm.js';
+import { m as matchesEventDescriptor, t as toArray, p as parseDelayToMilliseconds, i as isAtomicStateNode, c as createActor } from './createActor-88709f74.development.esm.js';
+export { A as Actor, h as __unsafe_getAllOwnEventDescriptors, k as checkStateIn, c as createActor, a as createListenerLogic, b as createSubscriptionLogic, u as deliverEvent, q as executeEffects, g as getInitialSnapshot, d as getNextSnapshot, f as getStateNodes, r as isBuiltInExecutableAction, e as isMachineSnapshot, l as listenerLogic, j as matchesState, n as pathToStateValue, v as runStep, w as stopActor, s as subscriptionLogic, x as terminateActor, o as toObserver } from './createActor-88709f74.development.esm.js';
+import { c as createMachine } from './types-adda3842.development.esm.js';
+export { S as SpecialTargets, c as createMachine, a as createStateConfig } from './types-adda3842.development.esm.js';
+export { c as createFSM } from './fsm-e18a7cb4.development.esm.js';
+import { S as StateMachine } from './StateMachine-faf50c5c.development.esm.js';
+export { S as StateMachine, a as StateNode } from './StateMachine-faf50c5c.development.esm.js';
+export { c as getEffectDescriptor, a as getInitialMicrosteps, g as getMicrosteps, b as getNextTransitions, i as initialTransition, t as transition } from './effectDescriptor-39d22100.development.esm.js';
+import './validation-e69470ad.development.esm.js';
 
 /**
  * Asserts that the given event object is of the specified type or types. Throws
@@ -29,7 +33,7 @@ export { c as getEffectDescriptor, a as getInitialMicrosteps, g as getMicrosteps
  * ```
  */
 function assertEvent(event, type) {
-  const types = toArray$1(type);
+  const types = toArray(type);
   const matches = types.some(descriptor => matchesEventDescriptor(event.type, descriptor));
   if (!matches) {
     const typesText = types.length === 1 ? `type matching "${types[0]}"` : `one of types matching "${types.join('", "')}"`;
@@ -37,453 +41,11 @@ function assertEvent(event, type) {
   }
 }
 
-/**
- * Creates a state machine (statechart) with the given configuration.
- *
- * The state machine represents the pure logic of a state machine actor.
- *
- * @example
- *
- * ```ts
- * import { createMachine } from 'xstate';
- *
- * const lightMachine = createMachine({
- *   id: 'light',
- *   initial: 'green',
- *   states: {
- *     green: {
- *       on: {
- *         TIMER: { target: 'yellow' }
- *       }
- *     },
- *     yellow: {
- *       on: {
- *         TIMER: { target: 'red' }
- *       }
- *     },
- *     red: {
- *       on: {
- *         TIMER: { target: 'green' }
- *       }
- *     }
- *   }
- * });
- *
- * const lightActor = createActor(lightMachine);
- * lightActor.start();
- *
- * lightActor.send({ type: 'TIMER' });
- * ```
- *
- * @param config The state machine configuration.
- * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
- *   to provide machine sources instead.
- */
-// Overload 1: With schemas.context — context type inferred from schema
-
-// Overload 2: Without schemas.context — context type inferred from config.context
-
-// Implementation
-function createMachine(config) {
-  return new StateMachine(config);
-}
-function createStateConfig(config) {
-  return config;
-}
-
-const emptySources = {
-  actions: {},
-  actors: {},
-  guards: {},
-  delays: {}
-};
-const emptyExecutableActions = [];
-const emptyRawActions = [];
-const builtInActionSet = new Set(Object.values(builtInActions));
-function toArray(value) {
-  return value === undefined ? [] : Array.isArray(value) ? value : [value];
-}
-function resolveContext(context, input) {
-  return typeof context === 'function' ? context({
-    input
-  }) : context ?? {};
-}
-function resolveTransitionContext(context, args) {
-  return typeof context === 'function' ? context(args) : context;
-}
-function resolveInput(input, context, event) {
-  return typeof input === 'function' ? input({
-    context,
-    event
-  }) : input;
-}
-function mergeContextPatch(context, patch) {
-  for (const key of Object.keys(patch)) {
-    if (!Object.prototype.hasOwnProperty.call(context, key) || !Object.is(context[key], patch[key])) {
-      return {
-        ...context,
-        ...patch
-      };
-    }
-  }
-  return context;
-}
-function createSnapshot(value, context, input, machine, stateInput) {
-  return {
-    status: 'active',
-    output: undefined,
-    error: undefined,
-    value,
-    context,
-    input,
-    children: {},
-    timers: {},
-    _nextTimerId: 0,
-    _stateInput: stateInput,
-    machine
-  };
-}
-function cloneSnapshot(snapshot, value, context, stateInput) {
-  return {
-    status: snapshot.status,
-    output: snapshot.output,
-    error: snapshot.error,
-    value,
-    context,
-    input: snapshot.input,
-    children: snapshot.children,
-    timers: snapshot.timers,
-    _nextTimerId: snapshot._nextTimerId,
-    // Carried across state changes: dropping these would let a later spawn
-    // reuse the id of a still-running child.
-    _nextActorIds: snapshot._nextActorIds,
-    _stateInput: stateInput,
-    machine: snapshot.machine
-  };
-}
-function stopSnapshot(snapshot) {
-  return {
-    status: 'stopped',
-    output: undefined,
-    error: undefined,
-    value: snapshot.value,
-    context: snapshot.context,
-    input: undefined,
-    children: snapshot.children,
-    timers: snapshot.timers,
-    _nextTimerId: snapshot._nextTimerId,
-    _nextActorIds: snapshot._nextActorIds,
-    _stateInput: snapshot._stateInput,
-    machine: snapshot.machine
-  };
-}
-function assertNoStringTransitions(config) {
-  for (const [stateKey, stateConfig] of Object.entries(config.states)) {
-    for (const [eventType, transitionConfig] of Object.entries(stateConfig.on ?? {})) {
-      for (const transition of toArray(transitionConfig)) {
-        if (typeof transition === 'string') {
-          const target = transition;
-          throw new Error(`Invalid transition for "${stateKey}.${eventType}": use { target: "${target}" } instead of a string target.`);
-        }
-      }
-    }
-  }
-}
-function resolveSimpleEnqueuedActions(rawActions) {
-  const executableActions = [];
-  for (const action of rawActions) {
-    if (!action || typeof action !== 'object' || !('action' in action) || typeof action.action !== 'function' || builtInActionSet.has(action.action) || '_special' in action.action) {
-      return undefined;
-    }
-    executableActions.push({
-      kind: 'action',
-      type: action.action.name || '(anonymous)',
-      params: undefined,
-      args: action.args,
-      action: action.action,
-      exec() {
-        return this.action?.(...this.args);
-      }
-    });
-  }
-  return executableActions;
-}
-function createFSM(config) {
-  const machine = {
-    id: config.id ?? '(fsm)',
-    sources: emptySources
-  };
-  assertNoStringTransitions(config);
-  const runActions = (snapshot, event, actorScope, rawActions) => {
-    if (!rawActions?.length) {
-      return [snapshot, emptyExecutableActions];
-    }
-    const simpleExecutableActions = resolveSimpleEnqueuedActions(rawActions);
-    if (simpleExecutableActions) {
-      return [snapshot, simpleExecutableActions];
-    }
-    return resolveActionsWithContext(snapshot, event, actorScope, rawActions);
-  };
-  const runStateActions = (snapshot, event, actorScope, actionsConfig, stateInput, internalQueue) => {
-    if (!actionsConfig) {
-      return [snapshot, emptyExecutableActions];
-    }
-    const actions = [];
-    const enq = createTransitionEnqueue(actorScope, actions, internalQueue, true);
-    let context;
-    const actionCount = Array.isArray(actionsConfig) ? actionsConfig.length : 1;
-    for (let i = 0; i < actionCount; i++) {
-      const action = Array.isArray(actionsConfig) ? actionsConfig[i] : actionsConfig;
-      const result = action(withActorScope({
-        context: context ?? snapshot.context,
-        event: event,
-        input: stateInput,
-        value: snapshot.value,
-        children: snapshot.children
-      }, actorScope), enq);
-      if (result?.context !== undefined) {
-        const currentContext = context ?? snapshot.context;
-        const nextContext = mergeContextPatch(currentContext, result.context);
-        if (nextContext !== currentContext) {
-          context = nextContext;
-        }
-      }
-    }
-    const nextSnapshot = context !== undefined ? cloneSnapshot(snapshot, snapshot.value, context, snapshot._stateInput) : snapshot;
-    return runActions(nextSnapshot, event, actorScope, actions);
-  };
-  const selectTransition = (snapshot, event, actorScope, internalQueue) => {
-    const state = config.states[snapshot.value];
-    const transitionsConfig = state?.on?.[event.type];
-    if (!transitionsConfig) {
-      return undefined;
-    }
-    const transitionCount = Array.isArray(transitionsConfig) ? transitionsConfig.length : 1;
-    for (let i = 0; i < transitionCount; i++) {
-      const transition = Array.isArray(transitionsConfig) ? transitionsConfig[i] : transitionsConfig;
-      const args = withActorScope({
-        context: snapshot.context,
-        event,
-        input: snapshot.input,
-        value: snapshot.value,
-        children: snapshot.children
-      }, actorScope);
-      if (typeof transition === 'function') {
-        const actions = [];
-        const enq = createTransitionEnqueue(actorScope, actions, internalQueue, true);
-        const result = transition(args, enq);
-        if (!result) {
-          if (actions.length) {
-            return {
-              actions
-            };
-          }
-          continue;
-        }
-        return {
-          target: result.target,
-          context: result.context,
-          input: result.input,
-          actions
-        };
-      }
-      if ('guard' in transition && transition.guard && !transition.guard(args)) {
-        continue;
-      }
-      return {
-        target: transition.target,
-        context: resolveTransitionContext(transition.context, args),
-        input: transition.input,
-        actions: 'actions' in transition && transition.actions ? toArray(transition.actions) : emptyRawActions
-      };
-    }
-    return undefined;
-  };
-  const transitionCore = (snapshot, event, actorScope) => {
-    if (snapshot.status !== 'active') {
-      return [snapshot, []];
-    }
-    if (event.type === XSTATE_STOP) {
-      const actions = [];
-      const enqueue = createTransitionEnqueue(actorScope, actions, []);
-      for (const id of Object.keys(snapshot.timers)) {
-        enqueue.cancel(id);
-      }
-      const [withoutTimers, cancelEffects] = resolveActionsWithContext(snapshot, event, actorScope, actions);
-      return [stopSnapshot(withoutTimers), cancelEffects];
-    }
-    if (event.type === XSTATE_TIMER) {
-      const timer = snapshot.timers[event.id];
-      if (!timer) {
-        return [snapshot, emptyExecutableActions];
-      }
-      const timers = {
-        ...snapshot.timers
-      };
-      delete timers[timer.id];
-      const nextSnapshot = {
-        ...snapshot,
-        timers
-      };
-      if (timer.type === '@xstate.raise') {
-        return transitionCore(nextSnapshot, timer.event, actorScope);
-      }
-      const target = timer.target === 'self' ? actorScope.self : timer.target;
-      return [nextSnapshot, [createSendToEffect(actorScope, target, timer.event)]];
-    }
-    const stateConfig = config.states[snapshot.value];
-    const directTransition = stateConfig?.on?.[event.type];
-    if (!directTransition) {
-      return [snapshot, emptyExecutableActions];
-    }
-    if (!Array.isArray(directTransition) && typeof directTransition !== 'function' && !('guard' in directTransition) && !('actions' in directTransition && directTransition.actions) && typeof directTransition.input !== 'function') {
-      const target = directTransition.target ?? snapshot.value;
-      const stateChanged = target !== snapshot.value;
-      if (stateChanged && (stateConfig.exit || config.states[target]?.entry)) ; else {
-        const hasContext = directTransition.context !== undefined;
-        const hasInput = directTransition.input !== undefined;
-        const resolvedContext = !isLazyActorScope(actorScope) ? resolveTransitionContext(directTransition.context, {
-          context: snapshot.context,
-          event,
-          input: snapshot.input,
-          value: snapshot.value,
-          self: actorScope.self,
-          system: actorScope.system,
-          parent: actorScope.self._parent,
-          children: snapshot.children
-        }) : typeof directTransition.context === 'function' ? directTransition.context(withActorScope({
-          context: snapshot.context,
-          event,
-          input: snapshot.input,
-          value: snapshot.value,
-          children: snapshot.children
-        }, actorScope)) : directTransition.context;
-        const context = hasContext && resolvedContext ? mergeContextPatch(snapshot.context, resolvedContext) : snapshot.context;
-        if (!stateChanged && context === snapshot.context && !hasInput && snapshot._stateInput === undefined) {
-          return [snapshot, emptyExecutableActions];
-        }
-        return [cloneSnapshot(snapshot, target, context, hasInput ? resolveInput(directTransition.input, context, event) : undefined), emptyExecutableActions];
-      }
-    }
-    if (typeof directTransition === 'function' && directTransition.length < 2 && !stateConfig?.exit) {
-      const result = directTransition(withActorScope({
-        context: snapshot.context,
-        event,
-        input: snapshot.input,
-        value: snapshot.value,
-        children: snapshot.children
-      }, actorScope), undefined);
-      if (result) {
-        const target = result.target ?? snapshot.value;
-        if (!config.states[target]?.entry) {
-          const hasContext = result.context !== undefined;
-          const hasInput = result.input !== undefined;
-          const context = hasContext && result.context ? mergeContextPatch(snapshot.context, result.context) : snapshot.context;
-          if (target === snapshot.value && context === snapshot.context && !hasInput && snapshot._stateInput === undefined) {
-            return [snapshot, emptyExecutableActions];
-          }
-          return [cloneSnapshot(snapshot, target, context, hasInput ? resolveInput(result.input, context, event) : undefined), emptyExecutableActions];
-        }
-      }
-    }
-    let nextSnapshot = snapshot;
-    const executableActions = [];
-    const internalQueue = [event];
-    let iterations = 0;
-    while (internalQueue.length) {
-      if (++iterations > 1000) {
-        throw new Error('FSM microstep count exceeded 1000');
-      }
-      const nextEvent = internalQueue.shift();
-      const selected = selectTransition(nextSnapshot, nextEvent, actorScope, internalQueue);
-      if (!selected) {
-        continue;
-      }
-      const nextValue = selected.target ?? nextSnapshot.value;
-      const stateChanged = nextValue !== nextSnapshot.value;
-      if (stateChanged) {
-        const [exited, exitActions] = runStateActions(nextSnapshot, nextEvent, actorScope, config.states[nextSnapshot.value]?.exit, nextSnapshot._stateInput, internalQueue);
-        nextSnapshot = exited;
-        executableActions.push(...exitActions);
-      }
-      let context = nextSnapshot.context;
-      if (selected.context !== undefined) {
-        context = mergeContextPatch(context, selected.context);
-      }
-      const hasInput = selected.input !== undefined;
-      const stateInput = hasInput ? resolveInput(selected.input, context, nextEvent) : undefined;
-      if (stateChanged || context !== nextSnapshot.context || hasInput || nextSnapshot._stateInput !== undefined) {
-        nextSnapshot = cloneSnapshot(nextSnapshot, nextValue, context, stateInput);
-      }
-      const [afterTransition, transitionActions] = runActions(nextSnapshot, nextEvent, actorScope, selected.actions);
-      nextSnapshot = afterTransition;
-      executableActions.push(...transitionActions);
-      if (stateChanged) {
-        const [entered, entryActions] = runStateActions(nextSnapshot, nextEvent, actorScope, config.states[nextValue]?.entry, stateInput, internalQueue);
-        nextSnapshot = entered;
-        executableActions.push(...entryActions);
-      }
-    }
-    return [nextSnapshot, executableActions];
-  };
-  const transition = (...args) => {
-    beginSpawnAllocation(args[2]);
-    const [nextSnapshot, effects] = transitionCore(...args);
-    return finalizeTransitionResult(args[2], args[0], [nextSnapshot, [...effects, ...deriveDeferredStarts(effects)]]);
-  };
-  const logic = {
-    id: config.id,
-    config,
-    transition,
-    initialTransition: (input, actorScope) => {
-      beginSpawnAllocation(actorScope);
-      const context = resolveContext(config.context, input);
-      const snapshot = createSnapshot(config.initial, context, input, machine);
-      const internalQueue = [];
-      let [nextSnapshot, actions] = runStateActions(snapshot, {
-        type: XSTATE_INIT
-      }, actorScope, config.states[config.initial]?.entry, undefined, internalQueue);
-      if (!actions.length) {
-        actions = [];
-      }
-      while (internalQueue.length) {
-        const [raisedSnapshot, raisedActions] = transitionCore(nextSnapshot, internalQueue.shift(), actorScope);
-        nextSnapshot = raisedSnapshot;
-        actions.push(...raisedActions);
-      }
-      return finalizeTransitionResult(actorScope, undefined, [nextSnapshot, [...actions, ...deriveDeferredStarts(actions)]]);
-    },
-    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
-    getPersistedSnapshot: ({
-      machine: _,
-      ...snapshot
-    }) => snapshot,
-    restoreSnapshot: snapshot => ({
-      ...snapshot,
-      machine: machine
-    })
-  };
-  return logic;
-}
-
 function delayToMs(delay) {
   const parsedDelay = parseDelayToMilliseconds(delay);
   if (parsedDelay !== undefined) return parsedDelay;
   return typeof delay === 'string' ? parseFloat(delay) || 0 : delay;
 }
-function normalizeScxmlEventType(eventType) {
-  return /^error(\.|$)/.test(eventType) ? `xstate.${eventType}` : eventType;
-}
-function toScxmlEventName(eventType) {
-  return eventType.startsWith('xstate.error.') ? eventType.slice('xstate.'.length) : eventType;
-}
-
-/**
- * Isolated executable-content block. Errors in nested actions stop this block
- * but do not propagate to the surrounding action list. Used to model SCXML's
- * separate <onentry>/<onexit> blocks: each is its own block per spec.
- */
-
 function isExpression(value) {
   return !!value && typeof value === 'object' && typeof value['@expr'] === 'string';
 }
@@ -496,9 +58,6 @@ function isResolvable(value) {
 function isBuiltInActionType(type) {
   return type.startsWith('@xstate.');
 }
-function isScxmlActionType(type) {
-  return type.startsWith('scxml.');
-}
 function toPath(parent, key) {
   return typeof key === 'number' ? `${parent}[${key}]` : `${parent}.${key}`;
 }
@@ -639,7 +198,7 @@ function assertMachineJSON(json, resolvedSources, expressionResolver) {
       assertCondition(json.guards[condition.type].when, `$.guards.${condition.type}.when`);
       return;
     }
-    if (!resolvedSources.guards[condition.type] && !['scxml.cond', 'xstate.stateIn', 'xstate.not'].includes(condition.type)) {
+    if (!resolvedSources.guards[condition.type] && !['xstate.stateIn', 'xstate.not'].includes(condition.type)) {
       throw new Error(`Missing guard source "${condition.type}"`);
     }
   }
@@ -652,7 +211,7 @@ function assertMachineJSON(json, resolvedSources, expressionResolver) {
       throw new Error(`Invalid action at ${path}`);
     }
     assertResolvable(action.params, `${path}.params`);
-    if (isBuiltInActionType(action.type) || isScxmlActionType(action.type)) {
+    if (isBuiltInActionType(action.type)) {
       assertResolvable(action, path);
       return;
     }
@@ -718,8 +277,7 @@ function assertMachineJSON(json, resolvedSources, expressionResolver) {
       const invokes = Array.isArray(node.invoke) ? node.invoke : [node.invoke];
       invokes.forEach((invoke, index) => {
         const invokePath = `${path}.invoke${Array.isArray(node.invoke) ? `[${index}]` : ''}`;
-        const extInv = invoke;
-        if (!extInv._nestedMachineJSON && !resolvedSources.actors[invoke.src]) {
+        if (!resolvedSources.actors[invoke.src]) {
           throw new Error(`Missing actor source "${invoke.src}"`);
         }
         assertResolvable(invoke.input, `${invokePath}.input`);
@@ -771,78 +329,6 @@ function assertMachineJSON(json, resolvedSources, expressionResolver) {
   }
   assertStateNode(json, '$');
 }
-let _scxmlSessionId = 'session_scxml';
-let _scxmlMachineName = '';
-
-/** Evaluates an SCXML expression with context variables available via `with`. */
-function evaluateExpr(context, expr, event, self) {
-  const fnBody = `
-with (context) {
-  return (${expr});
-}
-  `.trim();
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  const fn = new Function('context', '_event', '_sessionid', '_name', '_ioprocessors', 'In', fnBody);
-  const In = stateId => {
-    if (!self) return false;
-    try {
-      const snap = self.getSnapshot?.();
-      if (snap?.nodes) {
-        const sanitized = stateId.replace(/\./g, '$');
-        return snap.nodes.some(node => node.id === sanitized || node.id.endsWith('.' + sanitized));
-      }
-    } catch {
-      // ignore
-    }
-    return false;
-  };
-  const SCXML_ORIGIN = `#_scxml_${_scxmlSessionId}`;
-  const SCXML_ORIGIN_TYPE = 'http://www.w3.org/TR/scxml/#SCXMLEventProcessor';
-  const isExternal = event && event._scxmlExternal;
-  const isInitEvent = event && event.type === '@xstate.init';
-  // Per SCXML spec, _event has these fields. Fields that don't apply to a
-  // particular event are present with value `undefined` (so `'name' in _event`
-  // is true but `typeof _event.name === 'undefined'` for unset fields).
-  // For xstate.done.* events, _event.data is the `output` payload (matches
-  // SCXML's done event semantics where data is the donedata).
-  const isDoneEvent = event && typeof event.type === 'string' && event.type.startsWith('xstate.done.');
-  const explicitType = event && event._scxmlEventType;
-  const scxmlEvent = event && !isInitEvent ? {
-    name: event._scxmlEventName ?? toScxmlEventName(event.type),
-    type: explicitType || (isExternal ? 'external' : 'internal'),
-    sendid: event._scxmlSendId,
-    origin: isExternal ? SCXML_ORIGIN : undefined,
-    origintype: isExternal ? SCXML_ORIGIN_TYPE : undefined,
-    invokeid: event._scxmlInvokeId,
-    data: isDoneEvent ? event.output : event._scxmlEventData !== undefined ? event._scxmlEventData : event
-  } : undefined;
-  const result = fn(context, scxmlEvent, _scxmlSessionId, _scxmlMachineName, {
-    scxml: {
-      location: `#_scxml_${_scxmlSessionId}`
-    }
-  }, In);
-  return result;
-}
-
-/** Executes an SCXML script block and returns updated context values. */
-function executeScript(context, code) {
-  // Create a proxy to track which properties are modified
-  const updates = {};
-  const contextKeys = Object.keys(context);
-
-  // Build variable declarations and reassignment capture
-  const varDeclarations = contextKeys.map(k => `let ${k} = context.${k};`).join('\n');
-  const captureUpdates = contextKeys.map(k => `updates.${k} = ${k};`).join('\n');
-  const fnBody = `
-${varDeclarations}
-${code}
-${captureUpdates}
-return updates;
-  `;
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  const fn = new Function('context', 'updates', fnBody);
-  return fn(context, updates);
-}
 function createMachineFromConfig(json, sources = {}) {
   const resolvedSources = mergeSources(json, sources);
   const expressionResolver = createExpressionResolver(json['@exprLang'], resolvedSources);
@@ -853,9 +339,7 @@ function createMachineFromConfig(json, sources = {}) {
     getDurationConfig
   } = expressionResolver;
   function resolveCondition(condition, slot, path) {
-    if (!condition) {
-      return undefined;
-    }
+    if (!condition) return undefined;
     if (isResolvable(condition)) {
       return args => !!evaluateResolvable(condition, slot, makeScope(args), path);
     }
@@ -876,10 +360,11 @@ function createMachineFromConfig(json, sources = {}) {
       return guardImpl(args, params);
     };
   }
+  function getMissingGuardMessage(type, guards) {
+    return `Guard '${type}' is not implemented in machine '${json.id ?? '(machine)'}'. Available guards: ${Object.keys(guards).map(key => `'${key}'`).join(', ') || '(none)'}.`;
+  }
   function makeChoiceConfig(choice, path) {
-    if (!choice) {
-      return undefined;
-    }
+    if (!choice) return undefined;
     if (isResolvable(choice)) {
       return args => evaluateResolvable(choice, 'choice', makeScope(args), path);
     }
@@ -902,32 +387,8 @@ function createMachineFromConfig(json, sources = {}) {
       throw new Error(`Choice state at ${path} did not match any branch.`);
     };
   }
-
-  // Pending transition actions: set by .to functions, consumed by entry functions.
-  // This bridges SCXML's exit→transition→entry action ordering with XState's
-  // .to function receiving pre-exit context.
-  // Map keyed by target state ID so parallel transitions don't overwrite each other.
-  const pendingTransitionActionsMap = {};
-
-  // Ordered queue of ALL transition actions (targeted + targetless) for parallel
-  // context sharing. In SCXML, all transition actions execute sequentially in
-  // document order with a shared evolving data model.
-  const allTransitionActions = [];
-  // Pre-transition context saved when a targetless .to executes. Used by entry
-  // functions to re-execute all transition actions from scratch when parallel
-  // targetless transitions coexist with targeted transitions.
-  let contextBeforeTargetless = null;
-  // Platform errors collected during transition selection (e.g., failing
-  // <transition cond>). Drained by the next state's entry into the internal
-  // event queue so they're processed before any external events.
-  const pendingPlatformErrors = [];
-  function getMissingGuardMessage(type, guards) {
-    return `Guard '${type}' is not implemented in machine '${json.id ?? '(machine)'}'. Available guards: ${Object.keys(guards).map(key => `'${key}'`).join(', ') || '(none)'}.`;
-  }
   function resolveRouteConfig(route, path) {
-    if (!route || typeof route === 'function') {
-      return route;
-    }
+    if (!route || typeof route === 'function') return route;
     if (isResolvable(route)) {
       return args => evaluateResolvable(route, 'transition', makeScope(args), path);
     }
@@ -935,263 +396,15 @@ function createMachineFromConfig(json, sources = {}) {
       guard,
       ...routeConfig
     } = route;
-    if (!guard) {
-      return routeConfig;
-    }
+    if (!guard) return routeConfig;
     const resolvedGuard = resolveCondition({
       type: guard
     }, 'guard', path);
     return args => resolvedGuard(args) ? routeConfig : undefined;
   }
-  function iterNode(node, nodeKey) {
-    const originalEntryActions = toActionArray(node.entry);
-    const stateId = node.id || nodeKey;
-
-    // Wrap entry to first execute any pending transition actions, then normal entry.
-    // This ensures SCXML execution order: exit → transition_actions → entry_actions
-    // because pending transition actions are set by .to (before exit) but executed
-    // in entry (after exit), thus seeing post-exit context.
-    const entryFn = (x, enq) => {
-      // Drain any platform errors queued during transition selection (e.g.,
-      // failing <transition cond="..."> evaluations). These must be raised
-      // internally so they're processed before subsequent external events.
-      while (pendingPlatformErrors.length) {
-        const err = pendingPlatformErrors.shift();
-        enq.raise({
-          type: 'xstate.error.execution',
-          error: err,
-          _scxmlEventType: 'platform',
-          _scxmlEventName: 'error.execution',
-          _scxmlEventData: err
-        });
-      }
-      let context;
-
-      // If targetless transitions were interleaved with targeted transitions
-      // (parallel state), re-execute ALL transition actions from the original
-      // pre-transition context. This overrides any .to-produced context with
-      // the correct SCXML document-order sequential execution.
-      // Only trigger when BOTH targeted (pending in map) and targetless fired
-      // in the same microstep — prevents stale data from previous events.
-      if (contextBeforeTargetless && allTransitionActions.length > 0 && Object.keys(pendingTransitionActionsMap).length > 0) {
-        let ctx = contextBeforeTargetless;
-        for (const actions of allTransitionActions) {
-          const mergedX = {
-            ...x,
-            context: ctx
-          };
-          const result = executeActions(actions, mergedX, enq);
-          if (result.context) {
-            ctx = result.context;
-          }
-        }
-        allTransitionActions.length = 0;
-        contextBeforeTargetless = null;
-        // Clear per-target map since we re-processed everything
-        for (const key of Object.keys(pendingTransitionActionsMap)) {
-          delete pendingTransitionActionsMap[key];
-        }
-        context = ctx;
-      } else {
-        // Normal path: consume pending transition actions for THIS state.
-        // In parallel states, each target gets its own pending actions.
-        const transActions = stateId ? pendingTransitionActionsMap[stateId] : undefined;
-        if (transActions) {
-          delete pendingTransitionActionsMap[stateId];
-          const result = executeActions(transActions, x, enq);
-          if (result.context) {
-            context = result.context;
-          }
-        }
-        // Clear stale targetless data from previous microsteps
-        contextBeforeTargetless = null;
-        allTransitionActions.length = 0;
-      }
-
-      // Execute normal entry actions
-      if (originalEntryActions.length) {
-        const mergedX = context ? {
-          ...x,
-          context
-        } : x;
-        const result = executeActions(originalEntryActions, mergedX, enq);
-        if (result.context) {
-          context = result.context;
-        }
-      }
-      return {
-        context
-      };
-    };
-    const nodeConfig = {
-      id: node.id,
-      initial: node.initial,
-      type: node.type,
-      history: node.history,
-      target: node.target,
-      description: node.description,
-      tags: node.tags,
-      input: node.input,
-      timeout: getDurationConfig(node.timeout, `$.states.${nodeKey}.timeout`),
-      states: node.states ? Object.entries(node.states).reduce((acc, [key, value]) => {
-        acc[key] = iterNode(value, key);
-        return acc;
-      }, {}) : undefined,
-      on: node.on ? Object.entries(node.on).reduce((acc, [key, value]) => {
-        acc[key] = getTransitionConfig(value);
-        return acc;
-      }, {}) : undefined,
-      always: node.always ? getTransitionConfig(node.always) : undefined,
-      onError: node.onError ? getTransitionConfig(node.onError) : undefined,
-      choice: makeChoiceConfig(node.choice, `$.states.${nodeKey}.choice`),
-      route: resolveRouteConfig(node.route, `$.states.${nodeKey}.route`),
-      after: node.after ? Object.entries(node.after).reduce((acc, [key, value]) => {
-        acc[key] = getTransitionConfig(value);
-        return acc;
-      }, {}) : undefined,
-      onTimeout: node.onTimeout ? getTransitionConfig(node.onTimeout) : undefined,
-      entry: node.type === 'choice' ? undefined : entryFn,
-      exit: node.exit ? iterActions(toActionArray(node.exit)) : undefined,
-      invoke: node.invoke ? iterInvokeConfigs(node.invoke) : undefined,
-      meta: node.meta,
-      output: node._scxmlDonedata ? makeDonedataOutput(node._scxmlDonedata) : isResolvable(node.output) ? ({
-        context,
-        event,
-        self
-      }) => evaluateResolvable(node.output, 'output', {
-        context,
-        event,
-        self
-      }, `$.states.${nodeKey}.output`) : node.output
-    };
-    return nodeConfig;
-  }
-  function makeDonedataOutput(donedata) {
-    return ({
-      context,
-      event,
-      self
-    }) => {
-      try {
-        if (donedata.params && donedata.params.length) {
-          const out = {};
-          for (const param of donedata.params) {
-            out[param.name] = evaluateExpr(context, param.expr, event, self);
-          }
-          return out;
-        }
-        if (donedata.contentExpr !== undefined) {
-          return evaluateExpr(context, donedata.contentExpr, event, self);
-        }
-        if (donedata.contentText !== undefined) {
-          // Try parsing as a JS expression (number/object/array literals);
-          // fall back to the raw string.
-          try {
-            return evaluateExpr(context, donedata.contentText, event, self);
-          } catch {
-            return donedata.contentText;
-          }
-        }
-      } catch (err) {
-        // Per SCXML, donedata expression errors raise error.execution and
-        // result in undefined event.data. Queue for the next entry to drain.
-        const message = err instanceof Error ? err.message : typeof err === 'string' ? err : 'unknown error';
-        pendingPlatformErrors.push({
-          tagname: 'donedata',
-          message,
-          line: NaN,
-          column: NaN,
-          reason: message
-        });
-      }
-      return undefined;
-    };
-  }
-  function iterInvokeConfigs(invokes) {
-    const invokeArray = Array.isArray(invokes) ? invokes : [invokes];
-    return invokeArray.map(inv => {
-      const extInv = inv;
-      // Create child machine from nested SCXML JSON
-      let src;
-      if (extInv._nestedMachineJSON) {
-        src = createMachineFromConfig(extInv._nestedMachineJSON, resolvedSources);
-      } else {
-        src = resolvedSources.actors[inv.src] ?? inv.src;
-      }
-      return {
-        src,
-        id: inv.id,
-        registryKey: inv.registryKey,
-        input: inv.input !== undefined ? args => resolveValue(inv.input, 'input', makeScope(args), '$.invoke.input') : undefined,
-        onDone: inv.onDone ? getTransitionConfig(inv.onDone) : undefined,
-        onError: inv.onError ? getTransitionConfig(inv.onError) : undefined,
-        onSnapshot: inv.onSnapshot ? getTransitionConfig(inv.onSnapshot) : undefined,
-        timeout: getDurationConfig(inv.timeout, '$.invoke.timeout'),
-        onTimeout: inv.onTimeout ? getTransitionConfig(inv.onTimeout) : undefined
-      };
-    });
-  }
-
-  /**
-   * Raise an SCXML error.execution platform event onto the internal queue. Per
-   * spec, error.execution is type='platform' and _event.data contains error
-   * info. The surrounding block of executable content stops.
-   */
-  function raiseErrorExecution(state, tagname, err) {
-    const message = err instanceof Error ? err.message : typeof err === 'string' ? err : 'unknown error';
-    state.enq.raise({
-      type: 'xstate.error.execution',
-      error: {
-        tagname,
-        message,
-        line: NaN,
-        column: NaN,
-        reason: message
-      },
-      _scxmlEventType: 'platform',
-      _scxmlEventName: 'error.execution',
-      _scxmlEventData: {
-        tagname,
-        message,
-        line: NaN,
-        column: NaN,
-        reason: message
-      }
-    });
-    state.errored = true;
-  }
-  function executeActionDefinition(action, x, enq, params, parentState, stack) {
-    const definition = json.actions?.[action.type];
-    if (!definition) {
-      enq(x.actions[action.type], params);
-      return {
-        context: undefined,
-        errored: parentState.errored
-      };
-    }
-    if (stack.includes(action.type)) {
-      raiseErrorExecution(parentState, 'action', new Error(`Circular action reference: ${stack.concat(action.type).join(' -> ')}`));
-      return {
-        context: undefined,
-        errored: true
-      };
-    }
-    const definitions = Array.isArray(definition) ? definition : [definition];
-    return executeActions(definitions, {
-      ...x,
-      params
-    }, enq, parentState, stack.concat(action.type));
-  }
-
-  /** Execute an array of SCXML action JSON descriptors with context and enqueue. */
-  function executeActions(actions, x, enq, parentState, stack = []) {
-    const state = parentState ?? {
-      enq,
-      errored: false
-    };
+  function executeActions(actions, x, enq, stack = []) {
     let context;
     for (const action of actions) {
-      if (state.errored) break;
       if (isResolvable(action)) {
         const result = evaluateResolvable(action, 'action', makeScope(x, {
           params: x.params,
@@ -1201,31 +414,18 @@ function createMachineFromConfig(json, sources = {}) {
           context ??= {};
           Object.assign(context, result.context);
         }
-      } else if (isBuiltInActionJSON(action)) {
+        continue;
+      }
+      if (isBuiltInActionJSON(action)) {
         switch (action.type) {
           case '@xstate.raise':
-            {
-              // Tag as external if it has a delay (from <send>, not <raise>).
-              // Attach _scxmlSendId so _event.sendid can be read in expressions.
-              const isExternal = action.delay !== undefined;
-              const resolvedEvent = resolveValue(action.event, 'actionParams', makeScope(x, {
-                params: x.params
-              }), '$.actions.event');
-              const event = isExternal || action.id !== undefined ? {
-                ...resolvedEvent,
-                ...(isExternal ? {
-                  _scxmlExternal: true
-                } : {}),
-                ...(action.id !== undefined ? {
-                  _scxmlSendId: action.id
-                } : {})
-              } : resolvedEvent;
-              enq.raise(event, {
-                id: action.id,
-                delay: action.delay
-              });
-              break;
-            }
+            enq.raise(resolveValue(action.event, 'actionParams', makeScope(x, {
+              params: x.params
+            }), '$.actions.event'), {
+              id: action.id,
+              delay: action.delay
+            });
+            break;
           case '@xstate.cancel':
             enq.cancel(action.id);
             break;
@@ -1243,501 +443,161 @@ function createMachineFromConfig(json, sources = {}) {
               params: x.params
             }), '$.actions.context'));
             break;
-          default:
-            throw new Error(`Unknown built-in action: ${action.type}`);
-        }
-      } else if (action.type === 'scxml.assign') {
-        const scxmlAction = action;
-        const mergedContext = {
-          ...x.context,
-          ...context
-        };
-        let value;
-        try {
-          value = evaluateExpr(mergedContext, scxmlAction.expr, x.event, x.self);
-        } catch (err) {
-          raiseErrorExecution(state, 'assign', err);
-          continue;
-        }
-        // Per SCXML, assigning to a location that doesn't exist on the
-        // datamodel is an error. Allow setting an own property via context;
-        // detect deep paths (a.b.c) which we don't support.
-        if (scxmlAction.location.includes('.')) {
-          raiseErrorExecution(state, 'assign', new Error(`Invalid assign location: ${scxmlAction.location}`));
-          continue;
-        }
-        context ??= {};
-        context[scxmlAction.location] = value;
-      } else if (action.type === 'scxml.raise') {
-        const scxmlAction = action;
-        const mergedContext = {
-          ...x.context,
-          ...context
-        };
-        let eventType;
-        let eventData;
-        let target;
-        let delay;
-        try {
-          eventType = scxmlAction.eventexpr ? evaluateExpr(mergedContext, scxmlAction.eventexpr, x.event, x.self) : scxmlAction.event || 'unknown';
-          eventType = normalizeScxmlEventType(eventType);
-          eventData = {
-            type: eventType,
-            _scxmlEventName: toScxmlEventName(eventType)
-          };
-          if (scxmlAction.params) {
-            for (const param of scxmlAction.params) {
-              eventData[param.name] = evaluateExpr(mergedContext, param.expr, x.event, x.self);
-            }
-          }
-          target = scxmlAction.targetexpr ? evaluateExpr(mergedContext, scxmlAction.targetexpr, x.event, x.self) : scxmlAction.target;
-          const isInternalTarget = target === '#_internal';
-          delay = scxmlAction.delayexpr ? delayToMs(evaluateExpr(mergedContext, scxmlAction.delayexpr, x.event, x.self)) : isInternalTarget ? undefined : scxmlAction.delay;
-        } catch (err) {
-          raiseErrorExecution(state, 'send', err);
-          continue;
-        }
-        const isInternalTarget = target === '#_internal';
-        const isParentTarget = target === '#_parent';
-
-        // Validate target. SCXML targets must be '#_internal', '#_parent',
-        // or '#_<id>'. A bare string without the '#_' prefix is invalid and
-        // raises error.execution.
-        if (typeof target === 'string' && target.length > 0 && !target.startsWith('#_')) {
-          raiseErrorExecution(state, 'send', new Error(`Invalid send target: ${target}`));
-          continue;
-        }
-        // Attach send id so _event.sendid can be read in expressions.
-        if (scxmlAction.id !== undefined) {
-          eventData._scxmlSendId = scxmlAction.id;
-        }
-        // Resolve target at runtime: parent, child, or self
-        if (isParentTarget && x.parent) {
-          // Send to parent via sendTo; pass delay if present
-          enq.sendTo(x.parent, eventData, delay !== undefined ? {
-            delay
-          } : undefined);
-        } else if (typeof target === 'string' && target.startsWith('#_') && !isParentTarget && !isInternalTarget) {
-          // #_<invokeId> → try to send to child actor, fall back to self-raise
-          const childId = target.slice(2); // strip '#_'
-          const childRef = x.children?.[childId];
-          if (childRef) {
-            enq.sendTo(childRef, eventData);
-          } else if (childId.startsWith('scxml_') && childId !== `scxml_${_scxmlSessionId}`) {
-            const message = `Unable to dispatch event to target: ${target}`;
-            enq.raise({
-              type: 'xstate.error.communication',
-              error: {
-                tagname: 'send',
-                message,
-                line: NaN,
-                column: NaN,
-                reason: message
-              },
-              _scxmlEventType: 'platform',
-              _scxmlEventName: 'error.communication',
-              _scxmlEventData: {
-                tagname: 'send',
-                message,
-                line: NaN,
-                column: NaN,
-                reason: message
-              }
-            });
-          } else {
-            // This SCXML session id uses the external event queue.
-            eventData._scxmlExternal = true;
-            enq.sendTo(x.self, eventData, {
-              id: scxmlAction.id,
-              delay
-            });
-          }
-        } else {
-          // #_internal uses the internal queue; self-send/no target use the
-          // external event queue.
-          if (isInternalTarget) {
-            enq.raise(eventData, {
-              id: scxmlAction.id,
-              delay
-            });
-          } else {
-            eventData._scxmlExternal = true;
-            enq.sendTo(x.self, eventData, {
-              id: scxmlAction.id,
-              delay
-            });
-          }
-        }
-      } else if (action.type === 'scxml.cancel') {
-        const scxmlAction = action;
-        const mergedContext = {
-          ...x.context,
-          ...context
-        };
-        try {
-          const sendId = evaluateExpr(mergedContext, scxmlAction.sendidexpr, x.event, x.self);
-          if (sendId) {
-            enq.cancel(sendId);
-          }
-        } catch {
-          // ignore evaluation errors
-        }
-      } else if (action.type === 'scxml.script') {
-        const scxmlAction = action;
-        const mergedContext = {
-          ...x.context,
-          ...context
-        };
-        try {
-          const updatedContext = executeScript(mergedContext, scxmlAction.code);
-          context ??= {};
-          Object.assign(context, updatedContext);
-        } catch (err) {
-          raiseErrorExecution(state, 'script', err);
-        }
-      } else if (action.type === 'scxml.foreach') {
-        const scxmlAction = action;
-        const mergedContext = {
-          ...x.context,
-          ...context
-        };
-        // SCXML: `item` (and `index` if present) must be valid datamodel
-        // locations — i.e. legal identifiers. Reject things like 'continue'
-        // (string literal) or '7' (number).
-        const isLegalIdentifier = s => /^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(s);
-        if (!isLegalIdentifier(scxmlAction.item) || scxmlAction.index && !isLegalIdentifier(scxmlAction.index)) {
-          raiseErrorExecution(state, 'foreach', new Error('foreach item/index is not a legal location'));
-          continue;
-        }
-        let arr;
-        try {
-          arr = evaluateExpr(mergedContext, scxmlAction.array, x.event, x.self);
-        } catch (err) {
-          raiseErrorExecution(state, 'foreach', err);
-          continue;
-        }
-        if (!Array.isArray(arr)) {
-          raiseErrorExecution(state, 'foreach', new Error('foreach array is not iterable'));
-          continue;
         }
-        context ??= {};
-        for (let i = 0; i < arr.length; i++) {
-          context[scxmlAction.item] = arr[i];
-          if (scxmlAction.index) {
-            context[scxmlAction.index] = i;
-          }
-          const iterX = {
-            ...x,
-            context: {
-              ...x.context,
-              ...context
-            }
-          };
-          const iterResult = executeActions(scxmlAction.actions, iterX, enq, state);
-          if (iterResult.context) {
-            Object.assign(context, iterResult.context);
-          }
-          if (state.errored) break;
-        }
-      } else if (action.type === 'scxml.block') {
-        const scxmlAction = action;
-        const blockX = {
-          ...x,
-          context: {
-            ...x.context,
-            ...context
-          }
-        };
-        // Block has its own ExecState — errors don't propagate to parent.
-        const blockResult = executeActions(scxmlAction.actions, blockX, enq);
-        if (blockResult.context) {
-          context ??= {};
-          for (const key of Object.keys(blockResult.context)) {
-            if (blockResult.context[key] !== x.context[key]) {
-              context[key] = blockResult.context[key];
-            }
-          }
-        }
-      } else if (action.type === 'scxml.if') {
-        const scxmlAction = action;
-        const mergedContext = {
+        continue;
+      }
+      const params = resolveValue(action.params, 'actionParams', makeScope(x, {
+        params: x.params
+      }), '$.actions.params');
+      const definition = json.actions?.[action.type];
+      if (!definition) {
+        enq(x.actions[action.type], params);
+        continue;
+      }
+      if (stack.includes(action.type)) {
+        throw new Error(`Circular action reference: ${stack.concat(action.type).join(' -> ')}`);
+      }
+      const definitions = Array.isArray(definition) ? definition : [definition];
+      const result = executeActions(definitions, {
+        ...x,
+        context: {
           ...x.context,
           ...context
-        };
-        for (const branch of scxmlAction.branches) {
-          let condResult;
-          if (branch.cond) {
-            try {
-              condResult = !!evaluateExpr(mergedContext, branch.cond, x.event, x.self);
-            } catch (err) {
-              raiseErrorExecution(state, 'if', err);
-              condResult = false;
-            }
-          } else {
-            condResult = true;
-          }
-          if (condResult) {
-            if (branch.actions.length) {
-              const branchX = {
-                ...x,
-                context: mergedContext
-              };
-              const branchResult = executeActions(branch.actions, branchX, enq, state);
-              if (branchResult.context) {
-                context ??= {};
-                for (const key of Object.keys(branchResult.context)) {
-                  if (branchResult.context[key] !== x.context[key]) {
-                    context[key] = branchResult.context[key];
-                  }
-                }
-              }
-            }
-            break;
-          }
-        }
-      } else {
-        const params = resolveValue(action.params, 'actionParams', makeScope(x, {
-          params: x.params
-        }), '$.actions.params');
-        const result = executeActionDefinition(action, x, enq, params, state, stack);
-        if (result.context) {
-          context ??= {};
-          Object.assign(context, result.context);
-        }
-      }
+        },
+        params
+      }, enq, stack.concat(action.type));
+      if (result.context) context = result.context;
     }
     return {
       context: context ? {
         ...x.context,
         ...context
-      } : undefined,
-      errored: state.errored
+      } : undefined
     };
   }
   function iterActions(actions) {
-    return (x, enq) => executeActions(actions, x, enq);
+    const actionArray = toActionArray(actions);
+    return (x, enq) => executeActions(actionArray, x, enq);
   }
   function getTransitionConfig(transition) {
     const transitions = Array.isArray(transition) ? transition : [transition];
-
-    // Return an array of transition configs. Each SCXML transition becomes
-    // a separate XState transition with its own guard and optional .to.
-    // This ensures guards are evaluated by XState's evaluateCandidate (once,
-    // with pre-exit context) and NOT re-evaluated in computeEntrySet.
-    return transitions.map((t, index) => {
-      if (isResolvable(t)) {
-        return (x, enq) => evaluateResolvable(t, 'transition', makeScope(x, {
+    return transitions.map((item, index) => {
+      if (isResolvable(item)) {
+        return (x, enq) => evaluateResolvable(item, 'transition', makeScope(x, {
           enq
         }), `$.transition${transitions.length > 1 ? `[${index}]` : ''}`);
       }
-      const target = Array.isArray(t.target) ? t.target[0] : t.target;
-      const targetConfig = t.target;
-      const guard = resolveCondition(t.guard, 'guard', '$.transition.guard');
-      const resolveTransitionContext = x => t.context ? resolveValue(t.context, 'transitionContext', makeScope(x), '$.transition.context') : undefined;
-      const resolveTransitionInput = x => t.input !== undefined ? resolveValue(t.input, 'input', makeScope(x), '$.transition.input') : undefined;
-
-      // No guard and no actions: simple static config
-      if (!guard && !t.actions?.length) {
-        if (t.context) {
-          return {
-            matches: t.matches,
-            to: x => ({
-              target: targetConfig,
-              context: resolveTransitionContext(x),
-              reenter: t.reenter
-            }),
-            description: t.description,
-            meta: t.meta,
-            input: t.input !== undefined ? resolveTransitionInput : undefined
-          };
-        }
-        return {
-          matches: t.matches,
-          target: targetConfig,
-          description: t.description,
-          reenter: t.reenter,
-          meta: t.meta,
-          input: t.input !== undefined ? resolveTransitionInput : undefined
-        };
-      }
-
-      // Guard but no actions: static config with guard
-      if (guard && !t.actions?.length) {
-        if (t.context) {
-          return {
-            matches: t.matches,
-            guard,
-            to: x => ({
-              target: targetConfig,
-              context: resolveTransitionContext(x),
-              reenter: t.reenter
-            }),
-            description: t.description,
-            meta: t.meta,
-            input: t.input !== undefined ? resolveTransitionInput : undefined
-          };
-        }
-        return {
-          matches: t.matches,
-          target: targetConfig,
-          guard,
-          description: t.description,
-          reenter: t.reenter,
-          meta: t.meta,
-          input: t.input !== undefined ? resolveTransitionInput : undefined
-        };
-      }
-
-      // Targetless transitions: execute actions directly in .to AND track for
-      // parallel re-execution. For non-parallel, .to result is used directly.
-      // For parallel (entries exist), first entry re-executes all in document order.
-      if (!target) {
-        return {
-          matches: t.matches,
-          guard,
-          description: t.description,
-          reenter: t.reenter,
-          meta: t.meta,
-          input: t.input !== undefined ? resolveTransitionInput : undefined,
-          to: (x, enq) => {
-            const context = resolveTransitionContext(x);
-            if (t.actions?.length) {
-              // Track for parallel re-execution (dedup by reference)
-              if (!allTransitionActions.includes(t.actions)) {
-                allTransitionActions.push(t.actions);
-              }
-              // Save pre-transition context for parallel override
-              contextBeforeTargetless ??= x.context;
-              // Execute immediately (fallback for non-parallel case)
-              const result = executeActions(t.actions, x, enq);
-              if (result.context) {
-                return {
-                  context: {
-                    ...context,
-                    ...result.context
-                  }
-                };
-              }
-            }
-            return context ? {
-              context
-            } : {};
-          }
-        };
-      }
-
-      // Has target + actions: use guard (for XState evaluation) + .to (for pending actions).
-      // The .to function does NOT re-check the guard — XState's evaluateCandidate
-      // already validated it. The .to just stores actions for entry to execute.
-      // Map by target state ID so parallel transitions each get their own actions.
+      const context = item.context ? x => resolveValue(item.context, 'transitionContext', makeScope(x), '$.transition.context') : undefined;
+      const input = item.input !== undefined ? x => resolveValue(item.input, 'input', makeScope(x), '$.transition.input') : undefined;
+      const dynamic = !!context || !!item.actions?.length;
       return {
-        matches: t.matches,
-        guard,
-        description: t.description,
-        reenter: t.reenter,
-        meta: t.meta,
-        input: t.input !== undefined ? resolveTransitionInput : undefined,
-        to: (_x, _enq) => {
-          const context = resolveTransitionContext(_x);
-          if (t.actions?.length) {
-            const targetId = target.replace(/^#/, '');
-            pendingTransitionActionsMap[targetId] = t.actions;
-            // Track for parallel re-execution (dedup by reference)
-            if (!allTransitionActions.includes(t.actions)) {
-              allTransitionActions.push(t.actions);
+        matches: item.matches,
+        target: dynamic ? undefined : item.target,
+        to: dynamic ? (x, enq) => {
+          const resolvedContext = context?.(x);
+          const result = item.actions?.length ? executeActions(item.actions, resolvedContext ? {
+            ...x,
+            context: {
+              ...x.context,
+              ...resolvedContext
             }
-          }
+          } : x, enq) : undefined;
           return {
-            target: targetConfig,
-            context,
-            reenter: t.reenter
+            target: item.target,
+            context: result?.context ?? resolvedContext,
+            reenter: item.reenter
           };
-        }
+        } : undefined,
+        guard: resolveCondition(item.guard, 'guard', '$.transition.guard'),
+        description: item.description,
+        reenter: item.reenter,
+        meta: item.meta,
+        input
       };
     });
   }
+  function iterInvokeConfigs(invokes) {
+    return (Array.isArray(invokes) ? invokes : [invokes]).map(inv => ({
+      src: resolvedSources.actors[inv.src] ?? inv.src,
+      id: inv.id,
+      registryKey: inv.registryKey,
+      input: inv.input !== undefined ? args => resolveValue(inv.input, 'input', makeScope(args), '$.invoke.input') : undefined,
+      onDone: inv.onDone ? getTransitionConfig(inv.onDone) : undefined,
+      onError: inv.onError ? getTransitionConfig(inv.onError) : undefined,
+      onSnapshot: inv.onSnapshot ? getTransitionConfig(inv.onSnapshot) : undefined,
+      timeout: getDurationConfig(inv.timeout, '$.invoke.timeout'),
+      onTimeout: inv.onTimeout ? getTransitionConfig(inv.onTimeout) : undefined
+    }));
+  }
+  function iterNode(node, nodeKey) {
+    return {
+      id: node.id,
+      initial: node.initial,
+      type: node.type,
+      history: node.history,
+      target: node.target,
+      description: node.description,
+      tags: node.tags,
+      input: node.input,
+      timeout: getDurationConfig(node.timeout, `$.states.${nodeKey}.timeout`),
+      states: node.states ? Object.fromEntries(Object.entries(node.states).map(([key, value]) => [key, iterNode(value, key)])) : undefined,
+      on: node.on ? Object.fromEntries(Object.entries(node.on).map(([key, value]) => [key, getTransitionConfig(value)])) : undefined,
+      always: node.always ? getTransitionConfig(node.always) : undefined,
+      onError: node.onError ? getTransitionConfig(node.onError) : undefined,
+      choice: makeChoiceConfig(node.choice, `$.states.${nodeKey}.choice`),
+      route: resolveRouteConfig(node.route, `$.states.${nodeKey}.route`),
+      after: node.after ? Object.fromEntries(Object.entries(node.after).map(([key, value]) => [key, getTransitionConfig(value)])) : undefined,
+      onTimeout: node.onTimeout ? getTransitionConfig(node.onTimeout) : undefined,
+      entry: node.entry ? iterActions(node.entry) : undefined,
+      exit: node.exit ? iterActions(node.exit) : undefined,
+      invoke: node.invoke ? iterInvokeConfigs(node.invoke) : undefined,
+      meta: node.meta,
+      output: isResolvable(node.output) ? ({
+        context,
+        event,
+        self
+      }) => evaluateResolvable(node.output, 'output', {
+        context,
+        event,
+        self
+      }, `$.states.${nodeKey}.output`) : node.output
+    };
+  }
   if (json.delays) {
-    for (const key of Object.keys(json.delays)) {
-      const delay = json.delays[key];
-      if (typeof delay === 'number') {
-        resolvedSources.delays[key] = delay;
-      } else if (typeof delay === 'string') {
-        resolvedSources.delays[key] = delayToMs(delay);
-      } else if (delay && typeof delay === 'object') {
+    for (const [key, delay] of Object.entries(json.delays)) {
+      if (typeof delay === 'number') resolvedSources.delays[key] = delay;else if (typeof delay === 'string') resolvedSources.delays[key] = delayToMs(delay);else if (delay && typeof delay === 'object') {
         resolvedSources.delays[key] = args => delayToMs(resolveValue(delay.duration, 'delay', makeScope(args), `$.delays.${key}.duration`));
       }
     }
   }
   assertMachineJSON(json, resolvedSources, expressionResolver);
-  const rootNodeConfig = iterNode(json);
   const contextConfig = json.context ? {
     context: args => resolveValue(json.context, 'context', args, '$.context')
   } : {};
-  _scxmlMachineName = json.id || '';
-  _scxmlSessionId = 'session_scxml';
   const machine = createMachine({
-    ...rootNodeConfig,
+    ...iterNode(json),
     ...contextConfig,
     version: json.version
   });
-
-  // Register SCXML guard sources
-  const providedGuards = {
-    'scxml.cond': ({
-      context,
-      event,
-      self
-    }, params) => {
-      const expr = params?.expr;
-      if (!expr) return true;
-      try {
-        return !!evaluateExpr(context, expr, event, self);
-      } catch (err) {
-        // Per SCXML spec, a cond that fails to evaluate is treated as false
-        // AND raises error.execution. We can't enqueue from a guard, so
-        // queue it for the next entry to drain.
-        const message = err instanceof Error ? err.message : typeof err === 'string' ? err : 'unknown error';
-        pendingPlatformErrors.push({
-          tagname: 'cond',
-          message,
-          line: NaN,
-          column: NaN,
-          reason: message
-        });
-        return false;
-      }
-    },
-    'xstate.stateIn': (args, params) => {
-      const stateId = params?.stateId;
-      if (!stateId) return false;
-      const normalizedId = stateId.replace(/^#/, '');
-      const snapshot = args._snapshot;
-      if (snapshot?.nodes) {
-        return snapshot.nodes.some(node => node.id === normalizedId);
-      }
-      return false;
-    },
-    'xstate.not': (args, params) => {
-      const inner = params?.guard;
-      const innerImpl = inner && args.guards?.[inner.type];
-      if (!innerImpl) {
-        throw new Error(`Guard '${inner?.type}' referenced by 'xstate.not' is not implemented.`);
-      }
-      return !innerImpl(args, inner.params);
-    }
-  };
   const provided = machine.provide({
     actions: resolvedSources.actions,
     actors: resolvedSources.actors,
     guards: {
-      ...providedGuards,
+      'xstate.stateIn': (args, params) => {
+        const stateId = params?.stateId;
+        const snapshot = args._snapshot;
+        return !!stateId && !!snapshot?.nodes?.some(node => node.id === stateId.replace(/^#/, ''));
+      },
+      'xstate.not': (args, params) => {
+        const inner = params?.guard;
+        const impl = inner && args.guards?.[inner.type];
+        if (!impl) throw new Error(`Guard '${inner?.type}' referenced by 'xstate.not' is not implemented.`);
+        return !impl(args, inner.params);
+      },
       ...resolvedSources.guards
     },
     delays: resolvedSources.delays
   });
-
-  // Keep the original JSON so `serializeMachine(machine)`
-  // round-trip losslessly.
   provided._json = json;
   return provided;
 }
@@ -2626,134 +1486,6 @@ function toPromise(actor) {
   });
 }
 
-// this is needed to make JSDoc `@link` work properly
-// oxlint-disable-next-line no-unused-vars
-
-/**
- * @remarks
- * `T | unknown` reduces to `unknown` and that can be problematic when it comes
- * to contextual typing. It especially is a problem when the union has a
- * function member, like here:
- *
- * ```ts
- * declare function test(
- *   cbOrVal: ((arg: number) => unknown) | unknown
- * ): void;
- * test((arg) => {}); // oops, implicit any
- * ```
- *
- * This type can be used to avoid this problem. This union represents the same
- * value space as `unknown`.
- */
-
-// https://github.com/microsoft/TypeScript/issues/23182#issuecomment-379091887
-
-// @TODO: we can't use native `NoInfer` as we need those:
-// https://github.com/microsoft/TypeScript/pull/61092
-// https://github.com/microsoft/TypeScript/pull/61077
-// but even with those fixes native NoInfer still doesn't work - further issues have to be reproduced and fixed
-
-/** @deprecated Use the built-in `NoInfer` type instead */
-
-/** The full definition of an event, with a string `type`. */
-
-/**
- * The string or object representing the state value relative to the parent
- * state node.
- *
- * @remarks
- * - For a child atomic state node, this is a string, e.g., `"pending"`.
- * - For complex state nodes, this is an object, e.g., `{ success:
- *   "someChildState" }`.
- */
-
-// Accept any StateNode instance regardless of generic parameters
-// Using a union type to handle variance issues with machine.resolveState
-
-let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
-  SpecialTargets["Internal"] = "#_internal";
-  return SpecialTargets;
-}({});
-
-/** A deterministic delayed-delivery declaration owned by a logic snapshot. */
-
-/** The logical input delivered to a timer's source when its runtime delay ends. */
-
-/** A persisted snapshot tied to a versioned actor logic identity. */
-
-/**
- * A persisted snapshot restorable into the given actor logic: any snapshot
- * created by logic with the same machine `id` is accepted, regardless of
- * version (version mismatches are handled at runtime, e.g. by `migrate`).
- */
-
-/** @deprecated Use `AnyActor` instead. */
-
-// Based on RxJS types
-
-/**
- * A consumer-facing actor handle.
- *
- * `ActorRef` describes the contract a consumer needs: which events can be sent
- * to the actor, which snapshot it publishes for observation, and which emitted
- * events can be listened to. It intentionally does not expose lifecycle control
- * or runtime internals. A concrete `Actor` satisfies this interface, so APIs
- * should accept `ActorRef` whenever they only need to send events, read
- * snapshots, or listen to emitted events.
- */
-
-/**
- * Runtime-only actor capabilities.
- *
- * These members are needed by the interpreter, scheduler, inspection, and child
- * management code. Public consumer APIs should prefer `ActorRef` unless they
- * genuinely need lifecycle control such as starting, stopping, or accessing
- * system-owned runtime state.
- */
-
-/**
- * A concrete actor instance type.
- *
- * `ActorInstance` combines the consumer `ActorRef` contract with runtime
- * lifecycle capabilities. Values returned by `createActor(...)` and
- * `spawn(...)` naturally satisfy narrower `ActorRef` contracts.
- */
-
-/**
- * The actor's own full self handle.
- *
- * Internals and action/guard sources receive this shape because `self` can
- * participate in runtime-owned behavior while still being usable wherever an
- * `ActorRef` is expected.
- */
-
-// TODO: in v6, this should only accept AnyActorLogic, like ActorRefFromLogic
-
-/** The concrete actor instance type produced from actor logic. */
-
-/**
- * Represents logic which can be used by an actor.
- *
- * @template TSnapshot - The type of the snapshot.
- * @template TEvent - The type of the event object.
- * @template TInput - The type of the input.
- * @template TSystem - The type of the actor system.
- */
-
-// Actors that don't have literal string IDs — these are the only ones
-// that should appear in the index signature fallback, since actors with
-// literal IDs are already covered by ToConcreteChildren.
-
-/** Maps state IDs to their input types based on the StateSchema. */
-
-/** @deprecated */
-
-/** The terminal result published when an actor completes or errors. */
-
-/** An executable effect that publishes an actor's terminal result. */
-
-/** Mappers for subscribeTo - maps lifecycle events to machine events */
-
 const defaultWaitForOptions = {
   timeout: Infinity // much more than 10 seconds
 };
@@ -2858,4 +1590,4 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
-export { SimulatedClock, SpecialTargets, assertEvent, createFSM, createMachine, createMachineFromConfig, createStateConfig, createSystem, isTypeSchema, machineConfigToJSON, machineVersions, mapState, serializeMachine, setup, toPromise, types, waitFor };
+export { SimulatedClock, assertEvent, createMachineFromConfig, createSystem, isTypeSchema, machineConfigToJSON, machineVersions, mapState, serializeMachine, setup, toPromise, types, waitFor };