xstate 6.0.0-alpha.9 → 6.0.0-beta.0

package/dist/xstate-graph.cjs.js

@@ -2,384 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dist_xstateActors = require('./index-559ceab3.cjs.js');
-var StateMachine = require('./StateMachine-aef700df.cjs.js');
-
-function simpleStringify(value) {
-  return JSON.stringify(value);
-}
-function formatPathTestResult(path, testPathResult, options) {
-  const resolvedOptions = {
-    formatColor: (_color, string) => string,
-    serializeState: simpleStringify,
-    serializeEvent: simpleStringify,
-    ...options
-  };
-  const {
-    formatColor,
-    serializeState,
-    serializeEvent
-  } = resolvedOptions;
-  const {
-    state
-  } = path;
-  const targetStateString = serializeState(state, path.steps.length ? path.steps[path.steps.length - 1].event : undefined);
-  let errMessage = '';
-  let hasFailed = false;
-  errMessage += '\nPath:\n' + testPathResult.steps.map((s, i, steps) => {
-    const stateString = serializeState(s.step.state, i > 0 ? steps[i - 1].step.event : undefined);
-    const eventString = serializeEvent(s.step.event);
-    const stateResult = `\tState: ${hasFailed ? formatColor('gray', stateString) : s.state.error ? (hasFailed = true, formatColor('redBright', stateString)) : formatColor('greenBright', stateString)}`;
-    const eventResult = `\tEvent: ${hasFailed ? formatColor('gray', eventString) : s.event.error ? (hasFailed = true, formatColor('red', eventString)) : formatColor('green', eventString)}`;
-    return [stateResult, eventResult].join('\n');
-  }).concat(`\tState: ${hasFailed ? formatColor('gray', targetStateString) : testPathResult.state.error ? formatColor('red', targetStateString) : formatColor('green', targetStateString)}`).join('\n\n');
-  return errMessage;
-}
-function getDescription(snapshot) {
-  const contextString = !Object.keys(snapshot.context).length ? '' : `(${JSON.stringify(snapshot.context)})`;
-  const stateStrings = snapshot._nodes.filter(sn => sn.type === 'atomic' || sn.type === 'final').map(({
-    id,
-    path
-  }) => {
-    const meta = snapshot.getMeta()[id];
-    if (!meta) {
-      return `"${path.join('.')}"`;
-    }
-    const {
-      description
-    } = meta;
-    if (typeof description === 'function') {
-      return description(snapshot);
-    }
-    return description ? `"${description}"` : JSON.stringify(snapshot.value);
-  });
-  return `state${stateStrings.length === 1 ? '' : 's'} ` + stateStrings.join(', ') + ` ${contextString}`.trim();
-}
-
-/**
- * Deduplicates your paths so that A -> B is not executed separately to A -> B
- * -> C
- */
-const deduplicatePaths = (paths, serializeEvent = simpleStringify) => {
-  /** Put all paths on the same level so we can dedup them */
-  const allPathsWithEventSequence = [];
-  paths.forEach(path => {
-    allPathsWithEventSequence.push({
-      path,
-      eventSequence: path.steps.map(step => serializeEvent(step.event))
-    });
-  });
-
-  // Sort by path length, descending
-  allPathsWithEventSequence.sort((a, z) => z.path.steps.length - a.path.steps.length);
-  const superpathsWithEventSequence = [];
-
-  /** Filter out the paths that are subpaths of superpaths */
-  pathLoop: for (const pathWithEventSequence of allPathsWithEventSequence) {
-    // Check each existing superpath to see if the path is a subpath of it
-    superpathLoop: for (const superpathWithEventSequence of superpathsWithEventSequence) {
-      // eslint-disable-next-line @typescript-eslint/no-for-in-array
-      for (const i in pathWithEventSequence.eventSequence) {
-        // Check event sequence to determine if path is subpath, e.g.:
-        //
-        // This will short-circuit the check
-        // ['a', 'b', 'c', 'd'] (superpath)
-        // ['a', 'b', 'x']      (path)
-        //
-        // This will not short-circuit; path is subpath
-        // ['a', 'b', 'c', 'd'] (superpath)
-        // ['a', 'b', 'c']      (path)
-        if (pathWithEventSequence.eventSequence[i] !== superpathWithEventSequence.eventSequence[i]) {
-          // If the path is different from the superpath,
-          // continue to the next superpath
-          continue superpathLoop;
-        }
-      }
-
-      // If we reached here, path is subpath of superpath
-      // Continue & do not add path to superpaths
-      continue pathLoop;
-    }
-
-    // If we reached here, path is not a subpath of any existing superpaths
-    // So add it to the superpaths
-    superpathsWithEventSequence.push(pathWithEventSequence);
-  }
-  return superpathsWithEventSequence.map(path => path.path);
-};
-
-const createShortestPathsGen = () => (logic, defaultOptions) => {
-  const paths = getShortestPaths(logic, defaultOptions);
-  return paths;
-};
-const createSimplePathsGen = () => (logic, defaultOptions) => {
-  const paths = getSimplePaths(logic, defaultOptions);
-  return paths;
-};
-
-const validateState = _state => {
-  // TODO
-};
-const validateMachine = machine => {
-  validateState(machine.root);
-};
-
-/**
- * Creates a test model that represents an abstract model of a system under test
- * (SUT).
- *
- * The test model is used to generate test paths, which are used to verify that
- * states in the model are reachable in the SUT.
- */
-class TestModel {
-  getDefaultOptions() {
-    return {
-      serializeState: state => simpleStringify(state),
-      serializeEvent: event => simpleStringify(event),
-      // For non-state-machine test models, we cannot identify
-      // separate transitions, so just use event type
-      serializeTransition: (state, event) => `${simpleStringify(state)}|${event?.type}`,
-      events: [],
-      stateMatcher: (_, stateKey) => stateKey === '*',
-      logger: {
-        log: console.log.bind(console),
-        error: console.error.bind(console)
-      }
-    };
-  }
-  constructor(testLogic, options) {
-    this.testLogic = testLogic;
-    this.options = void 0;
-    this.defaultTraversalOptions = void 0;
-    this._toTestPath = statePath => {
-      function formatEvent(event) {
-        const {
-          type,
-          ...other
-        } = event;
-        const propertyString = Object.keys(other).length ? ` (${JSON.stringify(other)})` : '';
-        return `${type}${propertyString}`;
-      }
-      const eventsString = statePath.steps.map(s => formatEvent(s.event)).join(' → ');
-      return {
-        ...statePath,
-        test: params => this.testPath(statePath, params),
-        description: dist_xstateActors.isMachineSnapshot(statePath.state) ? `Reaches ${getDescription(statePath.state).trim()}: ${eventsString}` : JSON.stringify(statePath.state)
-      };
-    };
-    this.options = {
-      ...this.getDefaultOptions(),
-      ...options
-    };
-  }
-  getPaths(pathGenerator, options) {
-    const allowDuplicatePaths = options?.allowDuplicatePaths ?? false;
-    const paths = pathGenerator(this.testLogic, this._resolveOptions(options));
-    return (allowDuplicatePaths ? paths : deduplicatePaths(paths)).map(this._toTestPath);
-  }
-  getShortestPaths(options) {
-    return this.getPaths(createShortestPathsGen(), options);
-  }
-  getShortestPathsFrom(paths, options) {
-    const resultPaths = [];
-    for (const path of paths) {
-      const shortestPaths = this.getShortestPaths({
-        ...options,
-        fromState: path.state
-      });
-      for (const shortestPath of shortestPaths) {
-        resultPaths.push(this._toTestPath(joinPaths(path, shortestPath)));
-      }
-    }
-    return resultPaths;
-  }
-  getSimplePaths(options) {
-    return this.getPaths(createSimplePathsGen(), options);
-  }
-  getSimplePathsFrom(paths, options) {
-    const resultPaths = [];
-    for (const path of paths) {
-      const shortestPaths = this.getSimplePaths({
-        ...options,
-        fromState: path.state
-      });
-      for (const shortestPath of shortestPaths) {
-        resultPaths.push(this._toTestPath(joinPaths(path, shortestPath)));
-      }
-    }
-    return resultPaths;
-  }
-  getPathsFromEvents(events, options) {
-    const paths = getPathsFromEvents(this.testLogic, events, options);
-    return paths.map(this._toTestPath);
-  }
-
-  /**
-   * An array of adjacencies, which are objects that represent each `state` with
-   * the `nextState` given the `event`.
-   */
-  getAdjacencyMap() {
-    const adjMap = getAdjacencyMap(this.testLogic, this.options);
-    return adjMap;
-  }
-  async testPath(path, params, options) {
-    const testPathResult = {
-      steps: [],
-      state: {
-        error: null
-      }
-    };
-    try {
-      for (const step of path.steps) {
-        const testStepResult = {
-          step,
-          state: {
-            error: null
-          },
-          event: {
-            error: null
-          }
-        };
-        testPathResult.steps.push(testStepResult);
-        try {
-          await this.testTransition(params, step);
-        } catch (err) {
-          testStepResult.event.error = err;
-          throw err;
-        }
-        try {
-          await this.testState(params, step.state, options);
-        } catch (err) {
-          testStepResult.state.error = err;
-          throw err;
-        }
-      }
-    } catch (err) {
-      // TODO: make option
-      err.message += formatPathTestResult(path, testPathResult, this.options);
-      throw err;
-    }
-    return testPathResult;
-  }
-  async testState(params, state, options) {
-    const resolvedOptions = this._resolveOptions(options);
-    const stateTestKeys = this._getStateTestKeys(params, state, resolvedOptions);
-    for (const stateTestKey of stateTestKeys) {
-      await params.states?.[stateTestKey](state);
-    }
-  }
-  _getStateTestKeys(params, state, resolvedOptions) {
-    const states = params.states || {};
-    const stateTestKeys = Object.keys(states).filter(stateKey => {
-      return resolvedOptions.stateMatcher(state, stateKey);
-    });
-
-    // Fallthrough state tests
-    if (!stateTestKeys.length && '*' in states) {
-      stateTestKeys.push('*');
-    }
-    return stateTestKeys;
-  }
-  _getEventExec(params, step) {
-    const eventExec = params.events?.[step.event.type];
-    return eventExec;
-  }
-  async testTransition(params, step) {
-    const eventExec = this._getEventExec(params, step);
-    await eventExec?.(step);
-  }
-  _resolveOptions(options) {
-    return {
-      ...this.defaultTraversalOptions,
-      ...this.options,
-      ...options
-    };
-  }
-}
-function stateValuesEqual(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (a === undefined || b === undefined) {
-    return false;
-  }
-  if (typeof a === 'string' || typeof b === 'string') {
-    return a === b;
-  }
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  return aKeys.length === bKeys.length && aKeys.every(key => stateValuesEqual(a[key], b[key]));
-}
-function serializeMachineTransition(snapshot, event, previousSnapshot, {
-  serializeEvent
-}) {
-  // TODO: the stateValuesEqual check here is very likely not exactly correct
-  // but I'm not sure what the correct check is and what this is trying to do
-  if (!event || previousSnapshot && stateValuesEqual(previousSnapshot.value, snapshot.value)) {
-    return '';
-  }
-  const prevStateString = previousSnapshot ? ` from ${simpleStringify(previousSnapshot.value)}` : '';
-  return ` via ${serializeEvent(event)}${prevStateString}`;
-}
-
-/**
- * Creates a test model that represents an abstract model of a system under test
- * (SUT).
- *
- * The test model is used to generate test paths, which are used to verify that
- * states in the `machine` are reachable in the SUT.
- *
- * @example
- *
- * ```js
- * const toggleModel = createModel(toggleMachine).withEvents({
- *   TOGGLE: {
- *     exec: async (page) => {
- *       await page.click('input');
- *     }
- *   }
- * });
- * ```
- *
- * @param machine The state machine used to represent the abstract model.
- * @param options Options for the created test model:
- *
- *   - `events`: an object mapping string event types (e.g., `SUBMIT`) to an event
- *       test config (e.g., `{exec: () => {...}, cases: [...]}`)
- */
-function createTestModel(machine, options) {
-  validateMachine(machine);
-  const serializeEvent = options?.serializeEvent ?? simpleStringify;
-  const serializeTransition = options?.serializeTransition ?? serializeMachineTransition;
-  const {
-    events: getEvents,
-    ...otherOptions
-  } = options ?? {};
-  const testModel = new TestModel(machine, {
-    serializeState: (state, event, prevState) => {
-      // Only consider the `state` if `serializeTransition()` is opted out (empty string)
-      return `${serializeSnapshot(state)}${serializeTransition(state, event, prevState, {
-        serializeEvent
-      })}`;
-    },
-    stateMatcher: (state, key) => {
-      return key.startsWith('#') ? state._nodes.includes(machine.getStateNodeById(key)) : state.matches(key);
-    },
-    events: state => {
-      const events = typeof getEvents === 'function' ? getEvents(state) : getEvents ?? [];
-      return dist_xstateActors.getAllOwnEventDescriptors(state).flatMap(eventType => {
-        if (events.some(e => e.type === eventType)) {
-          return events.filter(e => e.type === eventType);
-        }
-        return [{
-          type: eventType
-        }]; // TODO: fix types
-      });
-    },
-    ...otherOptions
-  });
-  return testModel;
-}
+var dist_xstateActors = require('./xstate-actors.cjs.js');
+var createActor = require('./createActor-25900f76.cjs.js');
+require('./validation-4561b43c.cjs.js');
 
 function createMockActorScope() {
   const emptyActor = dist_xstateActors.createEmptyActor();
@@ -400,15 +25,17 @@ function createMockActorScope() {
 /**
  * Returns all state nodes of the given `node`.
  *
+ * @public
  * @param stateNode State node to recursively get child state nodes from
+ * @public
  */
-function getStateNodes(stateNode) {
+function getDescendantStateNodes(stateNode) {
   const {
     states
   } = stateNode;
   const nodes = Object.keys(states).reduce((accNodes, stateKey) => {
     const childStateNode = states[stateKey];
-    const childStateNodes = getStateNodes(childStateNode);
+    const childStateNodes = getDescendantStateNodes(childStateNode);
     accNodes.push(childStateNode, ...childStateNodes);
     return accNodes;
   }, []);
@@ -423,55 +50,87 @@ function getChildren(stateNode) {
   });
   return children;
 }
+
+/** @public */
 function serializeSnapshot(snapshot) {
   const {
     value,
     context
   } = snapshot;
+  const machineSnapshot = createActor.isMachineSnapshot(snapshot) ? snapshot : undefined;
+  const inputs = machineSnapshot?.getInputs();
+  const history = machineSnapshot?.historyValue;
   return JSON.stringify({
     value,
-    context: Object.keys(context ?? {}).length ? context : undefined
+    context: Object.keys(context ?? {}).length ? context : undefined,
+    // Equal values and root contexts can still make different decisions when
+    // their state inputs or remembered history differ. Empty records remain
+    // omitted to preserve the keys of machines that do not use these features.
+    stateInputs: inputs && Object.keys(inputs).length ? inputs : undefined,
+    historyValue: history && Object.keys(history).length ? Object.fromEntries(Object.entries(history).map(([id, nodes]) => [id, nodes.map(node => node.id)])) : undefined
   });
 }
 function serializeEvent(event) {
   return JSON.stringify(event);
 }
+function resolveEventCases(cases, state, defaults) {
+  const events = [];
+  const sources = cases;
+  const entries = Object.entries(sources).filter(([, source]) => source !== undefined);
+  const applicable = type => !defaults || defaults.some(event => createActor.matchesEventDescriptor(type, event.type));
+  for (const [type, source] of entries) {
+    if (!applicable(type)) {
+      continue;
+    }
+    const samples = typeof source === 'function' ? source(state) : source;
+    if (!Array.isArray(samples) || !samples.length) {
+      throw new Error(`Event cases for "${type}" must be a non-empty array`);
+    }
+    for (const payload of samples) {
+      const event = {
+        ...payload,
+        type
+      };
+      if (!defaults || defaults.some(({
+        type: descriptor,
+        ...pattern
+      }) => createActor.matchesEventDescriptor(type, descriptor) && createActor.matchesEvent(event, pattern))) {
+        events.push(event);
+      }
+    }
+  }
+  return [...events, ...(defaults?.filter(event => !entries.some(([type]) => type === event.type)) ?? [])];
+}
 function createDefaultMachineOptions(machine, options) {
-  const {
-    events: getEvents,
-    ...otherOptions
-  } = options ?? {};
   const traversalOptions = {
     serializeState: serializeSnapshot,
     serializeEvent,
-    events: state => {
-      const events = typeof getEvents === 'function' ? getEvents(state) : getEvents ?? [];
-      return dist_xstateActors.getAllOwnEventDescriptors(state).flatMap(type => {
-        const matchingEvents = events.filter(ev => ev.type === type);
-        if (matchingEvents.length) {
-          return matchingEvents;
-        }
-        return [{
-          type
-        }];
-      });
-    },
-    fromState: machine.getInitialSnapshot(createMockActorScope(), options?.input),
-    ...otherOptions
+    ...options,
+    events: state => createActor.getAllOwnEvents(state),
+    fromState: options?.fromState ?? machine.getInitialSnapshot(createMockActorScope(), options?.input)
   };
   return traversalOptions;
 }
-function createDefaultLogicOptions() {
-  return {
-    serializeState: state => JSON.stringify(state),
-    serializeEvent
-  };
-}
+
+/** @public */
 function toDirectedGraph(stateMachine) {
-  const stateNode = stateMachine instanceof StateMachine.StateMachine ? stateMachine.root : stateMachine; // TODO: accept only machines
+  const stateNode = isMachineLogic(stateMachine) ? stateMachine.root : stateMachine; // TODO: accept only machines
 
-  const edges = [...stateNode.transitions.values()].flat().flatMap((t, transitionIndex) => {
-    const targets = t.target ? t.target : [stateNode];
+  const diagnostics = [];
+  const transitions = [...[...stateNode.transitions.values()].flat(), ...(stateNode.always ?? [])];
+  const edges = transitions.flatMap((t, transitionIndex) => {
+    if (t.to) {
+      diagnostics.push({
+        code: 'dynamic-target',
+        stateId: stateNode.id,
+        eventType: t.eventType,
+        transitionId: `${stateNode.id}:${transitionIndex}`,
+        message: 'Transition function destinations require execution or source analysis.'
+      });
+    }
+    // A transition function computes its target when it runs, so there is
+    // no static edge to draw; a targetless transition stays in its state.
+    const targets = t.target ?? (t.to ? [] : [stateNode]);
     return targets.map((target, targetIndex) => {
       const edge = {
         id: `${stateNode.id}:${transitionIndex}:${targetIndex}`,
@@ -498,11 +157,17 @@ function toDirectedGraph(stateMachine) {
       return edge;
     });
   });
+  const children = getChildren(stateNode).map(toDirectedGraph);
+  diagnostics.push(...children.flatMap(child => child.analysis.diagnostics));
   const graph = {
     id: stateNode.id,
     stateNode: stateNode,
-    children: getChildren(stateNode).map(toDirectedGraph),
+    children,
     edges,
+    analysis: {
+      transitionTargetsComplete: diagnostics.length === 0,
+      diagnostics
+    },
     toJSON: () => {
       const {
         id,
@@ -512,34 +177,44 @@ function toDirectedGraph(stateMachine) {
       return {
         id,
         children,
-        edges: graphEdges
+        edges: graphEdges,
+        analysis: graph.analysis
       };
     }
   };
   return graph;
 }
 function isMachineLogic(logic) {
-  return 'getStateNodeById' in logic;
+  if (!logic || typeof logic !== 'object') {
+    return false;
+  }
+  const machine = logic;
+  const root = machine.root;
+  return !!root && typeof root === 'object' && typeof root.id === 'string' && typeof root.states === 'object' && typeof root.transitions?.values === 'function' && typeof machine.getStateNodeById === 'function' && typeof machine.resolveState === 'function' && typeof machine.getTransitionData === 'function';
 }
 function resolveTraversalOptions(logic, traversalOptions, defaultOptions) {
   const resolvedDefaultOptions = defaultOptions ?? (isMachineLogic(logic) ? createDefaultMachineOptions(logic, traversalOptions) : undefined);
   const serializeState = traversalOptions?.serializeState ?? resolvedDefaultOptions?.serializeState ?? (state => JSON.stringify(state));
+  const eventSource = traversalOptions?.events ?? resolvedDefaultOptions?.events ?? [];
   const traversalConfig = {
     serializeState,
     serializeEvent,
-    events: [],
     filterEvents: undefined,
     limit: Infinity,
-    fromState: undefined,
     toState: undefined,
     // Traversal should not continue past the `toState` predicate
     // since the target state has already been reached at that point
     stopWhen: traversalOptions?.toState,
     ...resolvedDefaultOptions,
-    ...traversalOptions
+    ...traversalOptions,
+    // Synthetic completion/delay events are supported by the machine runtime.
+    events: typeof eventSource === 'function' || Array.isArray(eventSource) ? eventSource : state => resolveEventCases(eventSource, state, createActor.isMachineSnapshot(state) ? createActor.getAllOwnEvents(state) : undefined),
+    fromState: traversalOptions?.fromState ?? resolvedDefaultOptions?.fromState
   };
   return traversalConfig;
 }
+
+/** @public */
 function joinPaths(headPath, tailPath) {
   const secondPathSource = tailPath.steps[0].state;
   if (secondPathSource !== headPath.state) {
@@ -553,9 +228,18 @@ function joinPaths(headPath, tailPath) {
   };
 }
 
+function createTraversalError(state, event, cause) {
+  return new Error(`Unable to evaluate graph transition from state ${state} with event ${event}. If the transition needs event payloads, provide representative events using the "events" option.`, {
+    cause
+  });
+}
+
 function resolveTransitionSnapshot(result) {
   return Array.isArray(result) ? result[0] : result;
 }
+
+/** @public */
+
 function getAdjacencyMap(logic, options) {
 
   const {
@@ -573,21 +257,25 @@ function getAdjacencyMap(logic, options) {
   const actorScope = createMockActorScope();
   const fromState = customFromState ?? logic.getInitialSnapshot(actorScope,
   // TODO: fix this
-  options.input);
-  const adj = {};
+  options?.input);
+  const adj = Object.create(null);
   let iterations = 0;
   const queue = [{
     nextState: fromState,
     event: undefined,
     prevState: undefined
   }];
-  const stateMap = new Map();
-  while (queue.length) {
+  for (let head = 0; head < queue.length; head++) {
     const {
       nextState: state,
       event,
       prevState
-    } = queue.shift();
+    } = queue[head];
+    // Release processed entries without shifting the remaining frontier.
+    if (head > 4096 && head * 2 > queue.length) {
+      queue.splice(0, head + 1);
+      head = -1;
+    }
     if (iterations++ > limit) {
       throw new Error('Traversal limit exceeded');
     }
@@ -595,10 +283,9 @@ function getAdjacencyMap(logic, options) {
     if (adj[serializedState]) {
       continue;
     }
-    stateMap.set(serializedState, state);
     adj[serializedState] = {
       state,
-      transitions: {}
+      transitions: Object.create(null)
     };
     if (stopWhen && stopWhen(state)) {
       continue;
@@ -608,8 +295,14 @@ function getAdjacencyMap(logic, options) {
       if (filterEvents && !filterEvents(state, nextEvent)) {
         continue;
       }
-      const nextSnapshot = resolveTransitionSnapshot(transition(state, nextEvent, actorScope));
-      adj[serializedState].transitions[serializeEvent(nextEvent)] = {
+      const serializedEvent = serializeEvent(nextEvent);
+      let nextSnapshot;
+      try {
+        nextSnapshot = resolveTransitionSnapshot(transition(state, nextEvent, actorScope));
+      } catch (cause) {
+        throw createTraversalError(serializedState, serializedEvent, cause);
+      }
+      adj[serializedState].transitions[serializedEvent] = {
         event: nextEvent,
         state: nextSnapshot
       };
@@ -622,6 +315,8 @@ function getAdjacencyMap(logic, options) {
   }
   return adj;
 }
+
+/** @public */
 function adjacencyMapToArray(adjMap) {
   const adjList = [];
   for (const adjValue of Object.values(adjMap)) {
@@ -643,7 +338,7 @@ function alterPath(path) {
     steps = [{
       state: path.state,
       event: {
-        type: dist_xstateActors.XSTATE_INIT
+        type: createActor.XSTATE_INIT
       }
     }];
   } else {
@@ -652,7 +347,7 @@ function alterPath(path) {
       steps.push({
         state: step.state,
         event: i === 0 ? {
-          type: dist_xstateActors.XSTATE_INIT
+          type: createActor.XSTATE_INIT
         } : path.steps[i - 1].event
       });
     }
@@ -667,46 +362,60 @@ function alterPath(path) {
   };
 }
 
-function isMachine(value) {
-  return !!value && value instanceof StateMachine.StateMachine;
-}
+/** @public */
 function getPathsFromEvents(logic, events, options) {
   const resolvedOptions = resolveTraversalOptions(logic, {
     events,
     ...options
-  }, isMachine(logic) ? createDefaultMachineOptions(logic) : createDefaultLogicOptions());
+  });
   const actorScope = createMockActorScope();
   const fromState = resolvedOptions.fromState ?? logic.getInitialSnapshot(actorScope,
   // TODO: fix this
   options?.input);
   const {
     serializeState,
-    serializeEvent
+    serializeEvent,
+    filterEvents,
+    stopWhen,
+    limit
   } = resolvedOptions;
-  const adjacency = getAdjacencyMap(logic, resolvedOptions);
-  const stateMap = new Map();
   const steps = [];
-  const serializedFromState = serializeState(fromState, undefined, undefined);
-  stateMap.set(serializedFromState, fromState);
-  let stateSerial = serializedFromState;
   let state = fromState;
+  let stateSerial = serializeState(state, undefined, undefined);
   for (const event of events) {
+    if (steps.length >= limit) {
+      throw new Error('Traversal limit exceeded');
+    }
+    const eventSerial = serializeEvent(event);
+    let nextEvent = event;
+    if (options?.events !== undefined) {
+      const candidates = typeof options.events === 'function' ? options.events(state) : options.events;
+      nextEvent = undefined;
+      for (let index = candidates.length - 1; index >= 0; index--) {
+        const candidate = candidates[index];
+        if ((!filterEvents || filterEvents(state, candidate)) && serializeEvent(candidate) === eventSerial) {
+          nextEvent = candidate;
+          break;
+        }
+      }
+    } else if (filterEvents && !filterEvents(state, event)) {
+      nextEvent = undefined;
+    }
+    if (!nextEvent || stopWhen?.(state)) {
+      throw new Error(`Invalid transition from ${stateSerial} with ${eventSerial}`);
+    }
     steps.push({
-      state: stateMap.get(stateSerial),
+      state,
       event
     });
-    const eventSerial = serializeEvent(event);
-    const {
-      state: nextState,
-      event: _nextEvent
-    } = adjacency[stateSerial].transitions[eventSerial];
-    if (!nextState) {
-      throw new Error(`Invalid transition from ${stateSerial} with ${eventSerial}`);
+    let result;
+    try {
+      result = logic.transition(state, nextEvent, actorScope);
+    } catch (cause) {
+      throw createTraversalError(stateSerial, eventSerial, cause);
     }
-    const prevState = stateMap.get(stateSerial);
-    const nextStateSerial = serializeState(nextState, event, prevState);
-    stateMap.set(nextStateSerial, nextState);
-    stateSerial = nextStateSerial;
+    const nextState = Array.isArray(result) ? result[0] : result;
+    stateSerial = serializeState(nextState, event, state);
     state = nextState;
   }
 
@@ -722,11 +431,16 @@ function getPathsFromEvents(logic, events, options) {
   })];
 }
 
+/** @public */
+
 function getShortestPaths(logic, options) {
   const resolvedOptions = resolveTraversalOptions(logic, options);
   const serializeState = resolvedOptions.serializeState;
   const fromState = resolvedOptions.fromState ?? logic.getInitialSnapshot(createMockActorScope(), options?.input);
-  const adjacency = getAdjacencyMap(logic, resolvedOptions);
+  const adjacency = getAdjacencyMap(logic, {
+    ...resolvedOptions,
+    fromState
+  });
 
   // weight, state, event
   const weightMap = new Map();
@@ -778,7 +492,7 @@ function getShortestPaths(logic, options) {
     visited.add(serializedState);
     unvisited.delete(serializedState);
   }
-  const statePlanMap = {};
+  const statePlanMap = Object.create(null);
   const paths = [];
   weightMap.forEach(({
     weight,
@@ -786,7 +500,7 @@ function getShortestPaths(logic, options) {
     event: fromEvent
   }, stateSerial) => {
     const state = stateMap.get(stateSerial);
-    const steps = !fromState ? [] : statePlanMap[fromState].paths[0].steps.concat({
+    const steps = fromState === undefined ? [] : statePlanMap[fromState].paths[0].steps.concat({
       state: stateMap.get(fromState),
       event: fromEvent
     });
@@ -810,19 +524,24 @@ function getShortestPaths(logic, options) {
   return paths.map(alterPath);
 }
 
+/** @public */
+
 function getSimplePaths(logic, options) {
   const resolvedOptions = resolveTraversalOptions(logic, options);
   const actorScope = createMockActorScope();
   const fromState = resolvedOptions.fromState ?? logic.getInitialSnapshot(actorScope, options?.input);
   const serializeState = resolvedOptions.serializeState;
-  const adjacency = getAdjacencyMap(logic, resolvedOptions);
+  const adjacency = getAdjacencyMap(logic, {
+    ...resolvedOptions,
+    fromState
+  });
   const stateMap = new Map();
   const visitCtx = {
     vertices: new Set(),
     edges: new Set()
   };
   const steps = [];
-  const pathMap = {};
+  const pathMap = Object.create(null);
   function util(fromStateSerial, toStateSerial) {
     const fromState = stateMap.get(fromStateSerial);
     visitCtx.vertices.add(fromStateSerial);
@@ -880,16 +599,13 @@ function getSimplePaths(logic, options) {
   return simplePaths.map(alterPath);
 }
 
-exports.TestModel = TestModel;
+exports.getAllOwnEvents = createActor.getAllOwnEvents;
 exports.adjacencyMapToArray = adjacencyMapToArray;
-exports.createShortestPathsGen = createShortestPathsGen;
-exports.createSimplePathsGen = createSimplePathsGen;
-exports.createTestModel = createTestModel;
 exports.getAdjacencyMap = getAdjacencyMap;
+exports.getDescendantStateNodes = getDescendantStateNodes;
 exports.getPathsFromEvents = getPathsFromEvents;
 exports.getShortestPaths = getShortestPaths;
 exports.getSimplePaths = getSimplePaths;
-exports.getStateNodes = getStateNodes;
 exports.joinPaths = joinPaths;
 exports.serializeSnapshot = serializeSnapshot;
 exports.toDirectedGraph = toDirectedGraph;