xstate 6.0.0-alpha.2 → 6.0.0-alpha.3

package/dist/{index-f6ef20d1.development.cjs.js → index-269d256d.development.cjs.js}

@@ -1,18 +1,5 @@
 'use strict';
 
-/**
- * Reactivity interop between actors and atoms.
- *
- * `Actor#get()` calls this hook (when installed) so that computed atoms can
- * track actor reads as dependencies. The hook is installed by `atom.ts` on
- * module evaluation, which only happens when atoms are actually used — apps
- * that never import atoms don't bundle the reactive system.
- */
-let onActorRead;
-function installActorReadHook(hook) {
-  onActorRead = hook;
-}
-
 class Mailbox {
   constructor(_process) {
     this._process = _process;
@@ -205,10 +192,9 @@ function createAttachedLogic(attach) {
       self,
       system
     }) => {
-      // Don't attach if the target doesn't exist, or (for actors) is stopped.
-      // Atoms have no `getSnapshot` / lifecycle, so they always attach.
+      // Don't attach if the target doesn't exist or is stopped.
       const target = state.input.actor;
-      if (!target || typeof target.getSnapshot === 'function' && target.getSnapshot().status === 'stopped') {
+      if (!target || target.getSnapshot().status === 'stopped') {
         return;
       }
       const subscription = attach(state.input, {
@@ -310,620 +296,6 @@ function createListenerLogic() {
 // Singleton logic instance
 const listenerLogic = /* #__PURE__ */createListenerLogic();
 
-/* eslint-disable */
-// Adapted from Alien Signals
-// https://github.com/stackblitz/alien-signals/
-
-let ReactiveFlags = /*#__PURE__*/function (ReactiveFlags) {
-  ReactiveFlags[ReactiveFlags["None"] = 0] = "None";
-  ReactiveFlags[ReactiveFlags["Mutable"] = 1] = "Mutable";
-  ReactiveFlags[ReactiveFlags["Watching"] = 2] = "Watching";
-  ReactiveFlags[ReactiveFlags["RecursedCheck"] = 4] = "RecursedCheck";
-  ReactiveFlags[ReactiveFlags["Recursed"] = 8] = "Recursed";
-  ReactiveFlags[ReactiveFlags["Dirty"] = 16] = "Dirty";
-  ReactiveFlags[ReactiveFlags["Pending"] = 32] = "Pending";
-  return ReactiveFlags;
-}({});
-function createReactiveSystem({
-  update,
-  notify,
-  unwatched
-}) {
-  return {
-    link,
-    unlink,
-    propagate,
-    checkDirty,
-    shallowPropagate
-  };
-  function link(dep, sub, version) {
-    const prevDep = sub.depsTail;
-    if (prevDep !== undefined && prevDep.dep === dep) {
-      return;
-    }
-    const nextDep = prevDep !== undefined ? prevDep.nextDep : sub.deps;
-    if (nextDep !== undefined && nextDep.dep === dep) {
-      nextDep.version = version;
-      sub.depsTail = nextDep;
-      return;
-    }
-    const prevSub = dep.subsTail;
-    if (prevSub !== undefined && prevSub.version === version && prevSub.sub === sub) {
-      return;
-    }
-    const newLink = sub.depsTail = dep.subsTail = {
-      version,
-      dep,
-      sub,
-      prevDep,
-      nextDep,
-      prevSub,
-      nextSub: undefined
-    };
-    if (nextDep !== undefined) {
-      nextDep.prevDep = newLink;
-    }
-    if (prevDep !== undefined) {
-      prevDep.nextDep = newLink;
-    } else {
-      sub.deps = newLink;
-    }
-    if (prevSub !== undefined) {
-      prevSub.nextSub = newLink;
-    } else {
-      dep.subs = newLink;
-    }
-  }
-  function unlink(link, sub = link.sub) {
-    const dep = link.dep;
-    const prevDep = link.prevDep;
-    const nextDep = link.nextDep;
-    const nextSub = link.nextSub;
-    const prevSub = link.prevSub;
-    if (nextDep !== undefined) {
-      nextDep.prevDep = prevDep;
-    } else {
-      sub.depsTail = prevDep;
-    }
-    if (prevDep !== undefined) {
-      prevDep.nextDep = nextDep;
-    } else {
-      sub.deps = nextDep;
-    }
-    if (nextSub !== undefined) {
-      nextSub.prevSub = prevSub;
-    } else {
-      dep.subsTail = prevSub;
-    }
-    if (prevSub !== undefined) {
-      prevSub.nextSub = nextSub;
-    } else if ((dep.subs = nextSub) === undefined) {
-      unwatched(dep);
-    }
-    return nextDep;
-  }
-  function propagate(link) {
-    let next = link.nextSub;
-    let stack;
-    top: do {
-      const sub = link.sub;
-      let flags = sub.flags;
-      if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed | ReactiveFlags.Dirty | ReactiveFlags.Pending))) {
-        sub.flags = flags | ReactiveFlags.Pending;
-      } else if (!(flags & (ReactiveFlags.RecursedCheck | ReactiveFlags.Recursed))) {
-        flags = ReactiveFlags.None;
-      } else if (!(flags & ReactiveFlags.RecursedCheck)) {
-        sub.flags = flags & ~ReactiveFlags.Recursed | ReactiveFlags.Pending;
-      } else if (!(flags & (ReactiveFlags.Dirty | ReactiveFlags.Pending)) && isValidLink(link, sub)) {
-        sub.flags = flags | (ReactiveFlags.Recursed | ReactiveFlags.Pending);
-        flags &= ReactiveFlags.Mutable;
-      } else {
-        flags = ReactiveFlags.None;
-      }
-      if (flags & ReactiveFlags.Watching) {
-        notify(sub);
-      }
-      if (flags & ReactiveFlags.Mutable) {
-        const subSubs = sub.subs;
-        if (subSubs !== undefined) {
-          const nextSub = (link = subSubs).nextSub;
-          if (nextSub !== undefined) {
-            stack = {
-              value: next,
-              prev: stack
-            };
-            next = nextSub;
-          }
-          continue;
-        }
-      }
-      if ((link = next) !== undefined) {
-        next = link.nextSub;
-        continue;
-      }
-      while (stack !== undefined) {
-        link = stack.value;
-        stack = stack.prev;
-        if (link !== undefined) {
-          next = link.nextSub;
-          continue top;
-        }
-      }
-      break;
-    } while (true);
-  }
-  function checkDirty(link, sub) {
-    let stack;
-    let checkDepth = 0;
-    let dirty = false;
-    top: do {
-      const dep = link.dep;
-      const flags = dep.flags;
-      if (sub.flags & ReactiveFlags.Dirty) {
-        dirty = true;
-      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) === (ReactiveFlags.Mutable | ReactiveFlags.Dirty)) {
-        if (update(dep)) {
-          const subs = dep.subs;
-          if (subs.nextSub !== undefined) {
-            shallowPropagate(subs);
-          }
-          dirty = true;
-        }
-      } else if ((flags & (ReactiveFlags.Mutable | ReactiveFlags.Pending)) === (ReactiveFlags.Mutable | ReactiveFlags.Pending)) {
-        if (link.nextSub !== undefined || link.prevSub !== undefined) {
-          stack = {
-            value: link,
-            prev: stack
-          };
-        }
-        link = dep.deps;
-        sub = dep;
-        ++checkDepth;
-        continue;
-      }
-      if (!dirty) {
-        const nextDep = link.nextDep;
-        if (nextDep !== undefined) {
-          link = nextDep;
-          continue;
-        }
-      }
-      while (checkDepth--) {
-        const firstSub = sub.subs;
-        const hasMultipleSubs = firstSub.nextSub !== undefined;
-        if (hasMultipleSubs) {
-          link = stack.value;
-          stack = stack.prev;
-        } else {
-          link = firstSub;
-        }
-        if (dirty) {
-          if (update(sub)) {
-            if (hasMultipleSubs) {
-              shallowPropagate(firstSub);
-            }
-            sub = link.sub;
-            continue;
-          }
-          dirty = false;
-        } else {
-          sub.flags &= ~ReactiveFlags.Pending;
-        }
-        sub = link.sub;
-        const nextDep = link.nextDep;
-        if (nextDep !== undefined) {
-          link = nextDep;
-          continue top;
-        }
-      }
-      return dirty;
-    } while (true);
-  }
-  function shallowPropagate(link) {
-    do {
-      const sub = link.sub;
-      const flags = sub.flags;
-      if ((flags & (ReactiveFlags.Pending | ReactiveFlags.Dirty)) === ReactiveFlags.Pending) {
-        sub.flags = flags | ReactiveFlags.Dirty;
-        if ((flags & (ReactiveFlags.Watching | ReactiveFlags.RecursedCheck)) === ReactiveFlags.Watching) {
-          notify(sub);
-        }
-      }
-    } while ((link = link.nextSub) !== undefined);
-  }
-  function isValidLink(checkLink, sub) {
-    let link = sub.depsTail;
-    while (link !== undefined) {
-      if (link === checkLink) {
-        return true;
-      }
-      link = link.prevDep;
-    }
-    return false;
-  }
-}
-
-/**
- * Nominal brand (phantom, compile-time only) marking a value as an XState atom.
- * Real atoms get the runtime brand ({@link $$atom}) in `createAtom`; this type
- * brand keeps atom-only APIs (e.g. `enq.subscribeTo`) from structurally
- * accepting plain readables like `actor.select(...)` that would be dispatched
- * down the non-atom path at runtime.
- */
-
-/** Brand marking an object as an atom, so it can be detected structurally. */
-const $$atom = /* #__PURE__ */Symbol.for('xstate.atom');
-
-/**
- * Returns `true` if the value is an atom (writable, computed, async, or
- * reducer). Lets actor-consuming APIs (e.g. `enq.subscribeTo`) accept atoms
- * directly.
- */
-function isAtom(value) {
-  return !!value && typeof value === 'object' && $$atom in value;
-}
-const queuedEffects = [];
-let cycle = 0;
-// Initialized lazily on first atom creation (instead of at module evaluation)
-// so the reactive system stays tree-shakeable for apps that never use atoms —
-
-// would be retained by consumer bundlers even when atoms are unused.
-let link;
-let unlink;
-let propagate;
-let checkDirty;
-let shallowPropagate;
-let reactiveSystemInstalled = false;
-function ensureReactiveSystem() {
-  if (reactiveSystemInstalled) {
-    return;
-  }
-  reactiveSystemInstalled = true;
-  ({
-    link,
-    unlink,
-    propagate,
-    checkDirty,
-    shallowPropagate
-  } = createReactiveSystem({
-    update(atom) {
-      return atom._update();
-    },
-    notify(effect) {
-      queuedEffects[queuedEffectsLength++] = effect;
-      effect.flags &= ~ReactiveFlags.Watching;
-    },
-    unwatched(atom) {
-      if (atom.depsTail !== undefined) {
-        atom.depsTail = undefined;
-        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-        purgeDeps(atom);
-      }
-    }
-  }));
-}
-let notifyIndex = 0;
-let queuedEffectsLength = 0;
-let activeSub;
-function purgeDeps(sub) {
-  const depsTail = sub.depsTail;
-  let dep = depsTail !== undefined ? depsTail.nextDep : sub.deps;
-  while (dep !== undefined) {
-    dep = unlink(dep, sub);
-  }
-}
-function flush() {
-  while (notifyIndex < queuedEffectsLength) {
-    const effect = queuedEffects[notifyIndex];
-    queuedEffects[notifyIndex++] = undefined;
-    effect.notify();
-  }
-  notifyIndex = 0;
-  queuedEffectsLength = 0;
-}
-
-/** The current state of an async atom. */
-
-/** Options passed to an async atom getter. */
-
-function compareAsyncAtomState(a, b) {
-  if (a.status !== b.status) {
-    return false;
-  }
-  if (a.status === 'done' && b.status === 'done') {
-    return Object.is(a.data, b.data);
-  }
-  if (a.status === 'error' && b.status === 'error') {
-    return Object.is(a.error, b.error);
-  }
-  // both 'pending'
-  return true;
-}
-function updateAsyncAtom(atom, nextValue) {
-  if (atom._update(nextValue)) {
-    const subs = atom.subs;
-    if (subs !== undefined) {
-      propagate(subs);
-      shallowPropagate(subs);
-      flush();
-    }
-  }
-}
-
-/**
- * Creates a read-only atom whose value is loaded from an async getter.
- *
- * The getter receives an `AbortSignal`; when the async atom recomputes, the
- * previous signal is aborted and stale resolutions are ignored.
- */
-function createAsyncAtom(getValue, options) {
-  const ref = {};
-  let currentController;
-  let currentRunId = 0;
-  const atom = createAtom(() => {
-    currentController?.abort();
-    const controller = new AbortController();
-    const runId = ++currentRunId;
-    currentController = controller;
-    getValue({
-      signal: controller.signal
-    }).then(data => {
-      if (runId !== currentRunId || controller.signal.aborted) {
-        return;
-      }
-      updateAsyncAtom(ref.current, {
-        status: 'done',
-        data
-      });
-    }, error => {
-      if (runId !== currentRunId || controller.signal.aborted) {
-        return;
-      }
-      updateAsyncAtom(ref.current, {
-        status: 'error',
-        error
-      });
-    });
-    return {
-      status: 'pending'
-    };
-  }, {
-    compare: compareAsyncAtomState,
-    ...options
-  });
-  ref.current = atom;
-  return atom;
-}
-
-/**
- * Mirror atoms that bump a version whenever a tracked actor emits a snapshot,
- * letting computed atoms depend on `actor.get()` reads.
- *
- * The hook is installed lazily on first atom creation (not at module
- * evaluation) so that it remains tree-shakeable for apps that never use atoms —
- * any tracked read necessarily happens inside an atom computation, so first-use
- * installation is always early enough.
- */
-let actorInteropInstalled = false;
-function ensureActorInterop() {
-  if (actorInteropInstalled) {
-    return;
-  }
-  actorInteropInstalled = true;
-  const actorVersions = new WeakMap();
-  installActorReadHook(actorRef => {
-    if (activeSub === undefined) {
-      return;
-    }
-    let version = actorVersions.get(actorRef);
-    if (version === undefined) {
-      version = createAtom(0);
-      actorVersions.set(actorRef, version);
-      actorRef.subscribe({
-        next: () => version.set(v => v + 1),
-        error: () => {}
-      });
-    }
-    version.get();
-  });
-}
-
-/**
- * Creates an atom.
- *
- * Pass a value for a writable atom or a getter for a computed read-only atom.
- */
-
-function createAtom(valueOrFn, optionsOrInput) {
-  ensureReactiveSystem();
-  ensureActorInterop();
-  const isComputed = typeof valueOrFn === 'function';
-  const getter = valueOrFn;
-
-  // Create plain object atom
-  const atom = {
-    _snapshot: isComputed ? undefined : valueOrFn,
-    subs: undefined,
-    subsTail: undefined,
-    deps: undefined,
-    depsTail: undefined,
-    flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
-    get() {
-      if (activeSub !== undefined) {
-        link(atom, activeSub, cycle);
-      }
-      return atom._snapshot;
-    },
-    subscribe(observerOrFn) {
-      const observer = typeof observerOrFn === 'function' ? {
-        next: observerOrFn
-      } : observerOrFn;
-      const observed = {
-        current: false
-      };
-      const e = effect(() => {
-        atom.get();
-        if (!observed.current) {
-          observed.current = true;
-        } else {
-          const prevSub = activeSub;
-          activeSub = undefined;
-          try {
-            observer.next?.(atom._snapshot);
-          } catch (err) {
-            reportUnhandledError(err);
-          } finally {
-            activeSub = prevSub;
-          }
-
-          // If the observer synchronously updates any of our deps we'll be
-          // marked as dirty preventing this effect from re-running. Request
-          // the value again to reconcile any dirty deps.
-          atom.get();
-        }
-      });
-      return {
-        unsubscribe: () => {
-          e.stop();
-        }
-      };
-    },
-    _update(getValue) {
-      const prevSub = activeSub;
-      const compare = optionsOrInput?.compare ?? Object.is;
-      activeSub = atom;
-      ++cycle;
-      atom.depsTail = undefined;
-      if (isComputed) {
-        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck;
-      }
-      try {
-        const oldValue = atom._snapshot;
-        const newValue = typeof getValue === 'function' ? getValue(oldValue) : getValue === undefined && isComputed ? getter(oldValue) : getValue;
-        if (oldValue === undefined || !compare(oldValue, newValue)) {
-          atom._snapshot = newValue;
-          return true;
-        }
-        return false;
-      } finally {
-        activeSub = prevSub;
-        if (isComputed) {
-          atom.flags &= ~ReactiveFlags.RecursedCheck;
-        }
-        purgeDeps(atom);
-      }
-    }
-  };
-  if (isComputed) {
-    atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty;
-    atom.get = function () {
-      const flags = atom.flags;
-      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(atom.deps, atom)) {
-        if (atom._update()) {
-          const subs = atom.subs;
-          if (subs !== undefined) {
-            shallowPropagate(subs);
-          }
-        }
-      } else if (flags & ReactiveFlags.Pending) {
-        atom.flags = flags & ~ReactiveFlags.Pending;
-      }
-      if (activeSub !== undefined) {
-        link(atom, activeSub, cycle);
-      }
-      return atom._snapshot;
-    };
-  } else {
-    atom.set = function (valueOrFn) {
-      if (atom._update(valueOrFn)) {
-        const subs = atom.subs;
-        if (subs !== undefined) {
-          propagate(subs);
-          shallowPropagate(subs);
-          flush();
-        }
-      }
-    };
-  }
-  atom[$$atom] = true;
-  return atom;
-}
-
-/**
- * Creates an inert atom config that can be instantiated later.
- *
- * Useful for framework hooks that need to create a stable local atom from
- * component input.
- */
-
-function createAtomConfig(initialValueOrFn, options) {
-  return {
-    createAtom(input) {
-      const initialValue = typeof initialValueOrFn === 'function' ? initialValueOrFn(input) : initialValueOrFn;
-      return createAtom(initialValue, options);
-    }
-  };
-}
-
-/** Creates an atom whose updates are handled by a reducer function. */
-function createReducerAtom(initialValue, reducer, options) {
-  const atom = createAtom(initialValue, options);
-  return {
-    [$$atom]: true,
-    get: atom.get.bind(atom),
-    subscribe: atom.subscribe.bind(atom),
-    send(event) {
-      const prevSub = activeSub;
-      activeSub = undefined;
-      let nextState;
-      try {
-        nextState = reducer(atom.get(), event);
-      } finally {
-        activeSub = prevSub;
-      }
-      atom.set(nextState);
-    }
-  };
-}
-function effect(fn) {
-  const run = () => {
-    const prevSub = activeSub;
-    activeSub = effectObj;
-    ++cycle;
-    effectObj.depsTail = undefined;
-    effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck;
-    try {
-      return fn();
-    } finally {
-      activeSub = prevSub;
-      effectObj.flags &= ~ReactiveFlags.RecursedCheck;
-      purgeDeps(effectObj);
-    }
-  };
-  const effectObj = {
-    deps: undefined,
-    depsTail: undefined,
-    subs: undefined,
-    subsTail: undefined,
-    flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
-    notify() {
-      const flags = this.flags;
-      if (flags & ReactiveFlags.Dirty || flags & ReactiveFlags.Pending && checkDirty(this.deps, this)) {
-        run();
-      } else {
-        this.flags = ReactiveFlags.Watching;
-      }
-    },
-    stop() {
-      this.flags = ReactiveFlags.None;
-      this.depsTail = undefined;
-      purgeDeps(this);
-    }
-  };
-  run();
-  return effectObj;
-}
-
 /**
  * Creates actor logic for subscribing to lifecycle events (done/error/snapshot)
  * from another actor. Used internally by `enq.subscribeTo()`.
@@ -941,15 +313,6 @@ function createSubscriptionLogic() {
       error,
       snapshot: onSnapshot
     } = mappers;
-
-    // Atoms emit a raw value (no `status`) and have no done/error lifecycle —
-    // pass the value straight to the `snapshot` mapper.
-    if (isAtom(actor)) {
-      if (!onSnapshot) {
-        return;
-      }
-      return actor.subscribe(value => relayMappedToParent(self, system, () => onSnapshot(value)));
-    }
     return actor.subscribe({
       next: snapshot => {
         if (snapshot.status === 'done' && done) {
@@ -1517,27 +880,13 @@ function formatRouteTransitions(rootStateNode) {
         if ('$unserializable' in routeConfig) {
           throw new Error(`State "${sn.id}" has a route that is not serializable. Re-provide the route function when reviving this machine.`);
         }
-
-        // Object-form route. A `guard` (string or function) on the object is
-        // only produced by the JSON layer (createMachineFromConfig) —
-        // authoring uses the function form above.
-        const userGuard = routeConfig.guard;
+        const {
+          guard: _guard,
+          ...routeOptions
+        } = routeConfig;
         const transition = {
-          ...routeConfig,
-          guard: userGuard ? args => {
-            if (!routeMatches(args)) return false;
-            if (typeof userGuard === 'function') return userGuard(args);
-            if (typeof userGuard === 'string') {
-              const guardImpl = args.guards?.[userGuard];
-              if (!guardImpl) {
-                // A typo'd guard name must fail loudly — silently passing
-                // would allow the route and corrupt machine behavior.
-                throw new Error(`Guard '${userGuard}' is not implemented in machine '${rootStateNode.machine.id}'. Available guards: ${Object.keys(args.guards ?? {}).map(key => `'${key}'`).join(', ') || '(none)'}.` );
-              }
-              return guardImpl(args);
-            }
-            return true;
-          } : routeMatches,
+          ...routeOptions,
+          guard: routeMatches,
           target: `#${routeId}`
         };
         routeTransitions.push(formatTransition(rootStateNode, 'xstate.route', transition));
@@ -2535,24 +1884,7 @@ function evaluateCandidate(candidate, event, snapshot, stateNode, self) {
       delays: stateNode.machine.implementations.delays,
       _snapshot: snapshot
     };
-    const guardConfig = candidate.guard;
-    const guardParams = typeof guardConfig?.params === 'function' ? guardConfig.params({
-      context: snapshot.context,
-      event
-    }) : guardConfig?.params;
-    let guardPassed = true;
-    if (typeof guardConfig === 'function') {
-      guardPassed = guardConfig(guardArgs, guardParams);
-    } else if (typeof guardConfig?.type === 'string') {
-      const guardImpl = stateNode.machine.implementations.guards[guardConfig.type];
-      if (!guardImpl) {
-        // A typo'd guard name must fail loudly — silently passing would
-        // take the guarded transition and corrupt machine behavior.
-        throw new Error(`Guard '${guardConfig.type}' is not implemented in machine '${stateNode.machine.id}'. Available guards: ${Object.keys(stateNode.machine.implementations.guards).map(key => `'${key}'`).join(', ') || '(none)'}.` );
-      }
-      guardPassed = guardImpl(guardArgs, guardParams);
-    }
-    if (!guardPassed) {
+    if (!candidate.guard(guardArgs)) {
       return false;
     }
   }
@@ -3854,7 +3186,7 @@ class Actor {
           complete: observer.complete
         });
       },
-      get: () => selector(this.get())
+      get: () => selector(this.getSnapshot())
     };
   }
 
@@ -4143,15 +3475,9 @@ class Actor {
    * @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
    */
   getSnapshot() {
-    return this.get();
-  }
-
-  /** Read the actor's current snapshot as an atom value. */
-  get() {
     if (!this._snapshot) {
       throw new Error(`Snapshot can't be read while the actor initializes itself`);
     }
-    onActorRead?.(this);
     return this._snapshot;
   }
 }
