xstate 6.0.0-alpha.48 → 6.0.0-alpha.49

package/dist/fsm-c1316948.development.cjs.js

@@ -0,0 +1,777 @@
+'use strict';
+
+var createActor = require('./createActor-a1e0dffb.development.cjs.js');
+
+const allocations = new WeakMap();
+function beginFSMEffects(scope, snapshot) {
+  allocations.set(scope, {
+    ids: new Set(Object.keys(snapshot.children)),
+    counters: {
+      ...snapshot._nextActorIds
+    }
+  });
+}
+function execute(runtime = this.source?.system ?? this.actor?.system) {
+  switch (this.type) {
+    case '@xstate.spawn':
+      return runtime.spawnActor(this.source, this.actor);
+    case '@xstate.start':
+      return runtime.startActor(this.actor);
+    case '@xstate.stop':
+      return runtime.stopActor(this.actor);
+    case '@xstate.terminate':
+      return runtime.terminateActor(this.actor, this);
+    case '@xstate.raise':
+    case '@xstate.sendTo':
+      {
+        if (this.delay === undefined) {
+          return runtime.sendEvent(this.source, this.target, this.event);
+        }
+        const timer = this.source.getSnapshot().timers[this.id];
+        if (timer && !runtime._clock.now) {
+          timer.startedAt = Date.now();
+        }
+        return runtime.scheduleTimer(this.source, this.id, this.delay);
+      }
+    case '@xstate.cancel':
+      return runtime.cancelTimer(this.source, this.id);
+    case '@xstate.emit':
+      return runtime.emitEvent(this.source, this.event);
+    default:
+      return this.action?.(...this.args);
+  }
+}
+function effect(type, fields = {}) {
+  return {
+    kind: 'builtin',
+    type,
+    params: undefined,
+    args: [],
+    exec: execute,
+    ...fields
+  };
+}
+function createFSMEnqueue(scope, effects, internalEvents) {
+  const enqueue = (action, ...args) => {
+    effects.push(effect(action.name || '(anonymous)', {
+      kind: 'action',
+      action,
+      args
+    }));
+  };
+  enqueue.cancel = id => {
+    effects.push(effect('@xstate.cancel', {
+      source: scope.self,
+      id
+    }));
+  };
+  enqueue.emit = event => {
+    effects.push(effect('@xstate.emit', {
+      kind: 'emit',
+      type: '@xstate.emit',
+      source: scope.self,
+      event
+    }));
+  };
+  enqueue.log = (...args) => {
+    enqueue(scope.logger, ...args);
+  };
+  enqueue.raise = (event, options) => {
+    if (typeof event === 'string') {
+      throw new Error('Only event objects may be used with raise');
+    }
+    if (options?.delay === undefined) {
+      internalEvents.push(event);
+    } else {
+      effects.push(effect('@xstate.raise', {
+        source: scope.self,
+        event,
+        id: options.id,
+        delay: options.delay
+      }));
+    }
+  };
+  enqueue.sendTo = (target, event, options) => {
+    if (!target) {
+      internalEvents.push({
+        type: 'xstate.error.communication',
+        error: {
+          message: 'Unable to send event to an undefined actor',
+          event
+        }
+      });
+      return;
+    }
+    effects.push(effect('@xstate.sendTo', {
+      source: scope.self,
+      target,
+      event,
+      id: options?.id,
+      delay: options?.delay
+    }));
+  };
+  const spawn = (logic, options = {}) => {
+    if (typeof logic === 'string') {
+      throw new Error(`Actor source "${logic}" not found`);
+    }
+    const allocation = allocations.get(scope);
+    let id = options.id;
+    let prefix;
+    let next;
+    if (id === undefined) {
+      prefix = logic.id ?? 'x';
+      if (prefix === '(machine)') {
+        prefix = 'x';
+      }
+      next = allocation.counters[prefix] ?? 0;
+      do {
+        id = `${prefix}:${next++}`;
+      } while (allocation.ids.has(id));
+      allocation.counters[prefix] = next;
+    }
+    if (allocation.ids.has(id)) {
+      throw new Error(`Actor with id "${id}" already exists`);
+    }
+    allocation.ids.add(id);
+    const actor = scope.system.createActorRef(logic, {
+      ...options,
+      id,
+      parent: scope.self
+    });
+    effects.push(effect('@xstate.spawn', {
+      source: scope.self,
+      actor,
+      id,
+      logic,
+      src: logic,
+      input: options.input,
+      childUpdate: {
+        type: 'add',
+        actor,
+        id,
+        prefix,
+        next
+      }
+    }));
+    return actor;
+  };
+  enqueue.spawn = spawn;
+  enqueue.stop = actor => {
+    if (actor) {
+      allocations.get(scope)?.ids.delete(actor.id);
+      effects.push(effect('@xstate.stop', {
+        source: scope.self,
+        actor,
+        id: actor.id,
+        childUpdate: {
+          type: 'remove',
+          actor: actor
+        }
+      }));
+    }
+  };
+  const attach = (logic, input) => {
+    const actor = scope.system.createActorRef(logic, {
+      input,
+      parent: scope.self
+    });
+    effects.push(effect('@xstate.spawn', {
+      source: scope.self,
+      actor,
+      id: actor.id,
+      logic,
+      src: logic,
+      input
+    }));
+    return actor;
+  };
+  enqueue.listen = (actor, eventType, mapper) => attach(createActor.listenerLogic, {
+    actor,
+    eventType,
+    mapper
+  });
+  enqueue.subscribeTo = (actor, mappers) => attach(createActor.subscriptionLogic, {
+    actor,
+    mappers: typeof mappers === 'function' ? {
+      snapshot: mappers
+    } : mappers
+  });
+  return enqueue;
+}
+function resolveFSMEffects(snapshot, effects, scope) {
+  let nextSnapshot = snapshot;
+  for (const current of effects) {
+    const update = current.childUpdate;
+    if (update?.type === 'add') {
+      nextSnapshot = {
+        ...nextSnapshot,
+        children: {
+          ...nextSnapshot.children,
+          [update.id]: update.actor
+        },
+        ...(update.prefix && {
+          _nextActorIds: {
+            ...nextSnapshot._nextActorIds,
+            [update.prefix]: Math.max(nextSnapshot._nextActorIds?.[update.prefix] ?? 0, update.next)
+          }
+        })
+      };
+    } else if (update?.type === 'remove') {
+      const children = {
+        ...nextSnapshot.children
+      };
+      let owned = update.actor._parent === scope.self;
+      for (const id of Object.keys(children)) {
+        if (children[id] === update.actor) {
+          owned = true;
+          delete children[id];
+        }
+      }
+      if (!owned) {
+        throw new Error(`Cannot stop non-child actor ${update.actor.id}`);
+      }
+      nextSnapshot = {
+        ...nextSnapshot,
+        children
+      };
+    }
+    if (current.type === '@xstate.cancel') {
+      if (nextSnapshot.timers[current.id]) {
+        const timers = {
+          ...nextSnapshot.timers
+        };
+        delete timers[current.id];
+        nextSnapshot = {
+          ...nextSnapshot,
+          timers
+        };
+      }
+    } else if ((current.type === '@xstate.raise' || current.type === '@xstate.sendTo') && current.delay !== undefined) {
+      const timer = current;
+      const generated = timer.id === undefined;
+      const id = timer.id ?? `xstate.timer.auto.${nextSnapshot._nextTimerId}`;
+      timer.id = id;
+      nextSnapshot = {
+        ...nextSnapshot,
+        timers: {
+          ...nextSnapshot.timers,
+          [id]: {
+            id,
+            delay: timer.delay,
+            type: timer.type,
+            event: timer.event,
+            target: timer.type === '@xstate.raise' || timer.target === scope.self ? 'self' : timer.target
+          }
+        },
+        _nextTimerId: generated ? nextSnapshot._nextTimerId + 1 : nextSnapshot._nextTimerId
+      };
+    }
+  }
+  return [nextSnapshot, effects];
+}
+function appendFSMStarts(effects) {
+  const ordered = [];
+  const attached = [];
+  const children = [];
+  for (const current of effects) {
+    if (current.type === '@xstate.stop') {
+      for (const starts of [attached, children]) {
+        const index = starts.findIndex(start => start.actor === current.actor);
+        if (index !== -1) {
+          ordered.push(starts.splice(index, 1)[0]);
+        }
+      }
+    }
+    ordered.push(current);
+    if (current.type !== '@xstate.spawn') {
+      continue;
+    }
+    const start = effect('@xstate.start', {
+      actor: current.actor,
+      id: current.id,
+      source: current.source
+    });
+    (current.logic === createActor.listenerLogic || current.logic === createActor.subscriptionLogic ? attached : children).push(start);
+  }
+  return ordered.concat(attached, children);
+}
+function createFSMSendEffect(scope, target, event) {
+  return effect('@xstate.sendTo', {
+    source: scope.self,
+    target,
+    event
+  });
+}
+function finalizeFSMEffects(scope, previous, result) {
+  const [snapshot, effects] = result;
+  if ((snapshot.status === 'done' || snapshot.status === 'error') && previous?.status !== 'done' && previous?.status !== 'error') {
+    effects.push(effect('@xstate.terminate', {
+      source: scope.self,
+      actor: scope.self,
+      id: scope.self.id,
+      status: snapshot.status,
+      output: snapshot.output,
+      error: snapshot.error
+    }));
+  }
+  return [snapshot, effects];
+}
+
+const emptySources = {
+  actions: {},
+  actors: {},
+  guards: {},
+  delays: {}
+};
+const emptyExecutableActions = [];
+const emptyFSMActions = [];
+function assertPersistableFSM(children, timers) {
+  if (Object.keys(children).length) {
+    throw new Error('FSM child persistence requires registered sources.');
+  }
+  for (const id in timers) {
+    if (timers[id].target !== 'self') {
+      throw new Error(`FSM timer '${id}' must target self to be persisted.`);
+    }
+  }
+}
+function toArray(value) {
+  return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}
+function resolveContext(context, input) {
+  return typeof context === 'function' ? context({
+    input
+  }) : context ?? {};
+}
+function resolveTransitionContext(context, args) {
+  return typeof context === 'function' ? context(args) : context;
+}
+function resolveInput(input, context, event) {
+  return typeof input === 'function' ? input({
+    context,
+    event
+  }) : input;
+}
+function mergeContextPatch(context, patch) {
+  for (const key of Object.keys(patch)) {
+    if (!Object.prototype.hasOwnProperty.call(context, key) || !Object.is(context[key], patch[key])) {
+      return {
+        ...context,
+        ...patch
+      };
+    }
+  }
+  return context;
+}
+function createSnapshot(value, context, input, machine, stateInput) {
+  return {
+    status: 'active',
+    output: undefined,
+    error: undefined,
+    value,
+    context,
+    input,
+    children: {},
+    timers: {},
+    _nextTimerId: 0,
+    _stateInput: stateInput,
+    machine
+  };
+}
+function cloneSnapshot(snapshot, value, context, stateInput) {
+  return {
+    status: snapshot.status,
+    output: snapshot.output,
+    error: snapshot.error,
+    value,
+    context,
+    input: snapshot.input,
+    children: snapshot.children,
+    timers: snapshot.timers,
+    _nextTimerId: snapshot._nextTimerId,
+    // Carried across state changes: dropping these would let a later spawn
+    // reuse the id of a still-running child.
+    _nextActorIds: snapshot._nextActorIds,
+    _stateInput: stateInput,
+    machine: snapshot.machine
+  };
+}
+function stopSnapshot(snapshot) {
+  return {
+    status: 'stopped',
+    output: undefined,
+    error: undefined,
+    value: snapshot.value,
+    context: snapshot.context,
+    input: undefined,
+    children: snapshot.children,
+    timers: snapshot.timers,
+    _nextTimerId: snapshot._nextTimerId,
+    _nextActorIds: snapshot._nextActorIds,
+    _stateInput: snapshot._stateInput,
+    machine: snapshot.machine
+  };
+}
+function cleanupFSM(snapshot, actorScope) {
+  const effects = [];
+  const enqueue = createFSMEnqueue(actorScope, effects, []);
+  for (const child of Object.values(snapshot.children)) {
+    enqueue.stop(child);
+  }
+  for (const id of Object.keys(snapshot.timers)) {
+    enqueue.cancel(id);
+  }
+  return resolveFSMEffects(snapshot, effects, actorScope);
+}
+function completeFinalState(snapshot, event, actorScope, internalQueue, states, runStateActions) {
+  const completed = {
+    ...snapshot,
+    status: 'done',
+    output: undefined,
+    error: undefined
+  };
+  const [exited, exitEffects] = runStateActions(completed, event, actorScope, states[completed.value]?.exit, completed._stateInput, internalQueue);
+  const [cleaned, cleanupEffects] = cleanupFSM(exited, actorScope);
+  return [cleaned, [...exitEffects, ...cleanupEffects]];
+}
+function invalidStringTarget(path, target) {
+  throw new Error(`Invalid transition for "${path}": use { target: "${target}" } instead of a string target.`);
+}
+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') {
+          invalidStringTarget(`${stateKey}.${eventType}`, transition);
+        }
+      }
+    }
+    if (stateConfig.always) {
+      for (const transition of toArray(stateConfig.always)) {
+        if (typeof transition === 'string') {
+          invalidStringTarget(`${stateKey}.always`, transition);
+        }
+      }
+    }
+  }
+}
+function createFSM(config) {
+  const machine = {
+    id: config.id ?? '(fsm)',
+    sources: emptySources
+  };
+  assertNoStringTransitions(config);
+  const runActions = (snapshot, event, actorScope, actionsConfig, internalQueue) => {
+    if (!actionsConfig) {
+      return [snapshot, emptyExecutableActions];
+    }
+    const effects = [];
+    const enqueue = createFSMEnqueue(actorScope, effects, internalQueue);
+    let context = snapshot.context;
+    for (const action of toArray(actionsConfig)) {
+      const result = action(createActor.withActorScope({
+        context,
+        event: event,
+        input: snapshot._stateInput,
+        value: snapshot.value,
+        children: snapshot.children
+      }, actorScope), enqueue);
+      if (result?.context) {
+        context = mergeContextPatch(context, result.context);
+      }
+    }
+    return resolveFSMEffects(context === snapshot.context ? snapshot : cloneSnapshot(snapshot, snapshot.value, context, snapshot._stateInput), effects, actorScope);
+  };
+  const runStateActions = (snapshot, event, actorScope, actionsConfig, stateInput, internalQueue) => {
+    if (!actionsConfig) {
+      return [snapshot, emptyExecutableActions];
+    }
+    const actions = [];
+    const enq = createFSMEnqueue(actorScope, actions, internalQueue);
+    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(createActor.withActorScope({
+        context: context ?? snapshot.context,
+        event: event,
+        input: stateInput,
+        value: snapshot.value,
+        children: snapshot.children
+      }, actorScope), enq);
+      if (result?.context !== undefined) {
+        const currentContext = context ?? snapshot.context;
+        const nextContext = mergeContextPatch(currentContext, result.context);
+        if (nextContext !== currentContext) {
+          context = nextContext;
+        }
+      }
+    }
+    const nextSnapshot = context !== undefined ? cloneSnapshot(snapshot, snapshot.value, context, snapshot._stateInput) : snapshot;
+    return resolveFSMEffects(nextSnapshot, actions, actorScope);
+  };
+  const selectTransition = (snapshot, event, actorScope, internalQueue) => {
+    const state = config.states[snapshot.value];
+    const transitionsConfig = event.type === '' ? state?.always : 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 = createActor.withActorScope({
+        context: snapshot.context,
+        event,
+        input: snapshot.input,
+        value: snapshot.value,
+        children: snapshot.children
+      }, actorScope);
+      if (typeof transition === 'function') {
+        const actions = [];
+        const enq = createFSMEnqueue(actorScope, actions, internalQueue);
+        const result = transition(args, enq);
+        if (!result) {
+          if (actions.length) {
+            return {
+              effects: actions
+            };
+          }
+          continue;
+        }
+        return {
+          target: result.target,
+          context: result.context,
+          input: result.input,
+          effects: 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) : emptyFSMActions
+      };
+    }
+    return undefined;
+  };
+  const transitionCore = (snapshot, event, actorScope) => {
+    if (snapshot.status !== 'active') {
+      return [snapshot, []];
+    }
+    if (event.type === createActor.XSTATE_STOP) {
+      const [cleaned, cleanupEffects] = cleanupFSM(snapshot, actorScope);
+      return [stopSnapshot(cleaned), cleanupEffects];
+    }
+    if (event.type === createActor.XSTATE_TIMER) {
+      const timer = snapshot.timers[event.id];
+      if (!timer) {
+        return [snapshot, emptyExecutableActions];
+      }
+      const timers = {
+        ...snapshot.timers
+      };
+      delete timers[timer.id];
+      const nextSnapshot = {
+        ...snapshot,
+        timers
+      };
+      if (timer.type === '@xstate.raise') {
+        return transitionCore(nextSnapshot, timer.event, actorScope);
+      }
+      const target = timer.target === 'self' ? actorScope.self : timer.target;
+      return [nextSnapshot, [createFSMSendEffect(actorScope, target, timer.event)]];
+    }
+    const stateConfig = config.states[snapshot.value];
+    const directTransition = event.type === '' ? stateConfig?.always : 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 targetState = config.states[target];
+      const stateChanged = target !== snapshot.value;
+      if (targetState?.always || stateChanged && (stateConfig.exit || targetState?.entry || targetState?.type === 'final')) ; else {
+        const hasContext = directTransition.context !== undefined;
+        const hasInput = directTransition.input !== undefined;
+        const resolvedContext = !createActor.isLazyActorScope(actorScope) ? resolveTransitionContext(directTransition.context, {
+          context: snapshot.context,
+          event,
+          input: snapshot.input,
+          value: snapshot.value,
+          self: actorScope.self,
+          system: actorScope.system,
+          parent: actorScope.self._parent,
+          children: snapshot.children
+        }) : typeof directTransition.context === 'function' ? directTransition.context(createActor.withActorScope({
+          context: snapshot.context,
+          event,
+          input: snapshot.input,
+          value: snapshot.value,
+          children: snapshot.children
+        }, actorScope)) : directTransition.context;
+        const context = hasContext && resolvedContext ? mergeContextPatch(snapshot.context, resolvedContext) : snapshot.context;
+        if (!stateChanged && context === snapshot.context && !hasInput && snapshot._stateInput === undefined) {
+          return [snapshot, emptyExecutableActions];
+        }
+        return [cloneSnapshot(snapshot, target, context, hasInput ? resolveInput(directTransition.input, context, event) : undefined), emptyExecutableActions];
+      }
+    }
+    let selectedTransition;
+    if (typeof directTransition === 'function' && directTransition.length < 2 && !stateConfig?.exit) {
+      const result = directTransition(createActor.withActorScope({
+        context: snapshot.context,
+        event,
+        input: snapshot.input,
+        value: snapshot.value,
+        children: snapshot.children
+      }, actorScope), undefined);
+      if (!result) {
+        return [snapshot, emptyExecutableActions];
+      }
+      const target = result.target ?? snapshot.value;
+      const targetState = config.states[target];
+      if (!targetState?.entry && !targetState?.always && targetState?.type !== 'final') {
+        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];
+      }
+      selectedTransition = {
+        target: result.target,
+        context: result.context,
+        input: result.input,
+        actions: emptyFSMActions
+      };
+    }
+    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 = selectedTransition ?? selectTransition(nextSnapshot, nextEvent, actorScope, internalQueue);
+      selectedTransition = undefined;
+      if (!selected) {
+        continue;
+      }
+      const nextValue = selected.target ?? nextSnapshot.value;
+      const nextState = config.states[nextValue];
+      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 transitionResult = selected.effects ? resolveFSMEffects(nextSnapshot, selected.effects, actorScope) : runActions(nextSnapshot, nextEvent, actorScope, selected.actions, internalQueue);
+      const [afterTransition, transitionActions] = transitionResult;
+      nextSnapshot = afterTransition;
+      executableActions.push(...transitionActions);
+      if (stateChanged) {
+        const [entered, entryActions] = runStateActions(nextSnapshot, nextEvent, actorScope, nextState?.entry, stateInput, internalQueue);
+        nextSnapshot = entered;
+        executableActions.push(...entryActions);
+      }
+      if (nextState?.type === 'final') {
+        const [completed, completionEffects] = completeFinalState(nextSnapshot, nextEvent, actorScope, internalQueue, config.states, runStateActions);
+        nextSnapshot = completed;
+        executableActions.push(...completionEffects);
+        break;
+      }
+      if (nextState?.always) {
+        internalQueue.unshift({
+          type: ''
+        });
+      }
+    }
+    return [nextSnapshot, executableActions];
+  };
+  const transition = (...args) => {
+    beginFSMEffects(args[2], args[0]);
+    const [nextSnapshot, effects] = transitionCore(...args);
+    return finalizeFSMEffects(args[2], args[0], [nextSnapshot, appendFSMStarts(effects)]);
+  };
+  const logic = {
+    id: config.id,
+    config,
+    transition,
+    initialTransition: (input, actorScope) => {
+      const initialState = config.states[config.initial];
+      const context = resolveContext(config.context, input);
+      const snapshot = createSnapshot(config.initial, context, input, machine);
+      beginFSMEffects(actorScope, snapshot);
+      const internalQueue = [];
+      let [nextSnapshot, actions] = runStateActions(snapshot, {
+        type: createActor.XSTATE_INIT
+      }, actorScope, initialState?.entry, undefined, internalQueue);
+      if (!actions.length) {
+        actions = [];
+      }
+      if (initialState?.type === 'final') {
+        const [completed, completionEffects] = completeFinalState(nextSnapshot, {
+          type: createActor.XSTATE_INIT
+        }, actorScope, internalQueue, config.states, runStateActions);
+        nextSnapshot = completed;
+        actions.push(...completionEffects);
+      } else {
+        if (initialState?.always) {
+          internalQueue.unshift({
+            type: ''
+          });
+        }
+        while (internalQueue.length) {
+          const [raisedSnapshot, raisedActions] = transitionCore(nextSnapshot, internalQueue.shift(), actorScope);
+          nextSnapshot = raisedSnapshot;
+          actions.push(...raisedActions);
+        }
+      }
+      return finalizeFSMEffects(actorScope, undefined, [nextSnapshot, appendFSMStarts(actions)]);
+    },
+    getInitialSnapshot: (actorScope, input) => logic.initialTransition(input, actorScope)[0],
+    getPersistedSnapshot: currentSnapshot => {
+      const {
+        machine: _,
+        children,
+        ...snapshot
+      } = currentSnapshot;
+      assertPersistableFSM(children, snapshot.timers);
+      return {
+        ...snapshot,
+        children: {}
+      };
+    },
+    restoreSnapshot: snapshot => {
+      const persisted = snapshot;
+      const children = persisted.children ?? {};
+      const timers = persisted.timers ?? {};
+      assertPersistableFSM(children, timers);
+      const restored = {
+        ...persisted,
+        children: {},
+        timers,
+        machine: machine
+      };
+      return restored;
+    }
+  };
+  return logic;
+}
+
+exports.createFSM = createFSM;