xstate 6.0.0-alpha.4 → 6.0.0-alpha.41

package/dist/xstate.esm.js

@@ -1,7 +1,9 @@
-import { m as matchesEventDescriptor, t as toArray, p as parseDelayToMilliseconds, i as isAtomicStateNode, c as createActor, a as macrostep, b as createInitEvent, d as initialMicrostep, g as getProperAncestors } from './index-9cce3480.esm.js';
-export { A as Actor, T as TimeoutError, h as __unsafe_getAllOwnEventDescriptors, k as checkStateIn, c as createActor, w as createAsyncLogic, r as createCallbackLogic, q as createEmptyActor, u as createEventObservableLogic, x as createListenerLogic, v as createLogic, s as createObservableLogic, z as createSubscriptionLogic, f as getStateNodes, o as isBuiltInExecutableAction, e as isMachineSnapshot, y as listenerLogic, j as matchesState, l as pathToStateValue, B as subscriptionLogic, n as toObserver } from './index-9cce3480.esm.js';
-import { S as StateMachine } from './StateMachine-f310bc72.esm.js';
-export { S as StateMachine, a as StateNode } from './StateMachine-f310bc72.esm.js';
+export { T as TimeoutError, c as createAsyncLogic, a as createCallbackLogic, b as createEmptyActor, d as createEventObservableLogic, e as createLogic, f as createObservableLogic } from './index-a8ce72f1.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-a3f7750f.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-a3f7750f.esm.js';
+import { S as StateMachine } from './StateMachine-ee89d49f.esm.js';
+export { S as StateMachine, a as StateNode } from './StateMachine-ee89d49f.esm.js';
+export { c as getEffectDescriptor, a as getInitialMicrosteps, g as getMicrosteps, b as getNextTransitions, i as initialTransition, t as transition } from './effectDescriptor-57ae11fa.esm.js';
 
 /**
  * Asserts that the given event object is of the specified type or types. Throws
@@ -27,7 +29,7 @@ export { S as StateMachine, a as StateNode } from './StateMachine-f310bc72.esm.j
  * ```
  */
 function assertEvent(event, type) {
-  const types = toArray(type);
+  const types = toArray$1(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('", "')}"`;
@@ -75,7 +77,7 @@ function assertEvent(event, type) {
  *
  * @param config The state machine configuration.
  * @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
- *   to provide machine implementations instead.
+ *   to provide machine sources instead.
  */
 // Overload 1: With schemas.context — context type inferred from schema
 
@@ -89,11 +91,392 @@ 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
@@ -101,48 +484,23 @@ function delayToMs(delay) {
  * 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 isExpression(value) {
+  return !!value && typeof value === 'object' && typeof value['@expr'] === '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 isCode(value) {
+  return !!value && typeof value === 'object' && typeof value['@code'] === 'string';
 }
-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 isResolvable(value) {
+  return isExpression(value) || isCode(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}`;
 }
 function extractSerializableDelays(delays) {
   const result = {};
@@ -153,22 +511,267 @@ function extractSerializableDelays(delays) {
     const value = delays[key];
     if (typeof value === 'number') {
       result[key] = value;
+    } else if (value && typeof value === 'object' && typeof value.duration === 'number') {
+      result[key] = value.duration;
     }
   }
   return result;
 }
-function mergeImplementations(json, implementations) {
+function mergeSources(json, sources) {
   return {
-    actions: implementations.actions ?? {},
-    guards: implementations.guards ?? {},
-    actors: implementations.actors ?? {},
+    actions: sources.actions ?? {},
+    guards: sources.guards ?? {},
+    actors: sources.actors ?? {},
     delays: {
       ...extractSerializableDelays(json.delays),
-      ...(implementations.delays ?? {})
+      ...(sources.delays ?? {})
+    },
+    evaluators: sources.evaluators ?? {}
+  };
+}
+function createExpressionResolver(expressionLanguage, sources) {
+  function getEvaluator(value, path) {
+    const lang = value['@lang'] ?? expressionLanguage;
+    if (!lang) {
+      throw new Error(`Missing @exprLang for expression at ${path}`);
+    }
+    const evaluator = sources.evaluators[lang];
+    if (!evaluator) {
+      throw new Error(`Missing evaluator for @lang '${lang}' at ${path}`);
     }
+    return evaluator;
+  }
+  function evaluateResolvable(value, slot, scope, path) {
+    const kind = isExpression(value) ? 'expr' : 'code';
+    const source = isExpression(value) ? value['@expr'] : value['@code'];
+    return getEvaluator(value, path)({
+      source,
+      kind,
+      slot,
+      scope,
+      path
+    });
+  }
+  function resolveValue(value, slot, scope, path) {
+    if (isResolvable(value)) {
+      return evaluateResolvable(value, slot, scope, path);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item, index) => resolveValue(item, slot, scope, toPath(path, index)));
+    }
+    if (!value || typeof value !== 'object') {
+      return value;
+    }
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = resolveValue(value[key], slot, scope, toPath(path, key));
+    }
+    return result;
+  }
+  function makeScope(x, extra) {
+    return {
+      context: x.context,
+      event: x.event,
+      input: x.input,
+      self: x.self,
+      children: x.children,
+      params: x.params,
+      ...extra
+    };
+  }
+  function getDurationConfig(value, path) {
+    if (!isResolvable(value)) {
+      return value;
+    }
+    return args => delayToMs(resolveValue(value, 'delay', makeScope(args), path));
+  }
+  function assertResolvable(value, path) {
+    if (isResolvable(value)) {
+      getEvaluator(value, path);
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => assertResolvable(item, toPath(path, index)));
+      return;
+    }
+    if (!value || typeof value !== 'object') {
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      assertResolvable(value[key], toPath(path, key));
+    }
+  }
+  return {
+    evaluateResolvable,
+    resolveValue,
+    makeScope,
+    getDurationConfig,
+    assertResolvable
   };
 }
-let _scxmlSessionId = 'session_' + Math.random().toString(36).slice(2);
+function toActionArray(actions) {
+  return actions === undefined ? [] : Array.isArray(actions) ? actions : [actions];
+}
+function validateChoiceConfig(choice, path) {
+  if (!Array.isArray(choice)) {
+    return;
+  }
+  choice.forEach((branch, index) => {
+    if (branch.when === undefined && index !== choice.length - 1) {
+      throw new Error(`Choice fallback branch at ${path}[${index}] must be last.`);
+    }
+  });
+}
+function assertMachineJSON(json, resolvedSources, expressionResolver) {
+  const {
+    assertResolvable
+  } = expressionResolver;
+  function assertCondition(condition, path) {
+    if (!condition) {
+      return;
+    }
+    if (isResolvable(condition)) {
+      assertResolvable(condition, path);
+      return;
+    }
+    assertResolvable(condition.params, `${path}.params`);
+    if (json.guards?.[condition.type]) {
+      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)) {
+      throw new Error(`Missing guard source "${condition.type}"`);
+    }
+  }
+  function assertAction(action, path, stack = []) {
+    if (isResolvable(action)) {
+      assertResolvable(action, path);
+      return;
+    }
+    if (!action || typeof action.type !== 'string') {
+      throw new Error(`Invalid action at ${path}`);
+    }
+    assertResolvable(action.params, `${path}.params`);
+    if (isBuiltInActionType(action.type) || isScxmlActionType(action.type)) {
+      assertResolvable(action, path);
+      return;
+    }
+    const definition = json.actions?.[action.type];
+    if (definition) {
+      if (stack.includes(action.type)) {
+        throw new Error(`Circular action reference: ${stack.concat(action.type).join(' -> ')}`);
+      }
+      const definitions = Array.isArray(definition) ? definition : [definition];
+      definitions.forEach((item, index) => assertAction(item, `${path}.actions.${action.type}${definitions.length > 1 ? `[${index}]` : ''}`, stack.concat(action.type)));
+      return;
+    }
+    if (!resolvedSources.actions[action.type]) {
+      throw new Error(`Missing action source "${action.type}"`);
+    }
+  }
+  function assertActions(actions, path) {
+    toActionArray(actions).forEach((action, index) => assertAction(action, `${path}[${index}]`));
+  }
+  function assertTransition(transition, path) {
+    const transitions = Array.isArray(transition) ? transition : transition ? [transition] : [];
+    transitions.forEach((t, index) => {
+      const transitionPath = Array.isArray(transition) ? `${path}[${index}]` : path;
+      if (isResolvable(t)) {
+        assertResolvable(t, transitionPath);
+        return;
+      }
+      assertCondition(t.guard, `${transitionPath}.guard`);
+      assertActions(t.actions, `${transitionPath}.actions`);
+      assertResolvable(t.context, `${transitionPath}.context`);
+      assertResolvable(t.input, `${transitionPath}.input`);
+    });
+  }
+  function assertStateNode(node, path) {
+    if ((node.type === 'history' || node.history !== undefined) && !(typeof node.target === 'string' && node.target.trim().length > 0 || Array.isArray(node.target) && node.target.length > 0 && node.target.every(target => target.trim().length > 0))) {
+      throw new Error(`History state at ${path} must declare a non-empty target.`);
+    }
+    assertResolvable(node.context, `${path}.context`);
+    assertResolvable(node.input, `${path}.input`);
+    assertResolvable(node.output, `${path}.output`);
+    assertResolvable(node.timeout, `${path}.timeout`);
+    assertActions(node.entry, `${path}.entry`);
+    assertActions(node.exit, `${path}.exit`);
+    if (node.type === 'choice') {
+      if (!node.choice) {
+        throw new Error(`Choice state at ${path} must declare choice.`);
+      }
+      if (Array.isArray(node.choice)) {
+        validateChoiceConfig(node.choice, `${path}.choice`);
+        node.choice.forEach((branch, index) => {
+          assertCondition(branch.when, `${path}.choice[${index}].when`);
+          assertResolvable(branch.context, `${path}.choice[${index}].context`);
+          assertResolvable(branch.input, `${path}.choice[${index}].input`);
+        });
+      } else {
+        assertResolvable(node.choice, `${path}.choice`);
+      }
+    }
+    if (isResolvable(node.route)) {
+      assertResolvable(node.route, `${path}.route`);
+    }
+    if (node.invoke) {
+      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]) {
+          throw new Error(`Missing actor source "${invoke.src}"`);
+        }
+        assertResolvable(invoke.input, `${invokePath}.input`);
+        assertResolvable(invoke.timeout, `${invokePath}.timeout`);
+        assertTransition(invoke.onDone, `${invokePath}.onDone`);
+        assertTransition(invoke.onError, `${invokePath}.onError`);
+        assertTransition(invoke.onSnapshot, `${invokePath}.onSnapshot`);
+        assertTransition(invoke.onTimeout, `${invokePath}.onTimeout`);
+      });
+    }
+    if (node.on) {
+      for (const descriptor of Object.keys(node.on)) {
+        assertTransition(node.on[descriptor], `${path}.on.${descriptor}`);
+      }
+    }
+    if (node.after) {
+      for (const delay of Object.keys(node.after)) {
+        if (Number.isNaN(Number(delay)) && parseDelayToMilliseconds(delay) === undefined && !json.delays?.[delay] && !resolvedSources.delays[delay]) {
+          throw new Error(`Missing delay source "${delay}"`);
+        }
+        assertTransition(node.after[delay], `${path}.after.${delay}`);
+      }
+    }
+    assertTransition(node.always, `${path}.always`);
+    assertTransition(node.onError, `${path}.onError`);
+    assertTransition(node.onTimeout, `${path}.onTimeout`);
+    if (node.states) {
+      for (const key of Object.keys(node.states)) {
+        assertStateNode(node.states[key], `${path}.states.${key}`);
+      }
+    }
+  }
+  if (json.actions) {
+    for (const key of Object.keys(json.actions)) {
+      const actions = Array.isArray(json.actions[key]) ? json.actions[key] : [json.actions[key]];
+      actions.forEach((action, index) => assertAction(action, `$.actions.${key}${actions.length > 1 ? `[${index}]` : ''}`, [key]));
+    }
+  }
+  if (json.guards) {
+    for (const key of Object.keys(json.guards)) {
+      assertCondition(json.guards[key].when, `$.guards.${key}.when`);
+    }
+  }
+  if (json.delays) {
+    for (const key of Object.keys(json.delays)) {
+      const delay = json.delays[key];
+      assertResolvable(delay && typeof delay === 'object' && 'duration' in delay ? delay.duration : delay, `$.delays.${key}`);
+    }
+  }
+  assertStateNode(json, '$');
+}
+let _scxmlSessionId = 'session_scxml';
 let _scxmlMachineName = '';
 
 /** Evaluates an SCXML expression with context variables available via `with`. */
@@ -184,16 +787,16 @@ with (context) {
     if (!self) return false;
     try {
       const snap = self.getSnapshot?.();
-      if (snap?._nodes) {
+      if (snap?.nodes) {
         const sanitized = stateId.replace(/\./g, '$');
-        return snap._nodes.some(node => node.id === sanitized || node.id.endsWith('.' + sanitized));
+        return snap.nodes.some(node => node.id === sanitized || node.id.endsWith('.' + sanitized));
       }
     } catch {
       // ignore
     }
     return false;
   };
-  const SCXML_ORIGIN = '#_scxml_session';
+  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';
@@ -205,7 +808,7 @@ with (context) {
   const isDoneEvent = event && typeof event.type === 'string' && event.type.startsWith('xstate.done.');
   const explicitType = event && event._scxmlEventType;
   const scxmlEvent = event && !isInitEvent ? {
-    name: event.type,
+    name: event._scxmlEventName ?? toScxmlEventName(event.type),
     type: explicitType || (isExternal ? 'external' : 'internal'),
     sendid: event._scxmlSendId,
     origin: isExternal ? SCXML_ORIGIN : undefined,
@@ -240,10 +843,65 @@ return updates;
   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);
+function createMachineFromConfig(json, sources = {}) {
+  const resolvedSources = mergeSources(json, sources);
+  const expressionResolver = createExpressionResolver(json['@exprLang'], resolvedSources);
+  const {
+    evaluateResolvable,
+    resolveValue,
+    makeScope,
+    getDurationConfig
+  } = expressionResolver;
+  function resolveCondition(condition, slot, path) {
+    if (!condition) {
+      return undefined;
+    }
+    if (isResolvable(condition)) {
+      return args => !!evaluateResolvable(condition, slot, makeScope(args), path);
+    }
+    return args => {
+      const params = resolveValue(condition.params, slot, makeScope(args), `${path}.params`);
+      const declarativeGuard = json.guards?.[condition.type];
+      if (declarativeGuard) {
+        const guard = resolveCondition(declarativeGuard.when, 'guard', `$.guards.${condition.type}.when`);
+        return !!guard?.({
+          ...args,
+          params
+        });
+      }
+      const guardImpl = args.guards?.[condition.type];
+      if (!guardImpl) {
+        throw new Error(getMissingGuardMessage(condition.type, args.guards ?? {}));
+      }
+      return guardImpl(args, params);
+    };
+  }
+  function makeChoiceConfig(choice, path) {
+    if (!choice) {
+      return undefined;
+    }
+    if (isResolvable(choice)) {
+      return args => evaluateResolvable(choice, 'choice', makeScope(args), path);
+    }
+    validateChoiceConfig(choice, path);
+    return args => {
+      for (let index = 0; index < choice.length; index++) {
+        const branch = choice[index];
+        const guard = resolveCondition(branch.when, 'choice', `${path}[${index}].when`);
+        if (!guard || guard(args)) {
+          return {
+            target: branch.target,
+            context: branch.context ? resolveValue(branch.context, 'transitionContext', makeScope(args), `${path}[${index}].context`) : undefined,
+            input: branch.input !== undefined ? resolveValue(branch.input, 'input', makeScope(args), `${path}[${index}].input`) : undefined,
+            description: branch.description,
+            reenter: branch.reenter,
+            meta: branch.meta
+          };
+        }
+      }
+      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
@@ -266,22 +924,13 @@ function createMachineFromConfig(json, implementations = {}) {
   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 resolveGuardConfig(guard) {
-    if (!guard) {
-      return undefined;
-    }
-    return args => {
-      const guardImpl = args.guards?.[guard.type];
-      if (!guardImpl) {
-        throw new Error(getMissingGuardMessage(guard.type, args.guards ?? {}));
-      }
-      return guardImpl(args, guard.params);
-    };
-  }
-  function resolveRouteConfig(route) {
+  function resolveRouteConfig(route, path) {
     if (!route || typeof route === 'function') {
       return route;
     }
+    if (isResolvable(route)) {
+      return args => evaluateResolvable(route, 'transition', makeScope(args), path);
+    }
     const {
       guard,
       ...routeConfig
@@ -289,13 +938,13 @@ function createMachineFromConfig(json, implementations = {}) {
     if (!guard) {
       return routeConfig;
     }
-    const resolvedGuard = resolveGuardConfig({
+    const resolvedGuard = resolveCondition({
       type: guard
-    });
+    }, 'guard', path);
     return args => resolvedGuard(args) ? routeConfig : undefined;
   }
   function iterNode(node, nodeKey) {
-    const originalEntryActions = node.entry;
+    const originalEntryActions = toActionArray(node.entry);
     const stateId = node.id || nodeKey;
 
     // Wrap entry to first execute any pending transition actions, then normal entry.
@@ -309,8 +958,10 @@ function createMachineFromConfig(json, implementations = {}) {
       while (pendingPlatformErrors.length) {
         const err = pendingPlatformErrors.shift();
         enq.raise({
-          type: 'error.execution',
+          type: 'xstate.error.execution',
+          error: err,
           _scxmlEventType: 'platform',
+          _scxmlEventName: 'error.execution',
           _scxmlEventData: err
         });
       }
@@ -358,7 +1009,7 @@ function createMachineFromConfig(json, implementations = {}) {
       }
 
       // Execute normal entry actions
-      if (originalEntryActions?.length) {
+      if (originalEntryActions.length) {
         const mergedX = context ? {
           ...x,
           context
@@ -381,7 +1032,7 @@ function createMachineFromConfig(json, implementations = {}) {
       description: node.description,
       tags: node.tags,
       input: node.input,
-      timeout: node.timeout,
+      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;
@@ -391,18 +1042,27 @@ function createMachineFromConfig(json, implementations = {}) {
         return acc;
       }, {}) : undefined,
       always: node.always ? getTransitionConfig(node.always) : undefined,
-      choice: node.choice ? getTransitionConfig(node.choice) : undefined,
-      route: resolveRouteConfig(node.route),
+      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: entryFn,
-      exit: node.exit ? iterActions(node.exit) : 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) : node.output
+      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;
   }
@@ -454,24 +1114,19 @@ function createMachineFromConfig(json, implementations = {}) {
       // 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 ?? ''}`);
-        }
+        src = createMachineFromConfig(extInv._nestedMachineJSON, resolvedSources);
       } else {
-        src = inv.src;
+        src = resolvedSources.actors[inv.src] ?? inv.src;
       }
       return {
         src,
         id: inv.id,
-        systemId: inv.systemId,
-        input: inv.input,
+        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: inv.timeout,
+        timeout: getDurationConfig(inv.timeout, '$.invoke.timeout'),
         onTimeout: inv.onTimeout ? getTransitionConfig(inv.onTimeout) : undefined
       };
     });
