xstate 6.0.0-alpha.2 → 6.0.0-alpha.21

package/dist/xstate.esm.js

@@ -1,7 +1,7 @@
-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-93edd3bd.esm.js';
-export { A as Actor, T as TimeoutError, o as __unsafe_getAllOwnEventDescriptors, r as checkStateIn, c as createActor, h as createAsyncAtom, B as createAsyncLogic, e as createAtom, f as createAtomConfig, w as createCallbackLogic, v as createEmptyActor, y as createEventObservableLogic, C as createListenerLogic, z as createLogic, x as createObservableLogic, j as createReducerAtom, E as createSubscriptionLogic, n as getStateNodes, k as isAtom, l as isMachineSnapshot, D as listenerLogic, q as matchesState, s as pathToStateValue, F as subscriptionLogic, u as toObserver } from './index-93edd3bd.esm.js';
-import { S as StateMachine } from './StateMachine-2dcdb1f5.esm.js';
-export { S as StateMachine, a as StateNode } from './StateMachine-2dcdb1f5.esm.js';
+import { m as matchesEventDescriptor, t as toArray$1, b as builtInActions, X as XSTATE_INIT, d as deriveDeferredStarts, c as createTransitionEnqueue, a as XSTATE_STOP, r as resolveActionsWithContext, p as parseDelayToMilliseconds, i as isAtomicStateNode, e as createActor, f as macrostep, g as createInitEvent, h as initialMicrostep, j as getProperAncestors } from './index-3f87408c.esm.js';
+export { A as Actor, T as TimeoutError, n as __unsafe_getAllOwnEventDescriptors, q as checkStateIn, e as createActor, C as createAsyncLogic, x as createCallbackLogic, w as createEmptyActor, z as createEventObservableLogic, D as createListenerLogic, B as createLogic, y as createObservableLogic, F as createSubscriptionLogic, l as getStateNodes, v as isBuiltInExecutableAction, k as isMachineSnapshot, E as listenerLogic, o as matchesState, s as pathToStateValue, G as subscriptionLogic, u as toObserver } from './index-3f87408c.esm.js';
+import { S as StateMachine } from './StateMachine-3c17fe3e.esm.js';
+export { S as StateMachine, a as StateNode } from './StateMachine-3c17fe3e.esm.js';
 
 /**
  * Asserts that the given event object is of the specified type or types. Throws
@@ -27,7 +27,7 @@ export { S as StateMachine, a as StateNode } from './StateMachine-2dcdb1f5.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('", "')}"`;
@@ -89,11 +89,354 @@ function createStateConfig(config) {
   return config;
 }
 
+const emptyImplementations = {
+  actions: {},
+  actorSources: {},
+  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: {},
+    _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,
+    _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,
+    _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({
+      type: action.action.name || '(anonymous)',
+      params: undefined,
+      args: action.args,
+      exec: action.args.length ? action.action.bind(null, ...action.args) : action.action
+    });
+  }
+  return executableActions;
+}
+function createFSM(config) {
+  const machine = {
+    id: config.id ?? '(fsm)',
+    implementations: emptyImplementations
+  };
+  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({
+        context: context ?? snapshot.context,
+        event: event,
+        input: stateInput,
+        value: snapshot.value,
+        self: actorScope.self,
+        system: actorScope.system,
+        parent: actorScope.self._parent,
+        children: snapshot.children
+      }, 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 = {
+        context: snapshot.context,
+        event,
+        input: snapshot.input,
+        value: snapshot.value,
+        self: actorScope.self,
+        system: actorScope.system,
+        parent: actorScope.self._parent,
+        children: snapshot.children
+      };
+      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) {
+      return [stopSnapshot(snapshot), emptyExecutableActions];
+    }
+    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 = 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
+        });
+        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({
+        context: snapshot.context,
+        event,
+        input: snapshot.input,
+        value: snapshot.value,
+        self: actorScope.self,
+        system: actorScope.system,
+        parent: actorScope.self._parent,
+        children: snapshot.children
+      }, 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) => {
+    const [nextSnapshot, effects] = transitionCore(...args);
+    return [nextSnapshot, [...effects, ...deriveDeferredStarts(effects)]];
+  };
+  const logic = {
+    id: config.id,
+    config,
+    transition,
+    initialTransition: (input, 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 [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 +444,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,6 +471,8 @@ 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;
@@ -161,14 +481,254 @@ function mergeImplementations(json, implementations) {
   return {
     actions: implementations.actions ?? {},
     guards: implementations.guards ?? {},
-    actors: implementations.actors ?? {},
+    actorSources: implementations.actorSources ?? {},
     delays: {
       ...extractSerializableDelays(json.delays),
       ...(implementations.delays ?? {})
+    },
+    evaluators: implementations.evaluators ?? {}
+  };
+}
+function createExpressionResolver(expressionLanguage, implementations) {
+  function getEvaluator(value, path) {
+    const lang = value['@lang'] ?? expressionLanguage;
+    if (!lang) {
+      throw new Error(`Missing @exprLang for expression at ${path}`);
+    }
+    const evaluator = implementations.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, resolvedImplementations, 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 (!resolvedImplementations.guards[condition.type] && !['scxml.cond', 'xstate.stateIn', 'xstate.not'].includes(condition.type)) {
+      throw new Error(`Missing guard implementation "${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 (!resolvedImplementations.actions[action.type]) {
+      throw new Error(`Missing action implementation "${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) {
+    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 && !resolvedImplementations.actorSources[invoke.src]) {
+          throw new Error(`Missing actorSource implementation "${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] && !resolvedImplementations.delays[delay]) {
+          throw new Error(`Missing delay implementation "${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`. */
@@ -193,7 +753,7 @@ with (context) {
     }
     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 +765,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,
