xstate 5.32.0 → 6.0.0-alpha.1

package/dist/xstate.development.cjs.js

@@ -2,12 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_xstateActors = require('./xstate-actors.development.cjs.js');
-var dist_xstateGuards = require('./raise-964cd4e9.development.cjs.js');
-var StateMachine = require('./StateMachine-be2e51a3.development.cjs.js');
-var assign = require('./assign-927227d6.development.cjs.js');
-var log = require('./log-029f180b.development.cjs.js');
-require('./xstate-dev.development.cjs.js');
+var dist_xstateActors = require('./index-c35824b4.development.cjs.js');
+var StateMachine = require('./StateMachine-6e063ac1.development.cjs.js');
 
 /**
  * Asserts that the given event object is of the specified type or types. Throws
@@ -33,8 +29,8 @@ require('./xstate-dev.development.cjs.js');
  * ```
  */
 function assertEvent(event, type) {
-  const types = dist_xstateGuards.toArray(type);
-  const matches = types.some(descriptor => dist_xstateGuards.matchesEventDescriptor(event.type, descriptor));
+  const types = dist_xstateActors.toArray(type);
+  const matches = types.some(descriptor => dist_xstateActors.matchesEventDescriptor(event.type, descriptor));
   if (!matches) {
     const typesText = types.length === 1 ? `type matching "${types[0]}"` : `one of types matching "${types.join('", "')}"`;
     throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
@@ -83,8 +79,1004 @@ function assertEvent(event, type) {
  * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
  *   to provide machine implementations instead.
  */
-function createMachine(config, implementations) {
-  return new StateMachine.StateMachine(config, implementations);
+// 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.StateMachine(config);
+}
+function createStateConfig(config) {
+  return config;
+}
+
+function delayToMs(delay) {
+  const parsedDelay = dist_xstateActors.parseDelayToMilliseconds(delay);
+  if (parsedDelay !== undefined) return parsedDelay;
+  return typeof delay === 'string' ? parseFloat(delay) || 0 : delay;
+}
+
+/**
+ * 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 isUnserializableMarker(value) {
+  return !!value && typeof value === 'object' && '$unserializable' in value && typeof value.$unserializable === 'string';
+}
+function assertNoUnresolvedMarkers(value, path = '$') {
+  if (isUnserializableMarker(value)) {
+    if (value.$unserializable === 'actor' && path.endsWith('.src')) {
+      return;
+    }
+    throw new Error(`Unresolved ${value.$unserializable} at ${path}`);
+  }
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => assertNoUnresolvedMarkers(item, `${path}[${index}]`));
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    const child = value[key];
+    const isImplementationMarker = path === '$' && (key === 'actions' || key === 'guards' || key === 'actors' || key === 'delays' || key === 'schemas');
+    if (isImplementationMarker) {
+      continue;
+    }
+    assertNoUnresolvedMarkers(child, `${path}.${key}`);
+  }
+}
+function assertRootImplementationMarkers(json, implementations) {
+  for (const kind of ['actions', 'guards', 'actors', 'delays']) {
+    const map = json[kind];
+    if (!map) {
+      continue;
+    }
+    for (const key of Object.keys(map)) {
+      const value = map[key];
+      if (!isUnserializableMarker(value)) {
+        continue;
+      }
+      if (!implementations[kind]?.[key]) {
+        throw new Error(`Missing ${kind}.${key}`);
+      }
+    }
+  }
+}
+function extractSerializableDelays(delays) {
+  const result = {};
+  if (!delays) {
+    return result;
+  }
+  for (const key of Object.keys(delays)) {
+    const value = delays[key];
+    if (typeof value === 'number') {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function mergeImplementations(json, implementations) {
+  return {
+    actions: implementations.actions ?? {},
+    guards: implementations.guards ?? {},
+    actors: implementations.actors ?? {},
+    delays: {
+      ...extractSerializableDelays(json.delays),
+      ...(implementations.delays ?? {})
+    }
+  };
+}
+let _scxmlSessionId = 'session_' + Math.random().toString(36).slice(2);
+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_session';
+  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.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, implementations = {}) {
+  assertRootImplementationMarkers(json, implementations);
+  assertNoUnresolvedMarkers(json);
+  const resolvedImplementations = mergeImplementations(json, implementations);
+
+  // 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 iterNode(node, nodeKey) {
+    const originalEntryActions = 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: 'error.execution',
+          _scxmlEventType: 'platform',
+          _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: node.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,
+      choice: node.choice ? getTransitionConfig(node.choice) : undefined,
+      route: node.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: entryFn,
+      exit: node.exit ? iterActions(node.exit) : undefined,
+      invoke: node.invoke ? iterInvokeConfigs(node.invoke) : undefined,
+      meta: node.meta,
+      output: node._scxmlDonedata ? makeDonedataOutput(node._scxmlDonedata) : 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, resolvedImplementations);
+      } else if (isUnserializableMarker(inv.src)) {
+        src = inv.src.id ? resolvedImplementations.actors[inv.src.id] : undefined;
+        if (!src) {
+          throw new Error(`Missing actors.${inv.src.id ?? ''}`);
+        }
+      } else {
+        src = inv.src;
+      }
+      return {
+        src,
+        id: inv.id,
+        systemId: inv.systemId,
+        input: inv.input,
+        onDone: inv.onDone ? getTransitionConfig(inv.onDone) : undefined,
+        onError: inv.onError ? getTransitionConfig(inv.onError) : undefined,
+        onSnapshot: inv.onSnapshot ? getTransitionConfig(inv.onSnapshot) : undefined,
+        timeout: inv.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: 'error.execution',
+      _scxmlEventType: 'platform',
+      _scxmlEventData: {
+        tagname,
+        message,
+        line: NaN,
+        column: NaN,
+        reason: message
+      }
+    });
+    state.errored = true;
+  }
+  /** Execute an array of SCXML action JSON descriptors with context and enqueue. */
+  function executeActions(actions, x, enq, parentState) {
+    const state = parentState ?? {
+      enq,
+      errored: false
+    };
+    let context;
+    for (const action of actions) {
+      if (state.errored) break;
+      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 event = isExternal || action.id !== undefined ? {
+                ...action.event,
+                ...(isExternal ? {
+                  _scxmlExternal: true
+                } : {}),
+                ...(action.id !== undefined ? {
+                  _scxmlSendId: action.id
+                } : {})
+              } : action.event;
+              enq.raise(event, {
+                id: action.id,
+                delay: action.delay
+              });
+              break;
+            }
+          case '@xstate.cancel':
+            enq.cancel(action.id);
+            break;
+          case '@xstate.log':
+            enq.log(...action.args);
+            break;
+          case '@xstate.emit':
+            enq.emit(action.event);
+            break;
+          case '@xstate.assign':
+            context ??= {};
+            Object.assign(context, action.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';
+          eventData = {
+            type: 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 {
+            // Not a known child (e.g. #_scxml_sessionid) → self-raise
+            if (delay !== undefined) {
+              eventData._scxmlExternal = true;
+            }
+            enq.raise(eventData, {
+              id: scxmlAction.id,
+              delay
+            });
+          }
+        } else {
+          // Self-send or no special target: raise as external event
+          if (delay !== undefined) {
+            eventData._scxmlExternal = true;
+          }
+          enq.raise(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 = {
+          ...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 {
+        enq(x.actions[action.type], action.params);
+      }
+    }
+    return {
+      context: context ? {
+        ...x.context,
+        ...context
+      } : undefined,
+      errored: state.errored
+    };
+  }
+  function iterActions(actions) {
+    return (x, enq) => executeActions(actions, 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 => {
+      const target = Array.isArray(t.target) ? t.target[0] : t.target;
+      const targetConfig = t.target;
+
+      // No guard and no actions: simple static config
+      if (!t.guard && !t.actions?.length) {
+        return {
+          target: targetConfig,
+          description: t.description,
+          reenter: t.reenter,
+          meta: t.meta,
+          input: t.input
+        };
+      }
+
+      // Guard but no actions: static config with guard
+      if (t.guard && !t.actions?.length) {
+        return {
+          target: targetConfig,
+          guard: t.guard,
+          description: t.description,
+          reenter: t.reenter,
+          meta: t.meta,
+          input: t.input
+        };
+      }
+
+      // 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 {
+          guard: t.guard,
+          description: t.description,
+          reenter: t.reenter,
+          meta: t.meta,
+          input: t.input,
+          to: (x, enq) => {
+            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: result.context
+                };
+              }
+            }
+            return {};
+          }
+        };
+      }
+
+      // 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.
+      return {
+        guard: t.guard,
+        description: t.description,
+        reenter: t.reenter,
+        meta: t.meta,
+        input: t.input,
+        to: (_x, _enq) => {
+          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);
+            }
+          }
+          return {
+            target: targetConfig,
+            reenter: t.reenter
+          };
+        }
+      };
+    });
+  }
+  const rootNodeConfig = iterNode(json);
+  const contextConfig = json.context ? {
+    context: json.context
+  } : {};
+  _scxmlMachineName = json.id || '';
+  _scxmlSessionId = 'session_' + Math.random().toString(36).slice(2);
+  const machine = createMachine({
+    ...rootNodeConfig,
+    ...contextConfig,
+    version: json.version
+  });
+
+  // Register SCXML guard implementations
+  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 && providedGuards[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: resolvedImplementations.actions,
+    actors: resolvedImplementations.actors,
+    guards: {
+      ...providedGuards,
+      ...resolvedImplementations.guards
+    },
+    delays: resolvedImplementations.delays
+  });
+
+  // Keep the original JSON so `serializeMachine(machine)`
+  // round-trip losslessly.
+  provided._json = json;
+  return provided;
+}
+function isBuiltInActionJSON(action) {
+  return action.type.startsWith('@xstate.');
+}
+
+/**
+ * Machine-definition serialization.
+ *
+ * `machineConfigToJSON` converts a machine config into a JSON-safe structure
+ * (the `MachineJSON` shape accepted by `createMachineFromConfig`). The boundary
+ * between serializable structure and runtime implementations is explicit: any
+ * value that cannot be represented as data (inline functions, actor logic,
+ * runtime schemas) is replaced with an `{ "$unserializable": <kind> }` marker
+ * rather than silently dropped.
+ *
+ * A machine definition is fully portable iff its JSON contains no
+ * `$unserializable` markers; reviving a definition that has markers requires
+ * re-providing those implementations (e.g. via `machine.provide(...)` or the
+ * `actions`/`guards`/`actors` maps on `createMachineFromConfig` revival).
+ */
+
+/**
+ * Returns the JSON-serializable definition of a machine.
+ *
+ * Inline functions, actor logic, and runtime schemas cannot be represented as
+ * data; they appear as `{ "$unserializable": ... }` markers. A machine created
+ * via `createMachineFromConfig` returns its original JSON config (lossless
+ * round-trip):
+ *
+ * ```ts
+ * import { serializeMachine, createMachineFromConfig } from 'xstate';
+ *
+ * const json = serializeMachine(machine);
+ * const revived = createMachineFromConfig(
+ *   JSON.parse(JSON.stringify(json))
+ * );
+ * ```
+ */
+function serializeMachine(machine) {
+  return machine._json ?? machineConfigToJSON(machine.config);
+}
+
+/**
+ * State-node config keys that are part of the serializable definition. Keys
+ * outside this list (unknown/internal properties) are dropped.
+ */
+const STATE_NODE_KEYS = ['id', 'key', 'type', 'history', 'description', 'target', 'version', 'initial', 'context', 'on', 'after', 'always', 'choice', 'route', 'onTimeout', 'timeout', 'entry', 'exit', 'meta', 'output', 'tags', 'input', '_scxmlDonedata'];
+function marker(kind, id) {
+  const m = {
+    $unserializable: kind
+  };
+  if (id) {
+    m.id = id;
+  }
+  return m;
+}
+
+/** JSON-safe deep copy of a plain value; functions become markers. */
+function valueToJSON(value) {
+  if (typeof value === 'function') {
+    return marker('function', value.name || undefined);
+  }
+  if (value === null || typeof value !== 'object') {
+    return typeof value === 'bigint' || typeof value === 'symbol' ? marker('value') : value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(valueToJSON);
+  }
+  if (value.constructor !== Object && value.constructor !== undefined) {
+    // Class instances (actor logic, schemas, dates, ...) are not portable.
+    return marker('value');
+  }
+  const result = {};
+  for (const key of Object.keys(value)) {
+    const v = value[key];
+    if (v !== undefined) {
+      result[key] = valueToJSON(v);
+    }
+  }
+  return result;
+}
+function invokeToJSON(invoke) {
+  if (Array.isArray(invoke)) {
+    return invoke.map(invokeToJSON);
+  }
+  const def = invoke;
+  const result = {};
+  for (const key of Object.keys(def)) {
+    const value = def[key];
+    if (value === undefined) {
+      continue;
+    }
+    result[key] = key === 'src' && typeof value !== 'string' ?
+    // Actor logic keeps its dedicated marker kind so revival knows the
+    // contract is an actor, not a plain function.
+    marker('actor', value.id) : valueToJSON(value);
+  }
+  return result;
+}
+function implementationsToJSON(map, kind) {
+  if (!map) {
+    return undefined;
+  }
+  // Keys are preserved — they are the contract a revived machine must
+  // fulfill via provide() — while values become markers (or stay, for
+  // JSON-safe values like numeric delays).
+  const result = {};
+  for (const key of Object.keys(map)) {
+    const value = map[key];
+    result[key] = typeof value === 'function' ? marker('function', key) : value && typeof value === 'object' ? marker(kind, key) : value;
+  }
+  return result;
+}
+function stateNodeConfigToJSON(config) {
+  const result = {};
+  for (const key of STATE_NODE_KEYS) {
+    const value = config[key];
+    if (value !== undefined) {
+      result[key] = valueToJSON(value);
+    }
+  }
+  if (config.invoke !== undefined) {
+    result.invoke = invokeToJSON(config.invoke);
+  }
+  if (config.states) {
+    const states = {};
+    for (const key of Object.keys(config.states)) {
+      states[key] = stateNodeConfigToJSON(config.states[key]);
+    }
+    result.states = states;
+  }
+  return result;
+}
+
+/**
+ * Converts a machine config (as passed to `createMachine`) to its JSON-safe
+ * definition. See module docs for the `$unserializable` marker contract.
+ */
+function machineConfigToJSON(config) {
+  const result = stateNodeConfigToJSON(config);
+  if (config.internalEvents !== undefined) {
+    result.internalEvents = valueToJSON(config.internalEvents);
+  }
+  if (config.schemas) {
+    const schemas = {};
+    for (const key of Object.keys(config.schemas)) {
+      const value = config.schemas[key];
+      if (value && typeof value === 'object' && !('~standard' in value)) {
+        // Map-form schemas (events/emitted): preserve event-type keys.
+        schemas[key] = implementationsToJSON(value, 'schema');
+      } else {
+        schemas[key] = marker('schema', key);
+      }
+    }
+    result.schemas = schemas;
+  }
+  for (const key of ['actions', 'guards', 'actors', 'delays']) {
+    if (config[key]) {
+      result[key] = implementationsToJSON(config[key], key === 'actors' ? 'actor' : 'function');
+    }
+  }
+  return result;
 }
 
 /**
@@ -116,7 +1108,7 @@ function mapState(snapshot, mapper) {
     return mapper;
   };
   const visited = new Set();
-  for (const atomicNode of snapshot._nodes.filter(dist_xstateGuards.isAtomicStateNode)) {
+  for (const atomicNode of snapshot._nodes.filter(dist_xstateActors.isAtomicStateNode)) {
     let current = atomicNode;
     while (current && !visited.has(current)) {
       visited.add(current);
@@ -133,11 +1125,141 @@ function mapState(snapshot, mapper) {
   return results;
 }
 
+/** The Standard Schema interface. */
+
+/** A type-only Standard Schema produced by {@link types}. */
+
+/**
+ * Declares schema types for inference only — no runtime validation.
+ *
+ * Use in a machine's `schemas` when you want TypeScript types without pulling
+ * in a schema library like Zod. The returned value is a valid Standard Schema
+ * whose validation is the identity function, so it carries types but never
+ * rejects input.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createMachine, types } from 'xstate';
+ *
+ * const machine = createMachine({
+ *   schemas: {
+ *     context: types<{ count: number }>(),
+ *     events: {
+ *       inc: types<{ by: number }>(),
+ *       reset: types<{}>()
+ *     }
+ *   },
+ *   context: { count: 0 }
+ *   // ...
+ * });
+ * ```
+ */
+function types() {
+  return {
+    '~standard': {
+      version: 1,
+      vendor: 'xstate.types',
+      validate: value => ({
+        value: value
+      })
+    }
+  };
+}
+
+/** Returns true if the value is a type-only schema created by {@link types}. */
+function isTypeSchema(value) {
+  return !!value && typeof value === 'object' && '~standard' in value && value['~standard'].vendor === 'xstate.types';
+}
+
+// eslint-disable-next-line @typescript-eslint/no-namespace
+
+/** State schema with optional schemas.input and nested states */
+
+/** Extracts input type from a state schema */
+
+/**
+ * Converts SetupStateSchema to StateSchema with input types included. This
+ * allows getInputs() to be strongly typed.
+ */
+
+/** Converts the root setup states config to a StateSchema. */
+
+/** Machine config with typed state input */
+
+/** States config type that provides typed input for known states */
+
+/** State node config that recursively applies typed input for nested states */
+
+/** Initial transition with typed input based on target state */
+
+/** Return type of setup() */
+
+/**
+ * Sets up a state machine with state input schemas and other configuration.
+ *
+ * @example
+ *
+ * ```ts
+ * import { setup } from 'xstate';
+ * import z from 'zod';
+ *
+ * const s = setup({
+ *   states: {
+ *     loading: {
+ *       schemas: {
+ *         input: z.object({
+ *           userId: z.string()
+ *         })
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * const machine = s.createMachine({
+ *   initial: {
+ *     target: 'loading',
+ *     input: { userId: '123' }
+ *   },
+ *   states: {
+ *     loading: {
+ *       entry: ({ input }) => {
+ *         console.log(input.userId);
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+function setup(config = {}) {
+  const {
+    states = {},
+    schemas
+  } = config;
+  return {
+    createMachine(machineConfig) {
+      const configSchemas = machineConfig.schemas;
+      const mergedSchemas = schemas || configSchemas ? {
+        ...configSchemas,
+        ...schemas
+      } : undefined;
+      return new StateMachine.StateMachine(mergedSchemas ? {
+        ...machineConfig,
+        schemas: mergedSchemas
+      } : machineConfig);
+    },
+    createStateConfig(stateConfig) {
+      return stateConfig;
+    },
+    states
+  };
+}
+
 /** @internal */
 function createInertActorScope(actorLogic) {
-  const self = dist_xstateGuards.createActor(actorLogic);
+  const self = dist_xstateActors.createActor(actorLogic);
   const inertActorScope = {
-    self,
+    self: self,
     defer: () => {},
     id: '',
     logger: () => {},
@@ -192,60 +1314,8 @@ function getInitialSnapshot(actorLogic, ...[input]) {
 function getNextSnapshot(actorLogic, snapshot, event) {
   const inertActorScope = createInertActorScope(actorLogic);
   inertActorScope.self._snapshot = snapshot;
-  return actorLogic.transition(snapshot, event, inertActorScope);
-}
-
-// at the moment we allow extra actors - ones that are not specified by `children`
-// this could be reconsidered in the future
-
-// used to keep only StateSchema relevant keys
-// this helps with type serialization as it makes the inferred type much shorter when dealing with huge configs
-
-function setup({
-  schemas,
-  actors,
-  actions,
-  guards,
-  delays
-}) {
-  return {
-    assign: assign.assign,
-    sendTo: log.sendTo,
-    raise: dist_xstateGuards.raise,
-    log: log.log,
-    cancel: dist_xstateGuards.cancel,
-    stopChild: dist_xstateGuards.stopChild,
-    enqueueActions: log.enqueueActions,
-    emit: log.emit,
-    spawnChild: dist_xstateGuards.spawnChild,
-    createStateConfig: config => config,
-    createAction: fn => fn,
-    createMachine: config => createMachine({
-      ...config,
-      schemas
-    }, {
-      actors,
-      actions,
-      guards,
-      delays
-    }),
-    extend: extended => setup({
-      schemas,
-      actors,
-      actions: {
-        ...actions,
-        ...extended.actions
-      },
-      guards: {
-        ...guards,
-        ...extended.guards
-      },
-      delays: {
-        ...delays,
-        ...extended.delays
-      }
-    })
-  };
+  const transitionResult = actorLogic.transition(snapshot, event, inertActorScope);
+  return Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
@@ -310,6 +1380,11 @@ class SimulatedClock {
       }
     }
     this._flushing = false;
+    // Check if new timeouts were added during the last iteration
+    if (this._flushingInvalidated) {
+      this._flushingInvalidated = false;
+      this.flushTimeouts();
+    }
   }
   increment(ms) {
     this._now += ms;
@@ -351,6 +1426,138 @@ function toPromise(actor) {
   });
 }
 
+// this is needed to make JSDoc `@link` work properly
+
+/**
+ * @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 pending effect (delayed event/transition that has not fired yet) captured
+ * in a persisted snapshot — a serialized built-in action descriptor plus its
+ * runtime progress, with enough information to restore it under any strategy.
+ */
+
+/**
+ * How pending effects (timers) from a persisted snapshot are restored on
+ * `actor.start()`:
+ *
+ * - `'resume'` (default) — the clock was "frozen" while persisted: a 5-minute
+ *   timer persisted with 1 minute elapsed fires after 4 more minutes.
+ * - `'restart'` — timers start over with their full delay.
+ * - `'absolute'` — timers honor the original wall-clock expiry (`startedAt +
+ *   delay`); already-expired timers fire immediately.
+ * - A custom function receiving the pending effect and returning the remaining
+ *   delay in ms.
+ */
+
+/** @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 implementations 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. */
+
+// TODO: in v6, this should only accept AnyActorLogic, like ActorRefFromLogic
+
+/**
+ * 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 */
+
+/** Mappers for subscribeTo - maps lifecycle events to machine events */
+
 /**
  * Given actor `logic`, a `snapshot`, and an `event`, returns a tuple of the
  * `nextSnapshot` and `actions` to execute.
@@ -363,8 +1570,9 @@ function transition(logic, snapshot, event) {
   actorScope.actionExecutor = action => {
     executableActions.push(action);
   };
-  const nextSnapshot = logic.transition(snapshot, event, actorScope);
-  return [nextSnapshot, executableActions];
+  const transitionResult = logic.transition(snapshot, event, actorScope);
+  const [nextSnapshot, effects] = Array.isArray(transitionResult) ? transitionResult : [transitionResult, []];
+  return [nextSnapshot, executableActions.concat(effects)];
 }
 
 /**
@@ -394,7 +1602,7 @@ function getMicrosteps(machine, snapshot, event) {
   const actorScope = createInertActorScope(machine);
   const {
     microsteps
-  } = dist_xstateGuards.macrostep(snapshot, event, actorScope, []);
+  } = dist_xstateActors.macrostep(snapshot, event, actorScope, []);
   return microsteps;
 }
 
@@ -407,13 +1615,13 @@ function getMicrosteps(machine, snapshot, event) {
  */
 function getInitialMicrosteps(machine, ...[input]) {
   const actorScope = createInertActorScope(machine);
-  const initEvent = dist_xstateGuards.createInitEvent(input);
+  const initEvent = dist_xstateActors.createInitEvent(input);
   const internalQueue = [];
-  const preInitialSnapshot = machine._getPreInitialState(actorScope, initEvent, internalQueue);
-  const first = dist_xstateGuards.initialMicrostep(machine.root, preInitialSnapshot, actorScope, initEvent, internalQueue);
+  const preInitialSnapshot = machine._getPreInitialState(actorScope, initEvent);
+  const first = dist_xstateActors.initialMicrostep(machine.root, preInitialSnapshot, actorScope, initEvent, internalQueue);
   const {
     microsteps
-  } = dist_xstateGuards.macrostep(first[0], initEvent, actorScope, internalQueue);
+  } = dist_xstateActors.macrostep(first[0], initEvent, actorScope, internalQueue);
   return [first, ...microsteps];
 }
 