@@ -485,8 +1140,16 @@ function createMachineFromConfig(json, implementations = {}) {
   function raiseErrorExecution(state, tagname, err) {
     const message = err instanceof Error ? err.message : typeof err === 'string' ? err : 'unknown error';
     state.enq.raise({
-      type: 'error.execution',
+      type: 'xstate.error.execution',
+      error: {
+        tagname,
+        message,
+        line: NaN,
+        column: NaN,
+        reason: message
+      },
       _scxmlEventType: 'platform',
+      _scxmlEventName: 'error.execution',
       _scxmlEventData: {
         tagname,
         message,
@@ -497,8 +1160,31 @@ function createMachineFromConfig(json, implementations = {}) {
     });
     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) {
+  function executeActions(actions, x, enq, parentState, stack = []) {
     const state = parentState ?? {
       enq,
       errored: false
@@ -506,22 +1192,34 @@ function createMachineFromConfig(json, implementations = {}) {
     let context;
     for (const action of actions) {
       if (state.errored) break;
-      if (isBuiltInActionJSON(action)) {
+      if (isResolvable(action)) {
+        const result = evaluateResolvable(action, 'action', makeScope(x, {
+          params: x.params,
+          enq
+        }), '$.actions');
+        if (result && typeof result === 'object' && 'context' in result && result.context) {
+          context ??= {};
+          Object.assign(context, result.context);
+        }
+      } else 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 ? {
-                ...action.event,
+                ...resolvedEvent,
                 ...(isExternal ? {
                   _scxmlExternal: true
                 } : {}),
                 ...(action.id !== undefined ? {
                   _scxmlSendId: action.id
                 } : {})
-              } : action.event;
+              } : resolvedEvent;
               enq.raise(event, {
                 id: action.id,
                 delay: action.delay
@@ -535,11 +1233,15 @@ function createMachineFromConfig(json, implementations = {}) {
             enq.log(...action.args);
             break;
           case '@xstate.emit':
-            enq.emit(action.event);
+            enq.emit(resolveValue(action.event, 'actionParams', makeScope(x, {
+              params: x.params
+            }), '$.actions.event'));
             break;
           case '@xstate.assign':
             context ??= {};
-            Object.assign(context, action.context);
+            Object.assign(context, resolveValue(action.context, 'transitionContext', makeScope(x, {
+              params: x.params
+            }), '$.actions.context'));
             break;
           default:
             throw new Error(`Unknown built-in action: ${action.type}`);
@@ -578,8 +1280,10 @@ function createMachineFromConfig(json, implementations = {}) {
         let delay;
         try {
           eventType = scxmlAction.eventexpr ? evaluateExpr(mergedContext, scxmlAction.eventexpr, x.event, x.self) : scxmlAction.event || 'unknown';
+          eventType = normalizeScxmlEventType(eventType);
           eventData = {
-            type: eventType
+            type: eventType,
+            _scxmlEventName: toScxmlEventName(eventType)
           };
           if (scxmlAction.params) {
             for (const param of scxmlAction.params) {
@@ -619,25 +1323,50 @@ function createMachineFromConfig(json, implementations = {}) {
           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 {
-            // Not a known child (e.g. #_scxml_sessionid) → self-raise
-            if (delay !== undefined) {
-              eventData._scxmlExternal = true;
-            }
-            enq.raise(eventData, {
+            // This SCXML session id uses the external event queue.
+            eventData._scxmlExternal = true;
+            enq.sendTo(x.self, eventData, {
               id: scxmlAction.id,
               delay
             });
           }
         } else {
-          // Self-send or no special target: raise as external event
-          if (delay !== undefined) {
+          // #_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
+            });
           }
-          enq.raise(eventData, {
-            id: scxmlAction.id,
-            delay
-          });
         }
       } else if (action.type === 'scxml.cancel') {
         const scxmlAction = action;
@@ -767,7 +1496,14 @@ function createMachineFromConfig(json, implementations = {}) {
           }
         }
       } else {
-        enq(x.actions[action.type], action.params);
+        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);
+        }
       }
     }
     return {
@@ -788,31 +1524,67 @@ function createMachineFromConfig(json, implementations = {}) {
     // 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 => {
+    return transitions.map((t, index) => {
+      if (isResolvable(t)) {
+        return (x, enq) => evaluateResolvable(t, '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 = resolveGuardConfig(t.guard);
+      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
+          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
+          input: t.input !== undefined ? resolveTransitionInput : undefined
         };
       }
 
@@ -821,12 +1593,14 @@ function createMachineFromConfig(json, implementations = {}) {
       // 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,
+          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)) {
@@ -838,11 +1612,16 @@ function createMachineFromConfig(json, implementations = {}) {
               const result = executeActions(t.actions, x, enq);
               if (result.context) {
                 return {
-                  context: result.context
+                  context: {
+                    ...context,
+                    ...result.context
+                  }
                 };
               }
             }
-            return {};
+            return context ? {
+              context
+            } : {};
           }
         };
       }
@@ -852,12 +1631,14 @@ function createMachineFromConfig(json, implementations = {}) {
       // 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 {
+        matches: t.matches,
         guard,
         description: t.description,
         reenter: t.reenter,
         meta: t.meta,
-        input: t.input,
+        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;
@@ -868,25 +1649,39 @@ function createMachineFromConfig(json, implementations = {}) {
           }
           return {
             target: targetConfig,
+            context,
             reenter: t.reenter
           };
         }
       };
     });
   }
+  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') {
+        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: json.context
+    context: args => resolveValue(json.context, 'context', args, '$.context')
   } : {};
   _scxmlMachineName = json.id || '';
-  _scxmlSessionId = 'session_' + Math.random().toString(36).slice(2);
+  _scxmlSessionId = 'session_scxml';
   const machine = createMachine({
     ...rootNodeConfig,
     ...contextConfig,
     version: json.version
   });
 
-  // Register SCXML guard implementations
+  // Register SCXML guard sources
   const providedGuards = {
     'scxml.cond': ({
       context,
@@ -917,8 +1712,8 @@ function createMachineFromConfig(json, implementations = {}) {
       if (!stateId) return false;
       const normalizedId = stateId.replace(/^#/, '');
       const snapshot = args._snapshot;
-      if (snapshot?._nodes) {
-        return snapshot._nodes.some(node => node.id === normalizedId);
+      if (snapshot?.nodes) {
+        return snapshot.nodes.some(node => node.id === normalizedId);
       }
       return false;
     },
@@ -932,13 +1727,13 @@ function createMachineFromConfig(json, implementations = {}) {
     }
   };
   const provided = machine.provide({
-    actions: resolvedImplementations.actions,
-    actors: resolvedImplementations.actors,
+    actions: resolvedSources.actions,
+    actors: resolvedSources.actors,
     guards: {
       ...providedGuards,
-      ...resolvedImplementations.guards
+      ...resolvedSources.guards
     },
-    delays: resolvedImplementations.delays
+    delays: resolvedSources.delays
   });
 
   // Keep the original JSON so `serializeMachine(machine)`
@@ -947,7 +1742,7 @@ function createMachineFromConfig(json, implementations = {}) {
   return provided;
 }
 function isBuiltInActionJSON(action) {
-  return action.type.startsWith('@xstate.');
+  return !isResolvable(action) && action.type.startsWith('@xstate.');
 }
 
 /**
@@ -955,24 +1750,17 @@ function isBuiltInActionJSON(action) {
  *
  * `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:
- * functions are represented as code expressions, while actor logic, runtime
- * schemas, and other non-code runtime values are 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).
+ * between serializable structure and runtime sources is explicit: functions are
+ * represented as `@code` source objects, while actor logic, runtime schemas,
+ * and other non-data runtime values are omitted.
  */
 
 /**
  * Returns the JSON-serializable definition of a machine.
  *
- * Inline functions are represented as `{ "@type": "code", lang: "ts", expr }`.
- * Actor logic and runtime schemas appear as `{ "$unserializable": ... }`
- * markers. A machine created via `createMachineFromConfig` returns its original
- * JSON config (lossless round-trip):
+ * Inline functions are represented as `{ "@code": string, "@lang": "ts" }`. A
+ * machine created via `createMachineFromConfig` returns its original JSON
+ * config (lossless round-trip):
  *
  * ```ts
  * import { serializeMachine, createMachineFromConfig } from 'xstate';
@@ -986,22 +1774,12 @@ function isBuiltInActionJSON(action) {
 function serializeMachine(machine) {
   return machine._json ?? machineConfigToJSON(machine.config);
 }
-function marker(kind, id) {
-  const m = {
-    $unserializable: kind
-  };
-  if (id) {
-    m.id = id;
-  }
-  return m;
-}
 
 // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 function codeExpression(fn) {
   return {
-    '@type': 'code',
-    lang: 'ts',
-    expr: fn.toString()
+    '@code': fn.toString(),
+    '@lang': 'ts'
   };
 }
 function isActorLogic(value) {
@@ -1017,33 +1795,37 @@ function valueToJSON(value) {
     return codeExpression(value);
   }
   if (value === null || typeof value !== 'object') {
-    return typeof value === 'bigint' || typeof value === 'symbol' ? marker('value') : value;
+    return typeof value === 'bigint' || typeof value === 'symbol' ? undefined : value;
   }
   if (isActorLogic(value)) {
-    return marker('actor', value.id);
+    return undefined;
   }
   if (isRuntimeSchema(value)) {
-    return marker('schema');
+    return undefined;
   }
   if (Array.isArray(value)) {
-    return value.map(valueToJSON);
+    return value.map(valueToJSON).filter(item => item !== undefined);
   }
   if (value.constructor !== Object && value.constructor !== undefined) {
     // Class instances (actor logic, schemas, dates, ...) are not portable.
-    return marker('value');
+    return undefined;
   }
   const result = {};
   for (const key of Object.keys(value)) {
     const v = value[key];
     if (v !== undefined) {
-      result[key] = valueToJSON(v);
+      const jsonValue = valueToJSON(v);
+      if (jsonValue !== undefined) {
+        result[key] = jsonValue;
+      }
     }
   }
   return result;
 }
 function invokeToJSON(invoke) {
   if (Array.isArray(invoke)) {
-    return invoke.map(invokeToJSON);
+    const values = invoke.map(invokeToJSON).filter(value => value !== undefined);
+    return values.length ? values : undefined;
   }
   const def = invoke;
   const result = {};
@@ -1052,32 +1834,28 @@ function invokeToJSON(invoke) {
     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);
+    result[key] = key === 'src' && typeof value !== 'string' ? value.id : valueToJSON(value);
+    if (result[key] === undefined) {
+      delete result[key];
+    }
   }
-  return result;
+  return result.src === undefined ? undefined : result;
 }
-function implementationsToJSON(map, kind) {
+function sourcesToJSON(map) {
   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];
-    if (kind === 'schema') {
-      result[key] = marker('schema', key);
-    } else if (typeof value === 'function') {
-      result[key] = codeExpression(value);
-    } else if (kind === 'actor' && value && typeof value === 'object') {
-      result[key] = marker('actor', key);
+    if (typeof value === 'function') {
+      result[key] = undefined;
     } else {
       result[key] = valueToJSON(value);
     }
+    if (result[key] === undefined) {
+      delete result[key];
+    }
   }
   return result;
 }
@@ -1093,7 +1871,10 @@ function stateNodeConfigToJSON(config) {
     }
   }
   if (config.invoke !== undefined) {
-    result.invoke = invokeToJSON(config.invoke);
+    const invoke = invokeToJSON(config.invoke);
+    if (invoke !== undefined) {
+      result.invoke = invoke;
+    }
   }
   if (config.states) {
     const states = {};
@@ -1107,7 +1888,7 @@ function stateNodeConfigToJSON(config) {
 
 /**
  * Converts a machine config (as passed to `createMachine`) to its JSON-safe
- * definition. See module docs for the `$unserializable` marker contract.
+ * definition.
  */
 function machineConfigToJSON(config) {
   const result = stateNodeConfigToJSON(config);
@@ -1120,16 +1901,24 @@ function machineConfigToJSON(config) {
       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');
+        schemas[key] = sourcesToJSON(value);
       } else {
-        schemas[key] = marker('schema', key);
+        schemas[key] = valueToJSON(value);
+      }
+      if (schemas[key] === undefined) {
+        delete schemas[key];
       }
     }
     result.schemas = schemas;
   }
   for (const key of ['actions', 'guards', 'actors', 'delays']) {
     if (config[key]) {
-      result[key] = implementationsToJSON(config[key], key === 'actors' ? 'actor' : 'function');
+      const value = sourcesToJSON(config[key]);
+      if (value && Object.keys(value).length) {
+        result[key] = value;
+      } else {
+        delete result[key];
+      }
     }
   }
   return result;
@@ -1164,7 +1953,7 @@ function mapState(snapshot, mapper) {
     return mapper;
   };
   const visited = new Set();
-  for (const atomicNode of snapshot._nodes.filter(isAtomicStateNode)) {
+  for (const atomicNode of snapshot.nodes.filter(isAtomicStateNode)) {
     let current = atomicNode;
     while (current && !visited.has(current)) {
       visited.add(current);
@@ -1181,8 +1970,235 @@ function mapState(snapshot, mapper) {
   return results;
 }
 
+function isObject(value) {
+  return value !== null && typeof value === 'object';
+}
+function isVersionedStateMachine(entry) {
+  return 'transition' in entry && typeof entry.transition === 'function';
+}
+function hasSnapshotSchema(entry) {
+  return 'snapshotSchema' in entry && entry.snapshotSchema !== undefined;
+}
+function hasEventSchema(entry) {
+  return 'eventSchema' in entry && entry.eventSchema !== undefined;
+}
+function getSnapshotSource(raw, defaultId) {
+  if (!isObject(raw)) {
+    return {};
+  }
+  if (isObject(raw.machine)) {
+    return {
+      id: typeof raw.machine.id === 'string' ? raw.machine.id : undefined,
+      version: typeof raw.machine.version === 'string' ? raw.machine.version : undefined
+    };
+  }
+  return {
+    id: typeof raw.version === 'string' ? defaultId : undefined,
+    version: typeof raw.version === 'string' ? raw.version : undefined
+  };
+}
+async function validate(schema, value, description) {
+  if (!schema) {
+    return value;
+  }
+  const result = await schema['~standard'].validate(value);
+  if (result.issues) {
+    throw new Error(`Invalid ${description}: ${result.issues[0]?.message}`);
+  }
+  return result.value;
+}
+async function finalizeSnapshot(snapshot, target) {
+  return await validate(target.snapshotSchema, {
+    ...snapshot,
+    machine: {
+      id: target.id,
+      version: target.version
+    },
+    version: target.version
+  }, `snapshot for machine '${target.id}' version '${target.version}'`);
+}
+async function validateEvents(events, source) {
+  return Promise.all(events.map(async (event, index) => {
+    const result = await source.eventSchema['~standard'].validate(event);
+    if (result.issues) {
+      const message = result.issues[0]?.message;
+      if (message?.startsWith('Unknown event ')) {
+        throw new Error(message);
+      }
+      const type = isObject(event) ? event.type : undefined;
+      throw new Error(typeof type === 'string' ? `Invalid event '${type}' at index ${index}${message ? `: ${message}` : '.'}` : `Invalid event at index ${index}${message ? `: ${message}` : '.'}`);
+    }
+    const validated = result.value;
+    if (!isObject(validated) || typeof validated.type !== 'string') {
+      throw new Error(`Invalid event at index ${index}.`);
+    }
+    return validated;
+  }));
+}
+
+/** Creates migration and adaptation utilities for versions of one machine. */
+function machineVersions(entries, options) {
+  const byIdentity = new Map();
+  const machinesByIdentity = new Map();
+  const machineId = entries[0].id;
+  for (const entry of entries) {
+    if (entry.version === undefined) {
+      throw new Error(`Machine '${entry.id}' must define a version.`);
+    }
+    if (entry.version === '*') {
+      throw new Error("Machine version '*' is reserved for wildcard migrations.");
+    }
+    if (entry.id !== machineId) {
+      throw new Error(`Machine '${entry.id}' does not match machine ID '${machineId}'.`);
+    }
+    const key = `${entry.id}\0${entry.version}`;
+    if (byIdentity.has(key)) {
+      throw new Error(`Duplicate machine identity '${entry.id}' version '${entry.version}'.`);
+    }
+    byIdentity.set(key, entry);
+    if (isVersionedStateMachine(entry)) {
+      machinesByIdentity.set(key, entry);
+    }
+  }
+  if (options?.unversioned !== undefined && !byIdentity.has(`${machineId}\0${options.unversioned}`)) {
+    throw new Error(`Unversioned snapshot version '${options.unversioned}' is not retained for machine '${machineId}'.`);
+  }
+  const parseSnapshot = async raw => {
+    if (!isObject(raw)) {
+      throw new Error('Persisted snapshot is missing machine identity.');
+    }
+    let id;
+    let version;
+    if (isObject(raw.machine)) {
+      ({
+        id,
+        version
+      } = raw.machine);
+      if (typeof id !== 'string' || typeof version !== 'string') {
+        throw new Error('Persisted snapshot has an invalid machine identity.');
+      }
+    } else if (typeof raw.version === 'string') {
+      id = machineId;
+      version = raw.version;
+    } else if (raw.version === undefined && options?.unversioned !== undefined) {
+      id = machineId;
+      version = options.unversioned;
+    } else {
+      throw new Error('Persisted snapshot is missing machine identity.');
+    }
+    if (raw.version !== undefined && typeof raw.version !== 'string') {
+      throw new Error('Persisted snapshot has an invalid version.');
+    }
+    if (raw.version !== undefined && raw.version !== version) {
+      throw new Error(`Persisted snapshot version '${raw.version}' conflicts with machine version '${version}'.`);
+    }
+    const source = byIdentity.get(`${id}\0${version}`);
+    if (!source) {
+      throw new Error(`Unknown machine identity '${id}' version '${version}'.`);
+    }
+    if (!hasSnapshotSchema(source)) {
+      throw new Error(`Machine version '${version}' does not define a snapshot schema.`);
+    }
+    const snapshot = await validate(source.snapshotSchema, raw, `snapshot for machine '${id}' version '${version}'`);
+    return {
+      source,
+      ...(isVersionedStateMachine(source) && {
+        machine: source
+      }),
+      snapshot: {
+        ...snapshot,
+        machine: {
+          id,
+          version
+        }
+      }
+    };
+  };
+  return {
+    parseSnapshot,
+    async adaptEvents(events, adaptationOptions) {
+      const target = machinesByIdentity.get(`${machineId}\0${adaptationOptions.to}`);
+      if (!target) {
+        throw new Error(`Target version '${adaptationOptions.to}' is not backed by a machine for '${machineId}'.`);
+      }
+      const sourceId = adaptationOptions.from.id ?? machineId;
+      const source = byIdentity.get(`${sourceId}\0${adaptationOptions.from.version}`);
+      let sourceError;
+      let sourceValidationFailed = false;
+      const hasTypedSource = source && hasEventSchema(source);
+      if (hasTypedSource) {
+        let sourceEvents;
+        try {
+          sourceEvents = await validateEvents(events, source);
+        } catch (error) {
+          sourceError = error;
+          sourceValidationFailed = true;
+        }
+        if (sourceEvents) {
+          if (source === target) {
+            return sourceEvents;
+          }
+          const adapter = adaptationOptions.adapters[source.version];
+          if (adapter) {
+            return validateEvents(await adapter(sourceEvents), target);
+          }
+        }
+      }
+      const wildcardAdapter = adaptationOptions.adapters['*'];
+      if (wildcardAdapter) {
+        return validateEvents(await wildcardAdapter(events, adaptationOptions.from), target);
+      }
+      if (hasTypedSource) {
+        if (sourceValidationFailed) {
+          throw sourceError instanceof Error ? sourceError : new Error(`Unable to validate event history for machine '${source.id}' version '${source.version}'.`, {
+            cause: sourceError
+          });
+        }
+        throw new Error(`No event adapter from version '${source.version}' to '${target.version}' for machine '${target.id}'.`);
+      }
+      if (source) {
+        throw new Error(`Machine version '${source.version}' does not define an event schema; only the '*' adapter can handle its event history.`);
+      }
+      throw new Error(`Unknown event history source '${sourceId}' version '${adaptationOptions.from.version}'.`);
+    },
+    async migrateSnapshot(raw, migrationOptions) {
+      const target = machinesByIdentity.get(`${machineId}\0${migrationOptions.to}`);
+      if (!target) {
+        throw new Error(`Target version '${migrationOptions.to}' is not backed by a machine for '${machineId}'.`);
+      }
+      let source;
+      let parseError;
+      try {
+        source = await parseSnapshot(raw);
+      } catch (error) {
+        parseError = error;
+      }
+      if (source) {
+        if (source.source.version === target.version) {
+          return finalizeSnapshot(source.snapshot, target);
+        }
+        const exactMigration = migrationOptions.migrations[source.source.version];
+        if (exactMigration) {
+          return finalizeSnapshot(await exactMigration(source.snapshot), target);
+        }
+      }
+      const wildcardMigration = migrationOptions.migrations['*'];
+      if (!wildcardMigration) {
+        if (source) {
+          throw new Error(`No snapshot migration from version '${source.source.version}' to '${target.version}' for machine '${target.id}'.`);
+        }
+        throw parseError;
+      }
+      const snapshot = await wildcardMigration(raw, getSnapshotSource(raw, machineId));
+      return finalizeSnapshot(snapshot, target);
+    }
+  };
+}
+
 /** The Standard Schema interface. */
 
+/** Schemas that can be declared for an individual state node. */
+
 /** A type-only Standard Schema produced by {@link types}. */
 
 /**
@@ -1232,6 +2248,28 @@ function isTypeSchema(value) {
 
 /** State schema with optional schemas.input and nested states */
 
+/**
+ * The sibling state schemas of a dotted path: the children of the path's
+ * parent. A bare transition target resolves relative to the parent, so the
+ * valid targets for a path's config are its siblings. For a dotless (top-level)
+ * path the siblings are the root states.
+ */
+
+// dotless path: siblings are the current level's states
+
+/**
+ * Resolves a dotted state path (e.g. `'parent.child'`) into the leaf
+ * `SetupStateSchema` it addresses, or `never` if any segment is missing.
+ */
+
+/** Union of every addressable dotted path into a setup states tree */
+
+/**
+ * Shared body of both `createStateConfig` overloads: the
+ * `StateNodeConfigWithNestedInput` instantiation whose only varying parts are
+ * the leading sibling-schemas and state-schema arguments.
+ */
+
 /** Extracts input type from a state schema */
 
 /**
@@ -1287,8 +2325,9 @@ function isTypeSchema(value) {
  * });
  * ```
  */
-function setup(config = {}) {
+const setup = function setupImplementation(config = {}) {
   const {
+    validator,
     states = {},
     schemas,
     actions,
@@ -1303,6 +2342,7 @@ function setup(config = {}) {
     createMachine(machineConfig) {
       const configSchemas = machineConfig.schemas;
       const mergedSchemas = mergeSchemas(configSchemas, schemas);
+      const mergedStates = mergeStateSchemas(machineConfig.states, states);
       const mergedActions = mergeMaps(actions, machineConfig.actions);
       const mergedActors = mergeMaps(actors, machineConfig.actors);
       const mergedGuards = mergeMaps(guards, machineConfig.guards);
@@ -1312,6 +2352,9 @@ function setup(config = {}) {
         ...(mergedSchemas ? {
           schemas: mergedSchemas
         } : undefined),
+        ...(mergedStates ? {
+          states: mergedStates
+        } : undefined),
         ...(mergedActions ? {
           actions: mergedActions
         } : undefined),
@@ -1324,12 +2367,62 @@ function setup(config = {}) {
         ...(mergedDelays ? {
           delays: mergedDelays
         } : undefined)
+      }, undefined, validator);
+    },
+    createStateConfig(...args) {
+      return args.length > 1 ? args[1] : args[0];
+    },
+    states,
+    schemas: schemas ?? {}
+  };
+};
+function createSystem(_config = {}) {
+  const runtimeRef = {};
+  const pendingObservers = [];
+  const flushObservers = () => {
+    const runtime = runtimeRef.current;
+    if (!runtime) {
+      return;
+    }
+    for (const entry of pendingObservers) {
+      if (entry.active && !entry.subscription) {
+        entry.subscription = runtime.inspect(entry.observer);
+      }
+    }
+  };
+  return {
+    createActor(logic, options) {
+      const actor = createActor(logic, {
+        ...options,
+        _systemRef: runtimeRef
       });
+      flushObservers();
+      return actor;
+    },
+    get(key) {
+      return runtimeRef.current?.get(key);
+    },
+    getAll() {
+      return runtimeRef.current?.getAll() ?? {};
     },
-    createStateConfig(stateConfig) {
-      return stateConfig;
+    inspect(observer) {
+      const runtime = runtimeRef.current;
+      if (runtime) {
+        return runtime.inspect(observer);
+      }
+      const entry = {
+        observer: observer,
+        active: true
+      };
+      pendingObservers.push(entry);
+      return {
+        unsubscribe() {
+          entry.active = false;
+          entry.subscription?.unsubscribe();
+        }
+      };
     },
-    states
+    setup: setup
   };
 }
 function mergeMaps(left, right) {
@@ -1346,10 +2439,39 @@ function mergeSchemas(left, right) {
     ...left,
     ...right,
     events: mergeMaps(left?.events, right?.events),
+    actions: mergeMaps(left?.actions, right?.actions),
+    guards: mergeMaps(left?.guards, right?.guards),
     emitted: mergeMaps(left?.emitted, right?.emitted),
     children: mergeMaps(left?.children, right?.children)
   };
 }
+
+/**
+ * Setup schemas win over inline config schemas (same precedence as root
+ * `mergeSchemas`); setup states with no matching config state are skipped.
+ */
+function mergeStateSchemas(configStates, setupStates) {
+  if (!configStates || !setupStates) {
+    return configStates;
+  }
+  return Object.fromEntries(Object.entries(configStates).map(([key, configState]) => {
+    const setupState = setupStates[key];
+    if (!setupState) {
+      return [key, configState];
+    }
+    const schemas = mergeMaps(configState.schemas, setupState.schemas);
+    const states = mergeStateSchemas(configState.states, setupState.states);
+    return [key, {
+      ...configState,
+      ...(schemas ? {
+        schemas
+      } : undefined),
+      ...(states ? {
+        states
+      } : undefined)
+    }];
+  }));
+}
 function mergeSetupConfigs(base, extension) {
   return {
     ...base,
@@ -1363,72 +2485,8 @@ function mergeSetupConfigs(base, extension) {
   };
 }
 
-/** @internal */
-function createInertActorScope(actorLogic) {
-  const self = createActor(actorLogic);
-  const inertActorScope = {
-    self: self,
-    defer: () => {},
-    id: '',
-    logger: () => {},
-    sessionId: '',
-    stopChild: () => {},
-    system: self.system,
-    emit: () => {},
-    actionExecutor: () => {}
-  };
-  return inertActorScope;
-}
-
-/** @deprecated Use `initialTransition(…)` instead. */
-function getInitialSnapshot(actorLogic, ...[input]) {
-  const actorScope = createInertActorScope(actorLogic);
-  return actorLogic.initialTransition(input, actorScope)[0];
-}
-
-/**
- * Determines the next snapshot for the given `actorLogic` based on the given
- * `snapshot` and `event`.
- *
- * If the `snapshot` is `undefined`, the initial snapshot of the `actorLogic` is
- * used.
- *
- * @deprecated Use `transition(…)` instead.
- * @example
- *
- * ```ts
- * import { getNextSnapshot } from 'xstate';
- * import { trafficLightMachine } from './trafficLightMachine.ts';
- *
- * const nextSnapshot = getNextSnapshot(
- *   trafficLightMachine, // actor logic
- *   undefined, // snapshot (or initial state if undefined)
- *   { type: 'TIMER' }
- * ); // event object
- *
- * console.log(nextSnapshot.value);
- * // => 'yellow'
- *
- * const nextSnapshot2 = getNextSnapshot(
- *   trafficLightMachine, // actor logic
- *   nextSnapshot, // snapshot
- *   { type: 'TIMER' }
- * ); // event object
- *
- * console.log(nextSnapshot2.value);
- * // =>'red'
- * ```
- */
-function getNextSnapshot(actorLogic, snapshot, event) {
-  const inertActorScope = createInertActorScope(actorLogic);
-  inertActorScope.self._snapshot = snapshot;
-  const transitionResult = actorLogic.transition(snapshot, event, inertActorScope);
-  return Array.isArray(transitionResult) ? transitionResult[0] : transitionResult;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+// oxlint-disable-next-line typescript/no-unsafe-declaration-merging
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 class SimulatedClock {
   constructor() {
     this.timeouts = new Map();
@@ -1535,6 +2593,7 @@ function toPromise(actor) {
 }
 
 // this is needed to make JSDoc `@link` work properly
+// oxlint-disable-next-line no-unused-vars
 
 /**
  * @remarks
@@ -1582,23 +2641,16 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
   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.
- */
+/** 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. */
 
 /**
- * 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.
+ * 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. */
@@ -1636,17 +2688,15 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
 /**
  * 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.
+ * 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. */
 
-// TODO: in v6, this should only accept AnyActorLogic, like ActorRefFromLogic
-
 /**
  * Represents logic which can be used by an actor.
  *
@@ -1664,121 +2714,11 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
 
 /** @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.
- *
- * This is a pure function that does not execute `actions`.
- */
-function transition(logic, snapshot, event) {
-  const actorScope = createInertActorScope(logic);
-  const [nextSnapshot, effects] = logic.transition(snapshot, event, actorScope);
-  return [nextSnapshot, effects];
-}
+/** The terminal result published when an actor completes or errors. */
 
-/**
- * Given actor `logic` and optional `input`, returns a tuple of the
- * `nextSnapshot` and `actions` to execute from the initial transition (no
- * previous state).
- *
- * This is a pure function that does not execute `actions`.
- */
-function initialTransition(logic, ...[input]) {
-  const actorScope = createInertActorScope(logic);
-  const [nextSnapshot, executableActions] = logic.initialTransition(input, actorScope);
-  return [nextSnapshot, executableActions];
-}
+/** An executable effect that publishes an actor's terminal result. */
 
-/**
- * Given a state `machine`, a `snapshot`, and an `event`, returns an array of
- * microsteps, where each microstep is a tuple of `[snapshot, actions]`.
- *
- * This is a pure function that does not execute `actions`.
- */
-function getMicrosteps(machine, snapshot, event) {
-  const actorScope = createInertActorScope(machine);
-  const {
-    microsteps
-  } = macrostep(snapshot, event, actorScope, []);
-  return microsteps;
-}
-
-/**
- * Given a state `machine` and optional `input`, returns an array of microsteps
- * from the initial transition, where each microstep is a tuple of `[snapshot,
- * actions]`.
- *
- * This is a pure function that does not execute `actions`.
- */
-function getInitialMicrosteps(machine, ...[input]) {
-  const actorScope = createInertActorScope(machine);
-  const initEvent = createInitEvent(input);
-  const internalQueue = [];
-  const preInitialSnapshot = machine._getPreInitialState(actorScope, initEvent);
-  const first = initialMicrostep(machine.root, preInitialSnapshot, actorScope, initEvent, internalQueue);
-  const {
-    microsteps
-  } = macrostep(first[0], initEvent, actorScope, internalQueue);
-  return [first, ...microsteps];
-}
-
-/**
- * Gets all potential next transitions from the current state.
- *
- * Returns all transitions that are available from the current state, including:
- *
- * - All transitions from atomic states (leaf states in the current state
- *   configuration)
- * - All transitions from ancestor states (parent states that may handle events)
- * - All guarded transitions (regardless of whether their guards would pass)
- * - Always (eventless) transitions
- * - After (delayed) transitions
- *
- * The order of transitions is deterministic:
- *
- * 1. Atomic states are processed in document order
- * 2. For each atomic state, transitions are collected from the state itself first,
- *    then its ancestors
- * 3. Within each state node, transitions are in the order they appear in the state
- *    definition
- *
- * @param state - The current machine snapshot
- * @returns Array of transition definitions from the current state, in
- *   deterministic order
- */
-function getNextTransitions(state) {
-  const potentialTransitions = [];
-  const atomicStates = state._nodes.filter(isAtomicStateNode);
-  const visited = new Set();
-
-  // Collect all transitions from atomic states and their ancestors
-  // Process atomic states in document order (as they appear in state._nodes)
-  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(getProperAncestors(stateNode, undefined))) {
-      if (visited.has(s.id)) {
-        continue;
-      }
-      visited.add(s.id);
-
-      // 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.entries()) {
-        potentialTransitions.push(...transitions);
-      }
-
-      // Also include always (eventless) transitions
-      if (s.always) {
-        potentialTransitions.push(...s.always);
-      }
-    }
-  }
-  return potentialTransitions;
-}
+/** Mappers for subscribeTo - maps lifecycle events to machine events */
 
 const defaultWaitForOptions = {
   timeout: Infinity // much more than 10 seconds
@@ -1815,7 +2755,7 @@ function waitFor(actorRef, predicate, options) {
       signal
     } = resolvedOptions;
     if (signal?.aborted) {
-      // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+      // oxlint-disable-next-line typescript/prefer-promise-reject-errors
       rej(signal.reason);
       return;
     }
@@ -1844,7 +2784,7 @@ function waitFor(actorRef, predicate, options) {
      * `abort` event
      */
     let abortListener;
-    // eslint-disable-next-line prefer-const
+    // oxlint-disable-next-line prefer-const
     let sub; // avoid TDZ when disposing synchronously
 
     // See if the current snapshot already matches the predicate
@@ -1858,7 +2798,7 @@ function waitFor(actorRef, predicate, options) {
       abortListener = () => {
         dispose();
         // XState does not "own" the signal, so we should reject with its reason (if any)
-        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+        // oxlint-disable-next-line typescript/prefer-promise-reject-errors
         rej(signal.reason);
       };
       signal.addEventListener('abort', abortListener);
@@ -1867,7 +2807,7 @@ function waitFor(actorRef, predicate, options) {
       next: checkEmitted,
       error: err => {
         dispose();
-        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+        // oxlint-disable-next-line typescript/prefer-promise-reject-errors
         rej(err);
       },
       complete: () => {
@@ -1881,4 +2821,4 @@ function waitFor(actorRef, predicate, options) {
   });
 }
 
-export { SimulatedClock, SpecialTargets, assertEvent, createMachine, createMachineFromConfig, createStateConfig, getInitialMicrosteps, getInitialSnapshot, getMicrosteps, getNextSnapshot, getNextTransitions, initialTransition, isTypeSchema, machineConfigToJSON, mapState, serializeMachine, setup, toPromise, transition, types, waitFor };
+export { SimulatedClock, SpecialTargets, assertEvent, createFSM, createMachine, createMachineFromConfig, createStateConfig, createSystem, isTypeSchema, machineConfigToJSON, machineVersions, mapState, serializeMachine, setup, toPromise, types, waitFor };