@@ -241,9 +801,64 @@ return updates;
   return fn(context, updates);
 }
 function createMachineFromConfig(json, implementations = {}) {
-  assertRootImplementationMarkers(json, implementations);
-  assertNoUnresolvedMarkers(json);
   const resolvedImplementations = mergeImplementations(json, implementations);
+  const expressionResolver = createExpressionResolver(json['@exprLang'], resolvedImplementations);
+  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
@@ -263,8 +878,30 @@ function createMachineFromConfig(json, implementations = {}) {
   // <transition cond>). Drained by the next state's entry into the internal
   // event queue so they're processed before any external events.
   const pendingPlatformErrors = [];
+  function getMissingGuardMessage(type, guards) {
+    return `Guard '${type}' is not implemented in machine '${json.id ?? '(machine)'}'. Available guards: ${Object.keys(guards).map(key => `'${key}'`).join(', ') || '(none)'}.`;
+  }
+  function resolveRouteConfig(route, path) {
+    if (!route || typeof route === 'function') {
+      return route;
+    }
+    if (isResolvable(route)) {
+      return args => evaluateResolvable(route, 'transition', makeScope(args), path);
+    }
+    const {
+      guard,
+      ...routeConfig
+    } = route;
+    if (!guard) {
+      return routeConfig;
+    }
+    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.
@@ -278,8 +915,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
         });
       }
@@ -327,7 +966,7 @@ function createMachineFromConfig(json, implementations = {}) {
       }
 
       // Execute normal entry actions
-      if (originalEntryActions?.length) {
+      if (originalEntryActions.length) {
         const mergedX = context ? {
           ...x,
           context
@@ -350,7 +989,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;
@@ -360,18 +999,27 @@ function createMachineFromConfig(json, implementations = {}) {
         return acc;
       }, {}) : undefined,
       always: node.always ? getTransitionConfig(node.always) : undefined,
-      choice: node.choice ? getTransitionConfig(node.choice) : undefined,
-      route: 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;
   }
@@ -424,23 +1072,18 @@ function createMachineFromConfig(json, implementations = {}) {
       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;
+        src = resolvedImplementations.actorSources[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
       };
     });
