@systemfsoftware/xstate 0.0.0-bootstrap.0 → 6.0.0-beta.65

package/dist/graph.mjs

@@ -0,0 +1,667 @@
+import { t as createEmptyActor } from "./actors-LxMBvgxO.mjs";
+import { g as XSTATE_INIT, h as defaultWarn, r as getAllOwnEvents } from "./utils-CXBxxp3Z.mjs";
+// src/graph/actorScope.ts
+function actorSystem(actor) {
+	return actor.system;
+}
+function createMockActorScope() {
+	const emptyActor = createEmptyActor();
+	return {
+		self: emptyActor,
+		logger: console.log,
+		warn: defaultWarn,
+		id: "",
+		sessionId: "mock-actor-scope",
+		defer: () => {},
+		system: actorSystem(emptyActor),
+		stopChild: () => {},
+		emit: () => {},
+		actionExecutor: () => {}
+	};
+}
+// src/graph/graph.ts
+const isActorLogic = (value) => value !== void 0 && "transition" in value;
+const logicFirstOrLast = (compute) => (first, second) => isActorLogic(first) ? compute(first, second) : (logic) => compute(logic, first);
+/**
+* Returns all state nodes of the given `node`.
+*
+* @public
+* @param stateNode State node to recursively get child state nodes from
+* @public
+*/
+function getDescendantStateNodes(stateNode) {
+	const { states } = stateNode;
+	return Object.keys(states).reduce((accNodes, stateKey) => {
+		const childStateNode = states[stateKey];
+		if (childStateNode === void 0) return accNodes;
+		accNodes.push(childStateNode, ...getDescendantStateNodes(childStateNode));
+		return accNodes;
+	}, []);
+}
+function getChildren(stateNode) {
+	return Object.values(stateNode.states);
+}
+function isFilled(context) {
+	return context !== void 0 && Object.keys(context).length > 0;
+}
+function nonEmptyContext(context) {
+	return isFilled(context) ? context : void 0;
+}
+function snapshotFields(snapshot) {
+	const { value, context } = snapshot;
+	return {
+		value,
+		context: nonEmptyContext(context)
+	};
+}
+function toSerializedSnapshot(value) {
+	return value;
+}
+function toSerializedEvent(value) {
+	return value;
+}
+/** @public */
+function serializeSnapshot(snapshot) {
+	return toSerializedSnapshot(JSON.stringify(snapshotFields(snapshot)));
+}
+function serializeEvent(event) {
+	return toSerializedEvent(JSON.stringify(event));
+}
+function ownLogicEvents(state) {
+	return getAllOwnEvents(state);
+}
+function defaultSerializeState(state) {
+	return JSON.stringify(state);
+}
+function optionFromState(options) {
+	return options?.fromState;
+}
+function optionStopWhen(options) {
+	return options?.toState;
+}
+function startState(logic, options) {
+	return options.fromState ?? logic.getInitialSnapshot(createMockActorScope(), options.input);
+}
+function createDefaultMachineOptions(machine, options = {}) {
+	return {
+		serializeState: serializeSnapshot,
+		serializeEvent,
+		events: ownLogicEvents,
+		fromState: startState(machine, options)
+	};
+}
+const memberOf = (value, key) => new Object(Reflect.get(value, key));
+const memberIs = (value, key, kind) => typeof Reflect.get(value, key) === kind;
+const machineMethods = [
+	"getStateNodeById",
+	"resolveState",
+	"getTransitionData"
+];
+function isMachineLogic(logic) {
+	const root = memberOf(logic, "root");
+	return [
+		typeof logic === "object",
+		memberIs(logic, "root", "object"),
+		memberIs(root, "id", "string"),
+		memberIs(root, "states", "object"),
+		memberIs(memberOf(root, "transitions"), "values", "function"),
+		...machineMethods.map((method) => memberIs(logic, method, "function"))
+	].every(Boolean);
+}
+function transitionEventType(transition) {
+	return transition.eventType;
+}
+/** @public */
+function toDirectedGraph(stateMachine) {
+	const stateNode = isMachineLogic(stateMachine) ? stateMachine.root : stateMachine;
+	const edges = [...stateNode.transitions.values()].flat().flatMap((t, transitionIndex) => {
+		const targets = t.target !== void 0 ? t.target : [stateNode];
+		const eventType = transitionEventType(t);
+		return targets.map((target, targetIndex) => {
+			const edge = {
+				id: `${stateNode.id}:${transitionIndex}:${targetIndex}`,
+				source: stateNode,
+				target,
+				transition: t,
+				label: {
+					text: eventType,
+					toJSON: () => ({ text: eventType })
+				},
+				toJSON: () => {
+					const { label } = edge;
+					return {
+						source: stateNode.id,
+						target: target.id,
+						label
+					};
+				}
+			};
+			return edge;
+		});
+	});
+	const graph = {
+		id: stateNode.id,
+		stateNode,
+		children: getChildren(stateNode).map(toDirectedGraph),
+		edges,
+		toJSON: () => {
+			const { id, children, edges: graphEdges } = graph;
+			return {
+				id,
+				children,
+				edges: graphEdges
+			};
+		}
+	};
+	return graph;
+}
+function resolveDefaultOptions(logic, traversalOptions) {
+	return isMachineLogic(logic) ? createDefaultMachineOptions(logic, traversalOptions) : void 0;
+}
+function resolveTraversalOptions({ logic, options: traversalOptions }) {
+	const resolvedDefaultOptions = resolveDefaultOptions(logic, traversalOptions);
+	const serializeState = defaultSerializeState;
+	const fromState = optionFromState(traversalOptions) ?? optionFromState(resolvedDefaultOptions);
+	return {
+		serializeState,
+		serializeEvent,
+		events: [],
+		filterEvents: void 0,
+		limit: Infinity,
+		toState: void 0,
+		stopWhen: optionStopWhen(traversalOptions),
+		...resolvedDefaultOptions,
+		...traversalOptions,
+		fromState
+	};
+}
+function requireFirstStep(path) {
+	const firstStep = path.steps[0];
+	if (firstStep === void 0) throw new Error(`Paths cannot be joined`);
+	return firstStep;
+}
+const joinPathsDataFirst = (headPath, tailPath) => {
+	if (requireFirstStep(tailPath).state !== headPath.state) throw new Error(`Paths cannot be joined`);
+	return {
+		state: tailPath.state,
+		steps: headPath.steps.concat(tailPath.steps.slice(1)),
+		weight: headPath.weight + tailPath.weight
+	};
+};
+function joinPaths(...args) {
+	if (args.length === 2) return joinPathsDataFirst(args[0], args[1]);
+	const [tailPath] = args;
+	return (headPath) => joinPathsDataFirst(headPath, tailPath);
+}
+// src/graph/adjacency.ts
+const createNullDict$2 = () => {
+	const dict = {};
+	Object.setPrototypeOf(dict, null);
+	return dict;
+};
+function resolveTransitionSnapshot(result) {
+	return Array.isArray(result) ? result[0] : result;
+}
+const initialSnapshotOf$3 = (logic, input, actorScope) => logic.getInitialSnapshot(actorScope, input);
+function actorScopeOf$1(scope) {
+	return scope;
+}
+const isVisited = (adj, serialized) => adj[serialized] !== void 0;
+const stopsAt = (traversal, state) => {
+	const { stopWhen } = traversal.config;
+	return stopWhen === void 0 ? false : stopWhen(state);
+};
+const countIteration = (traversal) => {
+	const exceeded = traversal.iterations > traversal.config.limit;
+	traversal.iterations += 1;
+	if (exceeded) throw new Error("Traversal limit exceeded");
+};
+const registerQueued = (adj, queued, traversal) => {
+	countIteration(traversal);
+	const { nextState, event, prevState } = queued;
+	const serialized = toSerializedSnapshot(traversal.config.serializeState(nextState, event, prevState));
+	if (isVisited(adj, serialized)) return;
+	return storeValue(adj, serialized, nextState, traversal);
+};
+const storeValue = (adj, serialized, state, traversal) => {
+	const value = {
+		state,
+		transitions: createNullDict$2()
+	};
+	adj[serialized] = value;
+	return stopsAt(traversal, state) ? void 0 : value;
+};
+const eventsFor = (traversal, state) => {
+	const { events } = traversal.config;
+	return typeof events === "function" ? events(state) : events;
+};
+const passesFilter = (traversal, state, event) => {
+	const { filterEvents } = traversal.config;
+	return filterEvents === void 0 ? true : filterEvents(state, event);
+};
+const recordTransition = (value, queue, queued, event, traversal) => {
+	const nextState = resolveTransitionSnapshot(traversal.logic.transition(queued.nextState, event, actorScopeOf$1(traversal.actorScope)));
+	value.transitions[toSerializedEvent(traversal.config.serializeEvent(event))] = {
+		event,
+		state: nextState
+	};
+	queue.push({
+		nextState,
+		event,
+		prevState: queued.nextState
+	});
+};
+const enqueueTransitions = (value, queue, queued, traversal) => {
+	for (const event of eventsFor(traversal, queued.nextState)) enqueueFiltered(value, queue, queued, event, traversal);
+};
+const enqueueFiltered = (value, queue, queued, event, traversal) => {
+	if (passesFilter(traversal, queued.nextState, event)) recordTransition(value, queue, queued, event, traversal);
+};
+const expand = (adj, queue, queued, traversal) => {
+	const value = registerQueued(adj, queued, traversal);
+	if (value === void 0) return;
+	enqueueTransitions(value, queue, queued, traversal);
+};
+const expandLevel = (adj, level, traversal) => {
+	const nextLevel = [];
+	for (const queued of level) expand(adj, nextLevel, queued, traversal);
+	return nextLevel;
+};
+const drain = (adj, start, traversal) => {
+	let level = [start];
+	while (level.length !== 0) level = expandLevel(adj, level, traversal);
+};
+function computeAdjacencyMap(logic, options) {
+	"use strict";
+	const config = resolveTraversalOptions({
+		logic,
+		options
+	});
+	const actorScope = createMockActorScope();
+	const traversal = {
+		config,
+		logic,
+		actorScope,
+		iterations: 0
+	};
+	const fromState = config.fromState ?? initialSnapshotOf$3(logic, options.input, actorScope);
+	const adj = createNullDict$2();
+	drain(adj, {
+		nextState: fromState,
+		event: void 0,
+		prevState: void 0
+	}, traversal);
+	return adj;
+}
+function getAdjacencyMap(...args) {
+	if (args.length === 1) {
+		const [options] = args;
+		return (logic) => computeAdjacencyMap(logic, options);
+	}
+	return computeAdjacencyMap(args[0], args[1]);
+}
+/** @public */
+function adjacencyMapToArray(adjMap) {
+	return Object.values({ ...adjMap }).flatMap((adjValue) => adjacencyRow(adjValue));
+}
+const adjacencyRow = (adjValue) => Object.values({ ...adjValue.transitions }).map((transition) => ({
+	state: adjValue.state,
+	event: transition.event,
+	nextState: transition.state
+}));
+// src/graph/alterPath.ts
+const initStepOf = (state) => ({
+	state,
+	event: { type: XSTATE_INIT }
+});
+const previousStepOf = (steps, index) => steps[index - 1];
+const eventForStep = (steps, index) => {
+	const previous = previousStepOf(steps, index);
+	return previous === void 0 ? { type: XSTATE_INIT } : previous.event;
+};
+const replaySteps = (path) => path.steps.flatMap((step, index) => [{
+	state: step.state,
+	event: eventForStep(path.steps, index)
+}]);
+const finalStepOf = (path) => {
+	const last = path.steps[path.steps.length - 1];
+	return last === void 0 ? void 0 : {
+		state: path.state,
+		event: last.event
+	};
+};
+const appendedSteps = (path) => {
+	const steps = replaySteps(path);
+	const finalStep = finalStepOf(path);
+	steps.push(finalStep === void 0 ? initStepOf(path.state) : finalStep);
+	return steps;
+};
+function alterPath(path) {
+	return {
+		...path,
+		steps: appendedSteps(path)
+	};
+}
+// src/graph/pathFromEvents.ts
+const inputOf$2 = (options) => options === void 0 ? void 0 : options.input;
+const initialSnapshotOf$2 = (logic, input, actorScope) => logic.getInitialSnapshot(actorScope, input);
+function actorScopeOf(scope) {
+	return scope;
+}
+const passesFilterEvents = (filterEvents, state, event) => filterEvents === void 0 ? true : filterEvents(state, event);
+const matchesCandidate = (filterEvents, serializeEvent, state, candidate, eventSerial) => passesFilterEvents(filterEvents, state, candidate) && serializeEvent(candidate) === eventSerial;
+const lastMatchingCandidate = (candidates, filterEvents, serializeEvent, state, eventSerial) => [...candidates].reverse().find((candidate) => matchesCandidate(filterEvents, serializeEvent, state, candidate, eventSerial));
+const eventsFrom = (events, state) => typeof events === "function" ? events(state) : events;
+const overrideEvents = (options, state) => options === void 0 ? void 0 : eventsFrom(options.events, state);
+const replayEvent = (filterEvents, state, event) => passesFilterEvents(filterEvents, state, event) ? event : void 0;
+const nextEventFor = (context, state, event, eventSerial) => {
+	const override = overrideEvents(context.options, state);
+	if (override !== void 0) return lastMatchingCandidate(override, context.config.filterEvents, context.config.serializeEvent, state, eventSerial);
+	return replayEvent(context.config.filterEvents, state, event);
+};
+const assertWithinLimit = (stepCount, limit) => {
+	if (stepCount >= limit) throw new Error("Traversal limit exceeded");
+};
+const stopsBefore = (stopWhen, state) => stopWhen === void 0 ? false : stopWhen(state);
+const isReplayable = (nextEvent, stopWhen, state) => nextEvent !== void 0 && !stopsBefore(stopWhen, state);
+const invalidTransition = (stateSerial, eventSerial) => /* @__PURE__ */ new Error(`Invalid transition from ${stateSerial} with ${eventSerial}`);
+const assertReplayable = (nextEvent, stopWhen, state, stateSerial, eventSerial) => {
+	if (isReplayable(nextEvent, stopWhen, state)) return nextEvent;
+	throw invalidTransition(stateSerial, eventSerial);
+};
+const advanceState = (context, replay, nextEvent, event) => {
+	const result = context.logic.transition(replay.state, nextEvent, actorScopeOf(context.actorScope));
+	const nextState = Array.isArray(result) ? result[0] : result;
+	return {
+		state: nextState,
+		stateSerial: toSerializedSnapshot(context.config.serializeState(nextState, event, replay.state))
+	};
+};
+const replayOne = (context, replay, event) => {
+	assertWithinLimit(context.steps.length, context.config.limit);
+	const eventSerial = toSerializedEvent(context.config.serializeEvent(event));
+	const nextEvent = assertReplayable(nextEventFor(context, replay.state, event, eventSerial), context.config.stopWhen, replay.state, replay.stateSerial, eventSerial);
+	context.steps.push({
+		state: replay.state,
+		event
+	});
+	return advanceState(context, replay, nextEvent, event);
+};
+const initialReplay = (config, logic, options, actorScope) => {
+	const state = config.fromState ?? initialSnapshotOf$2(logic, inputOf$2(options), actorScope);
+	return {
+		state,
+		stateSerial: toSerializedSnapshot(config.serializeState(state, void 0, void 0))
+	};
+};
+const reachesTarget = (toState, state) => toState === void 0 ? true : toState(state);
+const buildPaths = (context, replay) => {
+	if (!reachesTarget(context.config.toState, replay.state)) return [];
+	return [alterPath({
+		state: replay.state,
+		steps: context.steps,
+		weight: context.steps.length
+	})];
+};
+function computePathsFromEvents(logic, events, options) {
+	const config = resolveTraversalOptions({
+		logic,
+		options: {
+			events,
+			...options
+		}
+	});
+	const actorScope = createMockActorScope();
+	const context = {
+		config,
+		options,
+		logic,
+		actorScope,
+		steps: []
+	};
+	let replay = initialReplay(config, logic, options, actorScope);
+	for (const event of events) replay = replayOne(context, replay, event);
+	return buildPaths(context, replay);
+}
+const isDataLastReplay = (args) => Array.isArray(args[0]);
+function getPathsFromEvents(...args) {
+	return isDataLastReplay(args) ? (logic) => computePathsFromEvents(logic, args[0], args[1]) : computePathsFromEvents(args[0], args[1], args[2]);
+}
+// src/graph/shortestPaths.ts
+const createNullDict$1 = () => {
+	const dict = {};
+	Object.setPrototypeOf(dict, null);
+	return dict;
+};
+const inputOf$1 = (options) => options === void 0 ? void 0 : options.input;
+const initialSnapshotOf$1 = (logic, input, actorScope) => logic.getInitialSnapshot(actorScope, input);
+const discover = (context, nextSerialized, entry) => {
+	if (!context.visited.has(nextSerialized)) context.unvisited.set(nextSerialized, entry);
+};
+const recordReach = (context, nextSerialized, weight, origin, snapshot, event) => {
+	const existing = context.weightMap.get(nextSerialized);
+	const entry = existing === void 0 ? {
+		weight,
+		snapshot,
+		origin,
+		event
+	} : {
+		...existing,
+		snapshot
+	};
+	context.weightMap.set(nextSerialized, entry);
+	discover(context, nextSerialized, entry);
+};
+const relaxTransition = (context, fromSerialized, fromSnapshot, weight, transitions, serializedEvent) => {
+	const transition = transitions[serializedEvent];
+	if (transition === void 0) return;
+	const nextSerialized = toSerializedSnapshot(context.serializeState(transition.state, transition.event, fromSnapshot));
+	recordReach(context, nextSerialized, weight + 1, fromSerialized, transition.state, transition.event);
+};
+const relaxTransitions = (context, fromSerialized, fromSnapshot, weight, adjacencyValue) => {
+	for (const serializedEvent of Object.keys(adjacencyValue.transitions).map(toSerializedEvent)) relaxTransition(context, fromSerialized, fromSnapshot, weight, adjacencyValue.transitions, serializedEvent);
+};
+const relaxState = (context, fromSerialized, entry) => {
+	const adjacencyValue = context.adjacency[fromSerialized];
+	if (adjacencyValue === void 0) return;
+	relaxTransitions(context, fromSerialized, entry.snapshot, entry.weight, adjacencyValue);
+	context.visited.add(fromSerialized);
+	context.unvisited.delete(fromSerialized);
+};
+const runTraversal = (context) => {
+	for (const [fromSerialized, entry] of context.unvisited) relaxState(context, fromSerialized, entry);
+};
+const firstPlanPath = (statePlanMap, fromSerialized) => {
+	const plan = statePlanMap[fromSerialized];
+	return plan === void 0 ? void 0 : plan.paths[0];
+};
+const stepTo = (fromState, event) => event === void 0 ? [] : [{
+	state: fromState,
+	event
+}];
+const stepsToward = (statePlanMap, fromSerialized, event) => {
+	const path = firstPlanPath(statePlanMap, fromSerialized);
+	return path === void 0 ? [] : path.steps.concat(stepTo(path.state, event));
+};
+const predecessorSteps = (statePlanMap, entry) => {
+	const origin = entry.origin;
+	return origin === void 0 ? [] : stepsToward(statePlanMap, origin, entry.event);
+};
+const buildPath = (statePlanMap, entry, stateSerial) => {
+	const state = entry.snapshot;
+	const steps = predecessorSteps(statePlanMap, entry);
+	statePlanMap[stateSerial] = {
+		state,
+		paths: [{
+			state,
+			steps,
+			weight: entry.weight
+		}]
+	};
+	return {
+		state,
+		steps,
+		weight: entry.weight
+	};
+};
+const collectPaths = (weightMap) => {
+	const statePlanMap = createNullDict$1();
+	const paths = [];
+	weightMap.forEach((entry, stateSerial) => {
+		paths.push(buildPath(statePlanMap, entry, stateSerial));
+	});
+	return paths;
+};
+const applyTarget$1 = (paths, toState) => {
+	const target = toState;
+	if (target === void 0) return paths.map(alterPath);
+	return paths.filter((path) => target(path.state)).map(alterPath);
+};
+const seed$1 = (context, fromState) => {
+	const serialized = toSerializedSnapshot(context.serializeState(fromState, void 0, void 0));
+	const entry = {
+		weight: 0,
+		snapshot: fromState,
+		origin: void 0,
+		event: void 0
+	};
+	context.weightMap.set(serialized, entry);
+	context.unvisited.set(serialized, entry);
+};
+function computeShortestPaths(logic, options) {
+	const resolvedOptions = resolveTraversalOptions({
+		logic,
+		options
+	});
+	const fromState = resolvedOptions.fromState ?? initialSnapshotOf$1(logic, inputOf$1(options), createMockActorScope());
+	const context = {
+		adjacency: getAdjacencyMap(logic, {
+			...resolvedOptions,
+			fromState
+		}),
+		serializeState: resolvedOptions.serializeState,
+		weightMap: /* @__PURE__ */ new Map(),
+		visited: /* @__PURE__ */ new Set(),
+		unvisited: /* @__PURE__ */ new Map()
+	};
+	seed$1(context, fromState);
+	runTraversal(context);
+	return applyTarget$1(collectPaths(context.weightMap), resolvedOptions.toState);
+}
+function getShortestPaths(...args) {
+	const [first, second] = args;
+	return logicFirstOrLast(computeShortestPaths)(first, second);
+}
+// src/graph/simplePaths.ts
+const createNullDict = () => {
+	const dict = {};
+	Object.setPrototypeOf(dict, null);
+	return dict;
+};
+const inputOf = (options) => options === void 0 ? void 0 : options.input;
+const initialSnapshotOf = (logic, input, actorScope) => logic.getInitialSnapshot(actorScope, input);
+const boxFor = (context, serialized, snapshot) => {
+	const existing = context.stateMap.get(serialized);
+	const box = existing === void 0 ? { snapshot } : existing;
+	box.snapshot = snapshot;
+	context.stateMap.set(serialized, box);
+	return box;
+};
+const createPlan = (pathMap, serialized, state) => {
+	const plan = {
+		state,
+		paths: []
+	};
+	pathMap[serialized] = plan;
+	return plan;
+};
+const planAt = (pathMap, serialized, state) => {
+	const existing = pathMap[serialized];
+	return existing === void 0 ? createPlan(pathMap, serialized, state) : existing;
+};
+const recordPath = (context, toSerialized, fromState) => {
+	planAt(context.pathMap, toSerialized, fromState).paths.push({
+		state: fromState,
+		weight: context.steps.length,
+		steps: [...context.steps]
+	});
+};
+function expandInto(context, box, toSerialized, serializedEvent, event, nextSerialized, nextBox) {
+	context.visitCtx.edges.add(serializedEvent);
+	context.steps.push({
+		state: box.snapshot,
+		event
+	});
+	visit(context, nextSerialized, nextBox, toSerialized);
+}
+const descendInto = (context, box, toSerialized, serializedEvent, transition) => {
+	const nextSerialized = toSerializedSnapshot(context.serializeState(transition.state, transition.event, box.snapshot));
+	const nextBox = boxFor(context, nextSerialized, transition.state);
+	if (!context.visitCtx.vertices.has(nextSerialized)) expandInto(context, box, toSerialized, serializedEvent, transition.event, nextSerialized, nextBox);
+};
+const descendTransition = (context, box, toSerialized, transitions, serializedEvent) => {
+	const transition = transitions[serializedEvent];
+	if (transition === void 0) return;
+	descendInto(context, box, toSerialized, serializedEvent, transition);
+};
+const descendTransitions = (context, box, toSerialized, adjacencyValue) => {
+	for (const serializedEvent of Object.keys(adjacencyValue.transitions).map(toSerializedEvent)) descendTransition(context, box, toSerialized, adjacencyValue.transitions, serializedEvent);
+};
+const descend = (context, fromSerialized, box, toSerialized) => {
+	const adjacencyValue = context.adjacency[fromSerialized];
+	if (adjacencyValue === void 0) return;
+	descendTransitions(context, box, toSerialized, adjacencyValue);
+};
+function visit(context, fromSerialized, box, toSerialized) {
+	context.visitCtx.vertices.add(fromSerialized);
+	if (fromSerialized === toSerialized) recordPath(context, toSerialized, box.snapshot);
+	else descend(context, fromSerialized, box, toSerialized);
+	context.steps.pop();
+	context.visitCtx.vertices.delete(fromSerialized);
+}
+const seed = (context, fromState) => {
+	const serialized = toSerializedSnapshot(context.serializeState(fromState, void 0));
+	return {
+		serialized,
+		box: boxFor(context, serialized, fromState)
+	};
+};
+const visitEachStart = (context, fromSerialized, box) => {
+	for (const nextSerialized of Object.keys(context.adjacency).map(toSerializedSnapshot)) visit(context, fromSerialized, box, nextSerialized);
+};
+const applyTarget = (paths, toState) => {
+	const target = toState;
+	if (target === void 0) return paths.map(alterPath);
+	return paths.filter((path) => target(path.state)).map(alterPath);
+};
+function computeSimplePaths(logic, options) {
+	const resolvedOptions = resolveTraversalOptions({
+		logic,
+		options
+	});
+	const actorScope = createMockActorScope();
+	const fromState = resolvedOptions.fromState ?? initialSnapshotOf(logic, inputOf(options), actorScope);
+	const context = {
+		adjacency: getAdjacencyMap(logic, {
+			...resolvedOptions,
+			fromState
+		}),
+		serializeState: resolvedOptions.serializeState,
+		stateMap: /* @__PURE__ */ new Map(),
+		visitCtx: {
+			vertices: /* @__PURE__ */ new Set(),
+			edges: /* @__PURE__ */ new Set()
+		},
+		steps: [],
+		pathMap: createNullDict()
+	};
+	const { serialized: fromSerialized, box } = seed(context, fromState);
+	visitEachStart(context, fromSerialized, box);
+	const simplePaths = Object.values(context.pathMap).flatMap((plan) => plan.paths);
+	return applyTarget(simplePaths, resolvedOptions.toState);
+}
+function getSimplePaths(...args) {
+	const [first, second] = args;
+	return logicFirstOrLast(computeSimplePaths)(first, second);
+}
+export { adjacencyMapToArray, getAdjacencyMap, getDescendantStateNodes, getPathsFromEvents, getShortestPaths, getSimplePaths, joinPaths, serializeSnapshot, toDirectedGraph };