xstate 6.0.0-alpha.11 → 6.0.0-alpha.13

package/dist/xstate.cjs.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_xstateActors = require('./index-559ceab3.cjs.js');
-var StateMachine = require('./StateMachine-aef700df.cjs.js');
+var dist_xstateActors = require('./index-32631949.cjs.js');
+var StateMachine = require('./StateMachine-1b26c5de.cjs.js');
 
 /**
  * Asserts that the given event object is of the specified type or types. Throws
@@ -91,6 +91,339 @@ function createStateConfig(config) {
   return config;
 }
 
+const emptyImplementations = {
+  actions: {},
+  actorSources: {},
+  guards: {},
+  delays: {}
+};
+const emptyExecutableActions = [];
+const emptyRawActions = [];
+const builtInActionSet = new Set(Object.values(dist_xstateActors.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 dist_xstateActors.resolveActionsWithContext(snapshot, event, actorScope, rawActions);
+  };
+  const runStateActions = (snapshot, event, actorScope, actionsConfig, stateInput, internalQueue) => {
+    if (!actionsConfig) {
+      return [snapshot, emptyExecutableActions];
+    }
+    const actions = [];
+    const enq = dist_xstateActors.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 = dist_xstateActors.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 transition = (snapshot, event, actorScope) => {
+    if (snapshot.status !== 'active') {
+      return [snapshot, []];
+    }
+    if (event.type === dist_xstateActors.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 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: dist_xstateActors.XSTATE_INIT
+      }, actorScope, config.states[config.initial]?.entry, undefined, internalQueue);
+      if (!actions.length) {
+        actions = [];
+      }
+      while (internalQueue.length) {
+        const [raisedSnapshot, raisedActions] = transition(nextSnapshot, internalQueue.shift(), actorScope);
+        nextSnapshot = raisedSnapshot;
+        actions.push(...raisedActions);
+      }
+      return [nextSnapshot, 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 = dist_xstateActors.parseDelayToMilliseconds(delay);
   if (parsedDelay !== undefined) return parsedDelay;
@@ -103,48 +436,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 === 'actorSources' || 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', 'actorSources', '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 = {};
@@ -155,6 +463,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;
@@ -167,9 +477,248 @@ function mergeImplementations(json, implementations) {
     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
   };
 }
+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)) && dist_xstateActors.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.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_' + Math.random().toString(36).slice(2);
 let _scxmlMachineName = '';
 
@@ -243,9 +792,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
@@ -268,22 +872,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
@@ -291,13 +886,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.
@@ -360,7 +955,7 @@ function createMachineFromConfig(json, implementations = {}) {
       }
 
       // Execute normal entry actions
-      if (originalEntryActions?.length) {
+      if (originalEntryActions.length) {
         const mergedX = context ? {
           ...x,
           context
@@ -383,7 +978,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;
@@ -393,18 +988,26 @@ 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),
+      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;
   }
@@ -457,23 +1060,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.actorSources[inv.src.id] : undefined;
-        if (!src) {
-          throw new Error(`Missing actorSources.${inv.src.id ?? ''}`);
-        }
       } else {
-        src = inv.src;
+        src = resolvedImplementations.actorSources[inv.src] ?? inv.src;
       }
       return {
         src,
         id: inv.id,
         registryKey: inv.registryKey,
-        input: inv.input,
+        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
       };
     });
@@ -499,8 +1097,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
@@ -508,22 +1129,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
@@ -537,11 +1170,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}`);
@@ -769,7 +1406,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 {
@@ -790,31 +1434,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 = 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 {
+            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 (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,
           description: t.description,
           reenter: t.reenter,
           meta: t.meta,
-          input: t.input
+          input: t.input !== undefined ? resolveTransitionInput : undefined
         };
       }
 
@@ -827,8 +1503,9 @@ function createMachineFromConfig(json, implementations = {}) {
           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)) {
@@ -840,11 +1517,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
+            } : {};
           }
         };
       }
@@ -858,8 +1540,9 @@ function createMachineFromConfig(json, implementations = {}) {
         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;
@@ -870,15 +1553,29 @@ 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);
@@ -949,7 +1646,7 @@ function createMachineFromConfig(json, implementations = {}) {
   return provided;
 }
 function isBuiltInActionJSON(action) {
-  return action.type.startsWith('@xstate.');
+  return !isResolvable(action) && action.type.startsWith('@xstate.');
 }
 
 /**
@@ -958,24 +1655,16 @@ 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`/`actorSources` maps on `createMachineFromConfig`
- * revival).
+ * 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';
@@ -989,22 +1678,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) {
@@ -1020,33 +1699,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 = {};
@@ -1055,32 +1738,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 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];
-    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;
 }
@@ -1096,7 +1775,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 = {};
@@ -1110,7 +1792,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);
@@ -1123,16 +1805,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', 'actorSources', 'delays']) {
     if (config[key]) {
-      result[key] = implementationsToJSON(config[key], key === 'actorSources' ? 'actor' : 'function');
+      const value = implementationsToJSON(config[key]);
+      if (value && Object.keys(value).length) {
+        result[key] = value;
+      } else {
+        delete result[key];
+      }
     }
   }
   return result;
@@ -1962,6 +2652,7 @@ exports.StateNode = StateMachine.StateNode;
 exports.SimulatedClock = SimulatedClock;
 exports.SpecialTargets = SpecialTargets;
 exports.assertEvent = assertEvent;
+exports.createFSM = createFSM;
 exports.createMachine = createMachine;
 exports.createMachineFromConfig = createMachineFromConfig;
 exports.createStateConfig = createStateConfig;