@@ -454,8 +1097,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,
@@ -466,8 +1117,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
@@ -475,22 +1149,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
@@ -504,11 +1190,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}`);
@@ -547,8 +1237,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) {
@@ -588,25 +1280,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;
@@ -736,7 +1453,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 {
@@ -757,30 +1481,63 @@ 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 = 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 (!t.guard && !t.actions?.length) {
+      if (!guard && !t.actions?.length) {
+        if (t.context) {
+          return {
+            to: x => ({
+              target: targetConfig,
+              context: resolveTransitionContext(x),
+              reenter: t.reenter
+            }),
+            description: t.description,
+            meta: t.meta,
+            input: t.input !== undefined ? resolveTransitionInput : undefined
+          };
+        }
         return {
           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 (t.guard && !t.actions?.length) {
+      if (guard && !t.actions?.length) {
+        if (t.context) {
+          return {
+            guard,
+            to: x => ({
+              target: targetConfig,
+              context: resolveTransitionContext(x),
+              reenter: t.reenter
+            }),
+            description: t.description,
+            meta: t.meta,
+            input: t.input !== undefined ? resolveTransitionInput : undefined
+          };
+        }
         return {
           target: targetConfig,
-          guard: t.guard,
+          guard,
           description: t.description,
           reenter: t.reenter,
           meta: t.meta,
-          input: t.input
+          input: t.input !== undefined ? resolveTransitionInput : undefined
         };
       }
 
@@ -789,12 +1546,13 @@ function createMachineFromConfig(json, implementations = {}) {
       // For parallel (entries exist), first entry re-executes all in document order.
       if (!target) {
         return {
-          guard: t.guard,
+          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)) {
@@ -806,11 +1564,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
+            } : {};
           }
         };
       }
@@ -820,12 +1583,13 @@ 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 {
-        guard: t.guard,
+        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;
@@ -836,18 +1600,32 @@ 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') {
+        resolvedImplementations.delays[key] = delay;
+      } else if (typeof delay === 'string') {
+        resolvedImplementations.delays[key] = delayToMs(delay);
+      } else if (delay && typeof delay === 'object') {
+        resolvedImplementations.delays[key] = args => delayToMs(resolveValue(delay.duration, 'delay', makeScope(args), `$.delays.${key}.duration`));
+      }
+    }
+  }
+  assertMachineJSON(json, resolvedImplementations, 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,
@@ -892,7 +1670,7 @@ function createMachineFromConfig(json, implementations = {}) {
     },
     'xstate.not': (args, params) => {
       const inner = params?.guard;
-      const innerImpl = inner && providedGuards[inner.type];
+      const innerImpl = inner && args.guards?.[inner.type];
       if (!innerImpl) {
         throw new Error(`Guard '${inner?.type}' referenced by 'xstate.not' is not implemented.`);
       }
@@ -901,7 +1679,7 @@ function createMachineFromConfig(json, implementations = {}) {
   };
   const provided = machine.provide({
     actions: resolvedImplementations.actions,
-    actors: resolvedImplementations.actors,
+    actorSources: resolvedImplementations.actorSources,
     guards: {
       ...providedGuards,
       ...resolvedImplementations.guards
@@ -915,7 +1693,7 @@ function createMachineFromConfig(json, implementations = {}) {
   return provided;
 }
 function isBuiltInActionJSON(action) {
-  return action.type.startsWith('@xstate.');
+  return !isResolvable(action) && action.type.startsWith('@xstate.');
 }
 
 /**
@@ -923,24 +1701,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: 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).
+ * between serializable structure and runtime implementations 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, 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):
+ * 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';
@@ -955,48 +1726,57 @@ 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
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function codeExpression(fn) {
+  return {
+    '@code': fn.toString(),
+    '@lang': 'ts'
   };
-  if (id) {
-    m.id = id;
-  }
-  return m;
+}
+function isActorLogic(value) {
+  return !!value && typeof value === 'object' && typeof value.transition === 'function' && typeof value.getInitialSnapshot === 'function';
+}
+function isRuntimeSchema(value) {
+  return !!value && typeof value === 'object' && '~standard' in value;
 }
 
-/** JSON-safe deep copy of a plain value; functions become markers. */
+/** JSON-safe deep copy of a plain value; functions become code expressions. */
 function valueToJSON(value) {
   if (typeof value === 'function') {
-    return marker('function', value.name || undefined);
+    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 undefined;
+  }
+  if (isRuntimeSchema(value)) {
+    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 = {};
@@ -1005,37 +1785,47 @@ 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 implementationsToJSON(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];
-    result[key] = typeof value === 'function' ? marker('function', key) : value && typeof value === 'object' ? marker(kind, key) : value;
+    if (typeof value === 'function') {
+      result[key] = undefined;
+    } else {
+      result[key] = valueToJSON(value);
+    }
+    if (result[key] === undefined) {
+      delete result[key];
+    }
   }
   return result;
 }
 function stateNodeConfigToJSON(config) {
   const result = {};
-  for (const key of STATE_NODE_KEYS) {
+  for (const key of Object.keys(config)) {
+    if (key === 'states' || key === 'invoke') {
+      continue;
+    }
     const value = config[key];
     if (value !== undefined) {
       result[key] = valueToJSON(value);
     }
   }
   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 = {};
@@ -1049,7 +1839,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);
@@ -1062,16 +1852,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] = implementationsToJSON(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']) {
+  for (const key of ['actions', 'guards', 'actorSources', 'delays']) {
     if (config[key]) {
-      result[key] = implementationsToJSON(config[key], key === 'actors' ? 'actor' : 'function');
+      const value = implementationsToJSON(config[key]);
+      if (value && Object.keys(value).length) {
+        result[key] = value;
+      } else {
+        delete result[key];
+      }
     }
   }
   return result;
@@ -1174,6 +1972,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 */
 
 /**
@@ -1229,33 +2049,142 @@ function isTypeSchema(value) {
  * });
  * ```
  */