@@ -443,7 +1651,7 @@ function getInitialMicrosteps(machine, ...[input]) {
  */
 function getNextTransitions(state) {
   const potentialTransitions = [];
-  const atomicStates = state._nodes.filter(dist_xstateGuards.isAtomicStateNode);
+  const atomicStates = state._nodes.filter(dist_xstateActors.isAtomicStateNode);
   const visited = new Set();
 
   // Collect all transitions from atomic states and their ancestors
@@ -451,7 +1659,7 @@ function getNextTransitions(state) {
   for (const stateNode of atomicStates) {
     // For each atomic state, process the state itself first, then its ancestors
     // This ensures child state transitions come before parent state transitions
-    for (const s of [stateNode].concat(dist_xstateGuards.getProperAncestors(stateNode, undefined))) {
+    for (const s of [stateNode].concat(dist_xstateActors.getProperAncestors(stateNode, undefined))) {
       if (visited.has(s.id)) {
         continue;
       }
@@ -460,7 +1668,7 @@ function getNextTransitions(state) {
       // Get all transitions for each event type
       // Include ALL transitions, even if the same event type appears in multiple state nodes
       // This is important for guarded transitions - all are "potential" regardless of guard evaluation
-      for (const [, transitions] of s.transitions) {
+      for (const [, transitions] of s.transitions.entries()) {
         potentialTransitions.push(...transitions);
       }
 
@@ -577,51 +1785,51 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
+exports.Actor = dist_xstateActors.Actor;
+exports.TimeoutError = dist_xstateActors.TimeoutError;
+exports.__unsafe_getAllOwnEventDescriptors = dist_xstateActors.getAllOwnEventDescriptors;
+exports.checkStateIn = dist_xstateActors.checkStateIn;
+exports.createActor = dist_xstateActors.createActor;
+exports.createAsyncAtom = dist_xstateActors.createAsyncAtom;
+exports.createAsyncLogic = dist_xstateActors.createAsyncLogic;
+exports.createAtom = dist_xstateActors.createAtom;
+exports.createAtomConfig = dist_xstateActors.createAtomConfig;
+exports.createCallbackLogic = dist_xstateActors.createCallbackLogic;
 exports.createEmptyActor = dist_xstateActors.createEmptyActor;
-exports.fromCallback = dist_xstateActors.fromCallback;
-exports.fromEventObservable = dist_xstateActors.fromEventObservable;
-exports.fromObservable = dist_xstateActors.fromObservable;
-exports.fromPromise = dist_xstateActors.fromPromise;
-exports.fromTransition = dist_xstateActors.fromTransition;
-exports.Actor = dist_xstateGuards.Actor;
-exports.__unsafe_getAllOwnEventDescriptors = dist_xstateGuards.getAllOwnEventDescriptors;
-exports.and = dist_xstateGuards.and;
-exports.cancel = dist_xstateGuards.cancel;
-exports.createActor = dist_xstateGuards.createActor;
-exports.getStateNodes = dist_xstateGuards.getStateNodes;
-exports.interpret = dist_xstateGuards.interpret;
-exports.isMachineSnapshot = dist_xstateGuards.isMachineSnapshot;
-exports.matchesState = dist_xstateGuards.matchesState;
-exports.not = dist_xstateGuards.not;
-exports.or = dist_xstateGuards.or;
-exports.pathToStateValue = dist_xstateGuards.pathToStateValue;
-exports.raise = dist_xstateGuards.raise;
-exports.spawnChild = dist_xstateGuards.spawnChild;
-exports.stateIn = dist_xstateGuards.stateIn;
-exports.stop = dist_xstateGuards.stop;
-exports.stopChild = dist_xstateGuards.stopChild;
-exports.toObserver = dist_xstateGuards.toObserver;
+exports.createEventObservableLogic = dist_xstateActors.createEventObservableLogic;
+exports.createListenerLogic = dist_xstateActors.createListenerLogic;
+exports.createLogic = dist_xstateActors.createLogic;
+exports.createObservableLogic = dist_xstateActors.createObservableLogic;
+exports.createReducerAtom = dist_xstateActors.createReducerAtom;
+exports.createSubscriptionLogic = dist_xstateActors.createSubscriptionLogic;
+exports.getStateNodes = dist_xstateActors.getStateNodes;
+exports.isAtom = dist_xstateActors.isAtom;
+exports.isMachineSnapshot = dist_xstateActors.isMachineSnapshot;
+exports.listenerLogic = dist_xstateActors.listenerLogic;
+exports.matchesState = dist_xstateActors.matchesState;
+exports.pathToStateValue = dist_xstateActors.pathToStateValue;
+exports.subscriptionLogic = dist_xstateActors.subscriptionLogic;
+exports.toObserver = dist_xstateActors.toObserver;
 exports.StateMachine = StateMachine.StateMachine;
 exports.StateNode = StateMachine.StateNode;
-exports.assign = assign.assign;
-exports.SpecialTargets = log.SpecialTargets;
-exports.emit = log.emit;
-exports.enqueueActions = log.enqueueActions;
-exports.forwardTo = log.forwardTo;
-exports.log = log.log;
-exports.sendParent = log.sendParent;
-exports.sendTo = log.sendTo;
 exports.SimulatedClock = SimulatedClock;
+exports.SpecialTargets = SpecialTargets;
 exports.assertEvent = assertEvent;
 exports.createMachine = createMachine;
+exports.createMachineFromConfig = createMachineFromConfig;
+exports.createStateConfig = createStateConfig;
 exports.getInitialMicrosteps = getInitialMicrosteps;
 exports.getInitialSnapshot = getInitialSnapshot;
 exports.getMicrosteps = getMicrosteps;
 exports.getNextSnapshot = getNextSnapshot;
 exports.getNextTransitions = getNextTransitions;
 exports.initialTransition = initialTransition;
+exports.isTypeSchema = isTypeSchema;
+exports.machineConfigToJSON = machineConfigToJSON;
 exports.mapState = mapState;
+exports.serializeMachine = serializeMachine;
 exports.setup = setup;
 exports.toPromise = toPromise;
 exports.transition = transition;
+exports.types = types;
 exports.waitFor = waitFor;