@@ -4956,10 +4282,7 @@ exports.TimeoutError = TimeoutError;
 exports.XSTATE_INIT = XSTATE_INIT;
 exports.checkStateIn = checkStateIn;
 exports.createActor = createActor;
-exports.createAsyncAtom = createAsyncAtom;
 exports.createAsyncLogic = createAsyncLogic;
-exports.createAtom = createAtom;
-exports.createAtomConfig = createAtomConfig;
 exports.createCallbackLogic = createCallbackLogic;
 exports.createEmptyActor = createEmptyActor;
 exports.createEventObservableLogic = createEventObservableLogic;
@@ -4970,7 +4293,6 @@ exports.createListenerLogic = createListenerLogic;
 exports.createLogic = createLogic;
 exports.createMachineSnapshot = createMachineSnapshot;
 exports.createObservableLogic = createObservableLogic;
-exports.createReducerAtom = createReducerAtom;
 exports.createSubscriptionLogic = createSubscriptionLogic;
 exports.evaluateCandidate = evaluateCandidate;
 exports.formatRouteTransitions = formatRouteTransitions;
@@ -4984,7 +4306,6 @@ exports.getProperAncestors = getProperAncestors;
 exports.getStateNodeByPath = getStateNodeByPath;
 exports.getStateNodes = getStateNodes;
 exports.initialMicrostep = initialMicrostep;
-exports.isAtom = isAtom;
 exports.isAtomicStateNode = isAtomicStateNode;
 exports.isInFinalState = isInFinalState;
 exports.isMachineSnapshot = isMachineSnapshot;