+
 function setup(config = {}) {
   const {
     states = {},
-    schemas
+    schemas,
+    actions,
+    actorSources,
+    guards,
+    delays
   } = config;
   return {
+    extend(extension) {
+      return setup(mergeSetupConfigs(config, extension));
+    },
     createMachine(machineConfig) {
       const configSchemas = machineConfig.schemas;
-      const mergedSchemas = schemas || configSchemas ? {
-        ...configSchemas,
-        ...schemas
-      } : undefined;
-      return new StateMachine(mergedSchemas ? {
+      const mergedSchemas = mergeSchemas(configSchemas, schemas);
+      const mergedActions = mergeMaps(actions, machineConfig.actions);
+      const mergedActorSources = mergeMaps(actorSources, machineConfig.actorSources);
+      const mergedGuards = mergeMaps(guards, machineConfig.guards);
+      const mergedDelays = mergeMaps(delays, machineConfig.delays);
+      return new StateMachine({
         ...machineConfig,
-        schemas: mergedSchemas
-      } : machineConfig);
+        ...(mergedSchemas ? {
+          schemas: mergedSchemas
+        } : undefined),
+        ...(mergedActions ? {
+          actions: mergedActions
+        } : undefined),
+        ...(mergedActorSources ? {
+          actorSources: mergedActorSources
+        } : undefined),
+        ...(mergedGuards ? {
+          guards: mergedGuards
+        } : undefined),
+        ...(mergedDelays ? {
+          delays: mergedDelays
+        } : undefined)
+      });
+    },
+    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);
     },
-    createStateConfig(stateConfig) {
-      return stateConfig;
+    getAll() {
+      return runtimeRef.current?.getAll() ?? {};
+    },
+    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(config) {
+      return config ? setup(config) : setup();
+    }
+  };
+}
+function mergeMaps(left, right) {
+  return left || right ? {
+    ...left,
+    ...right
+  } : undefined;
+}
+function mergeSchemas(left, right) {
+  if (!left && !right) {
+    return undefined;
+  }
+  return {
+    ...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)
+  };
+}
+function mergeSetupConfigs(base, extension) {
+  return {
+    ...base,
+    ...extension,
+    schemas: mergeSchemas(base.schemas, extension.schemas),
+    states: mergeMaps(base.states, extension.states),
+    actions: mergeMaps(base.actions, extension.actions),
+    actorSources: mergeMaps(base.actorSources, extension.actorSources),
+    guards: mergeMaps(base.guards, extension.guards),
+    delays: mergeMaps(base.delays, extension.delays)
   };
 }
 
 /** @internal */
 function createInertActorScope(actorLogic) {
-  const self = createActor(actorLogic);
+  const self = createActor(actorLogic, {
+    _inert: true
+  });
   const inertActorScope = {
     self: self,
     defer: () => {},
@@ -1273,7 +2202,7 @@ function createInertActorScope(actorLogic) {
 /** @deprecated Use `initialTransition(…)` instead. */
 function getInitialSnapshot(actorLogic, ...[input]) {
   const actorScope = createInertActorScope(actorLogic);
-  return actorLogic.getInitialSnapshot(actorScope, input);
+  return actorLogic.initialTransition(input, actorScope)[0];
 }
 
 /**
@@ -1563,14 +2492,9 @@ let SpecialTargets = /*#__PURE__*/function (SpecialTargets) {
  * This is a pure function that does not execute `actions`.
  */
 function transition(logic, snapshot, event) {
-  const executableActions = [];
   const actorScope = createInertActorScope(logic);
-  actorScope.actionExecutor = action => {
-    executableActions.push(action);
-  };
-  const transitionResult = logic.transition(snapshot, event, actorScope);
-  const [nextSnapshot, effects] = Array.isArray(transitionResult) ? transitionResult : [transitionResult, []];
-  return [nextSnapshot, executableActions.concat(effects)];
+  const [nextSnapshot, effects] = logic.transition(snapshot, event, actorScope);
+  return [nextSnapshot, effects];
 }
 
 /**
@@ -1581,12 +2505,8 @@ function transition(logic, snapshot, event) {
  * This is a pure function that does not execute `actions`.
  */
 function initialTransition(logic, ...[input]) {
-  const executableActions = [];
   const actorScope = createInertActorScope(logic);
-  actorScope.actionExecutor = action => {
-    executableActions.push(action);
-  };
-  const nextSnapshot = logic.getInitialSnapshot(actorScope, input);
+  const [nextSnapshot, executableActions] = logic.initialTransition(input, actorScope);
   return [nextSnapshot, executableActions];
 }
 
@@ -1780,4 +2700,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, getInitialMicrosteps, getInitialSnapshot, getMicrosteps, getNextSnapshot, getNextTransitions, initialTransition, isTypeSchema, machineConfigToJSON, mapState, serializeMachine, setup, toPromise, transition, types, waitFor };