@systemfsoftware/xstate 0.0.0-stage → 6.0.0-beta.65

package/dist/src-zLWug7SF.mjs

@@ -0,0 +1,2641 @@
+import { c as assertValid, n as TimeoutError, r as createAsyncLogic } from "./actors-LxMBvgxO.mjs";
+import { a as isActorRefLike, c as matchesEventDescriptor, d as resolveReferencedActor, f as toArray, h as defaultWarn } from "./utils-CXBxxp3Z.mjs";
+import { Ct as createErrorPlatformEvent, D as createSpawnEffect, F as resolveActionsWithContext, G as isInertActorScope, H as systemLogicMetadata, I as takeSpawnAllocationCounters, J as createMachineSnapshot, K as setInertActorScopeSnapshot, L as resolveRegisteredActorSource, N as mergeActorIdCounters, O as createStartEffect, P as reserveChildId, S as beginSpawnAllocation, St as createErrorActorEvent, Tt as createInvokeTimeoutEvent, U as attachSnapshotActorRef, V as listenerLogic, W as createInertActorScope, X as isMachineSnapshot, Y as getPersistedSnapshot, _ as transitionNode, at as parseDelayToMilliseconds, b as allocateChildId, ct as encodeAddressSegment, d as getTransitionResult, dt as parseGeneratedActorId, f as hasEffect, g as resolveStateValue, h as macrostep, i as StateNode, it as isAtomicStateNode, j as finalizeTransitionResult, l as getStateNodeByPath, lt as getActorIdPrefix, m as isInFinalState, mt as setSnapshotActorRef, nt as createRemoteActorRef, o as formatRouteTransitions, ot as withActorSelf, p as initialMicrostep, q as cloneMachineSnapshot, r as createActor, s as getAllStateNodes, tt as toStatePath, u as getStateNodes, w as createDeadLetterEffect, wt as createInitEvent, x as assertChildIdFree, xt as createDoneActorEvent, y as isStateId, z as subscriptionLogic } from "./createActor-BGHd7i8Q.mjs";
+// src/types.ts
+/** @public */
+let SpecialTargets = /* @__PURE__ */ function(SpecialTargets) {
+	SpecialTargets["Internal"] = "#_internal";
+	return SpecialTargets;
+}({});
+// src/assert.ts
+const describeTypes = (types) => types.length === 1 ? `type matching "${types[0]}"` : `one of types matching "${types.join("\", \"")}"`;
+const assertEventOf = (event, type) => {
+	const types = toArray(type);
+	if (!types.some((descriptor) => matchesEventDescriptor(event.type, descriptor))) throw new Error(`Expected event ${JSON.stringify(event)} to have ${describeTypes(types)}`);
+};
+function assertEvent(...args) {
+	if (args.length === 1) {
+		const [type] = args;
+		return (event) => assertEventOf(event, type);
+	}
+	assertEventOf(args[0], args[1]);
+}
+// src/spawn.ts
+function createSpawner(actorScope, actors, spawnedChildren) {
+	return ((src, options) => {
+		const referencedSrc = resolveRegisteredActorSource(actors, src);
+		const id = options?.id ?? allocateChildId(actorScope, referencedSrc ?? src).id;
+		if (options?.id !== void 0) {
+			assertChildIdFree(actorScope, options.id);
+			reserveChildId(actorScope, options.id);
+		}
+		const actor = actorScope.system.createActorRef(src, {
+			id,
+			parent: actorScope.self,
+			syncSnapshot: options?.syncSnapshot,
+			input: options?.input,
+			src: referencedSrc ?? src,
+			registryKey: options?.registryKey
+		});
+		spawnedChildren[actor.id] = actor;
+		return actor;
+	});
+}
+// src/StateMachine.ts
+function findEventSchema(schemas, eventType) {
+	if (!schemas) return;
+	if (Object.hasOwn(schemas, eventType)) return schemas[eventType];
+	const descriptor = Object.keys(schemas).find((key) => matchesEventDescriptor(eventType, key));
+	return descriptor === void 0 ? void 0 : schemas[descriptor];
+}
+let emptyCanActor;
+let emptyCanActorScope;
+function getEmptyCanActor() {
+	return emptyCanActor ??= createActor({
+		transition: (snapshot) => [snapshot, []],
+		initialTransition: () => [{
+			status: "active",
+			output: void 0,
+			error: void 0
+		}, []],
+		getInitialSnapshot: () => ({
+			status: "active",
+			output: void 0,
+			error: void 0
+		}),
+		getPersistedSnapshot: (snapshot) => snapshot
+	});
+}
+function getEmptyCanActorScope() {
+	if (emptyCanActorScope) return emptyCanActorScope;
+	const actor = getEmptyCanActor();
+	emptyCanActorScope = {
+		self: actor,
+		logger: () => {},
+		warn: defaultWarn,
+		id: "",
+		sessionId: "",
+		defer: () => {},
+		system: actor.system,
+		stopChild: () => {},
+		emit: () => {},
+		actionExecutor: () => {}
+	};
+	return emptyCanActorScope;
+}
+/** @public */
+var StateMachine = class StateMachine {
+	config;
+	validator;
+	/**
+	* Type-only marker for the actor's internal event protocol. `actor.send` and
+	* `actor.trigger` read it to drop internal events from the public protocol,
+	* so it must survive `stripInternal` into the published declarations. Not
+	* `declare` (the build's babel pipeline rejects declare class fields); the
+	* one `undefined` property this emits per machine instance is inert.
+	*/
+	_internalEventType;
+	/** Type-only marker for transition metadata. Never assigned at runtime. */
+	_transitionMetaType;
+	/**
+	* Type-only marker for the declared input type. `getInitialSnapshot` takes
+	* input optionally, so inferring input from it always adds `undefined`;
+	* `InputFrom` reads this carrier instead. Method-shaped so it stays
+	* bivariant like `getInitialSnapshot`. Never assigned at runtime.
+	*/
+	_inputType;
+	/**
+	* Type-level carriers for the machine's source maps and state schema. Type
+	* helpers in integration packages read these to walk a machine's declared
+	* actions, actors and invoked sources. They are never assigned at runtime.
+	*/
+	_actionMap;
+	_actorMap;
+	_stateSchema;
+	/** The machine's own version. */
+	version;
+	schemas;
+	/** Standard Schema for snapshots persisted by this machine version. */
+	snapshotSchema;
+	/** Standard Schema for complete events accepted by this machine version. */
+	eventSchema;
+	sources;
+	/** Runtime options for machine execution. */
+	options;
+	/** @internal */
+	idMap = /* @__PURE__ */ new Map();
+	root;
+	id;
+	states;
+	events;
+	internalEventDescriptors;
+	/** @internal Skips eventless-selection scans for machines without `always`. */
+	_hasEventlessTransitions;
+	/**
+	* Adapter hooks for actor-local transition evaluation state. Used by
+	* `@xstate/scxml`; not part of the stable API.
+	*
+	* @experimental
+	*/
+	_microstepHooks;
+	constructor(config, sources, validator) {
+		this.config = config;
+		this.validator = validator;
+		this.id = config.id || "(machine)";
+		this.sources = {
+			actors: config.actors ?? {},
+			actions: config.actions ?? {},
+			delays: config.delays ?? {},
+			guards: config.guards ?? {},
+			...sources
+		};
+		this.version = this.config.version;
+		this.schemas = this.config.schemas;
+		this.snapshotSchema = { "~standard": {
+			version: 1,
+			vendor: "xstate",
+			validate: async (value) => {
+				if (value === null || typeof value !== "object") return { issues: [{ message: "Expected a persisted snapshot." }] };
+				const snapshot = {
+					historyValue: {},
+					timers: {},
+					...value
+				};
+				const contextSchema = this.schemas?.context;
+				let context = snapshot["context"];
+				if (contextSchema) {
+					const result = await contextSchema["~standard"].validate(context);
+					if (result.issues) return { issues: [{ message: `Invalid context for machine '${this.id}' version '${this.version}': ${result.issues[0]?.message}` }] };
+					context = result.value;
+				}
+				for (const key of ["value", "children"]) if (!(key in snapshot)) return { issues: [{ message: `Persisted snapshot is missing '${key}'.` }] };
+				if (![
+					"active",
+					"done",
+					"error",
+					"stopped"
+				].includes(snapshot["status"])) return { issues: [{ message: "Persisted snapshot has invalid status." }] };
+				for (const key of [
+					"children",
+					"historyValue",
+					"timers"
+				]) if (snapshot[key] === null || typeof snapshot[key] !== "object" || Array.isArray(snapshot[key])) return { issues: [{ message: `Persisted snapshot has invalid '${key}'.` }] };
+				try {
+					this.resolveState({
+						value: snapshot["value"],
+						context
+					});
+				} catch (error) {
+					return { issues: [{ message: error instanceof Error ? error.message : "Persisted snapshot has invalid state value." }] };
+				}
+				return { value: {
+					...snapshot,
+					context
+				} };
+			}
+		} };
+		this.eventSchema = { "~standard": {
+			version: 1,
+			vendor: "xstate",
+			validate: async (value) => {
+				if (value === null || typeof value !== "object" || typeof value.type !== "string") return { issues: [{ message: "Expected an event object." }] };
+				const event = value;
+				const eventSchemas = this.schemas?.events;
+				const internalEventSchemas = this.schemas?.internalEvents;
+				const isFrameworkEvent = event.type.startsWith("xstate.") || event.type.startsWith("@xstate.");
+				const schema = findEventSchema(internalEventSchemas, event.type) ?? findEventSchema(eventSchemas, event.type);
+				if ((eventSchemas || internalEventSchemas) && !schema && !isFrameworkEvent) return { issues: [{ message: `Unknown event '${event.type}' for machine '${this.id}' version '${this.version}'.` }] };
+				if (!schema) return { value: event };
+				const { type, ...payload } = event;
+				const result = await schema["~standard"].validate(payload);
+				if (result.issues) return result;
+				if (result.value === null || typeof result.value !== "object") return { issues: [{ message: "Expected an event payload." }] };
+				return { value: {
+					...result.value,
+					type
+				} };
+			}
+		} };
+		this.internalEventDescriptors = Object.keys(this.schemas?.internalEvents ?? {});
+		this.options = { ...this.config.options };
+		this.transition = this.transition.bind(this);
+		this.initialTransition = this.initialTransition.bind(this);
+		this.getInitialSnapshot = this.getInitialSnapshot.bind(this);
+		this.getPersistedSnapshot = this.getPersistedSnapshot.bind(this);
+		this.restoreSnapshot = this.restoreSnapshot.bind(this);
+		this.start = this.start.bind(this);
+		this.root = new StateNode(config, {
+			_key: this.id,
+			_machine: this
+		});
+		this.root._initialize();
+		formatRouteTransitions(this.root);
+		this.root._refreshEventMetadata();
+		this._hasEventlessTransitions = Array.from(this.idMap.values()).some((stateNode) => !!stateNode.always?.length);
+		this.states = this.root.states;
+		this.events = this.root.events;
+	}
+	/**
+	* Clones this state machine with the provided sources.
+	*
+	* @param sources Options (`actions`, `guards`, `actors`, `delays`) to
+	*   recursively merge with the existing options.
+	* @returns A new `StateMachine` instance with the provided sources.
+	*/
+	provide(sources) {
+		const { actions, guards, actors, delays } = this.sources;
+		const provided = new StateMachine(this.config, {
+			actions: {
+				...actions,
+				...sources.actions
+			},
+			guards: {
+				...guards,
+				...sources.guards
+			},
+			actors: {
+				...actors,
+				...sources.actors
+			},
+			delays: {
+				...delays,
+				...sources.delays
+			}
+		}, this.validator);
+		provided._json = this._json;
+		provided.internalEventDescriptors = this.internalEventDescriptors;
+		provided._microstepHooks = this._microstepHooks;
+		return provided;
+	}
+	resolveState(config) {
+		const resolvedStateValue = resolveStateValue(this.root, config.value);
+		const nodeSet = getAllStateNodes(getStateNodes(this.root, resolvedStateValue));
+		const nodes = [...nodeSet];
+		return createMachineSnapshot({
+			_nodes: nodes,
+			value: resolvedStateValue,
+			context: config.context || {},
+			children: {},
+			status: isInFinalState(nodeSet, this.root) ? "done" : config.status || "active",
+			output: config.output,
+			error: config.error,
+			historyValue: config.historyValue
+		}, this);
+	}
+	/**
+	* Determines the next snapshot given the current `snapshot` and received
+	* `event`. Calculates a full macrostep from all microsteps.
+	*
+	* @param snapshot The current snapshot
+	* @param event The received event
+	*/
+	transition(snapshot, event, actorScope) {
+		const usesInertScope = !actorScope;
+		const resolvedActorScope = actorScope ?? createInertActorScope(this, snapshot);
+		if (usesInertScope) setInertActorScopeSnapshot(resolvedActorScope, snapshot, false);
+		if (this.validator) {
+			const sourceRef = actorScope && actorScope.self._lastSourceRef;
+			const eventOrigin = sourceRef ? "actor" : "external";
+			const error = this.validator.check({
+				kind: "event",
+				logic: this,
+				event,
+				eventOrigin
+			});
+			if (error) return [snapshot, [createDeadLetterEffect(resolvedActorScope, sourceRef, event, "invalidEvent", {
+				issues: error.issues,
+				error
+			})]];
+		}
+		beginSpawnAllocation(resolvedActorScope);
+		const fastSnapshot = this._transitionFast(snapshot, event, resolvedActorScope);
+		if (fastSnapshot) {
+			if (usesInertScope) setInertActorScopeSnapshot(resolvedActorScope, fastSnapshot, false);
+			const returnedSnapshot = usesInertScope && fastSnapshot !== snapshot ? attachSnapshotActorRef(resolvedActorScope, fastSnapshot) : this._attachPureActorRef(fastSnapshot, resolvedActorScope);
+			if (this.validator) assertValid(this.validator, {
+				kind: "result",
+				logic: this,
+				snapshot: returnedSnapshot,
+				effects: []
+			});
+			return [returnedSnapshot, []];
+		}
+		const { snapshot: nextSnapshot, microsteps } = macrostep(snapshot, event, resolvedActorScope, []);
+		if (usesInertScope) setInertActorScopeSnapshot(resolvedActorScope, nextSnapshot, false);
+		const returnedSnapshot = usesInertScope ? nextSnapshot === snapshot ? nextSnapshot : attachSnapshotActorRef(resolvedActorScope, nextSnapshot) : this._attachPureActorRef(nextSnapshot, resolvedActorScope);
+		const effects = this._collectEffects(microsteps);
+		if (this.validator) assertValid(this.validator, {
+			kind: "result",
+			logic: this,
+			snapshot: returnedSnapshot,
+			effects
+		});
+		return [returnedSnapshot, effects];
+	}
+	_collectEffects(microsteps) {
+		return microsteps.flatMap(([, actions]) => actions);
+	}
+	_attachPureActorRef(snapshot, actorScope, skipInitializingActor = false) {
+		if (isInertActorScope(actorScope)) return snapshot;
+		if (skipInitializingActor && actorScope.self._actorScope === actorScope && actorScope.self._snapshot === void 0) return snapshot;
+		setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
+		return snapshot;
+	}
+	_transitionFast(snapshot, event, actorScope) {
+		if (snapshot.status !== "active" || typeof snapshot.value !== "string" || this.root.always?.length) return;
+		const sourceNode = this.root.states[snapshot.value];
+		if (!sourceNode || sourceNode.type !== "atomic" || sourceNode.exit || sourceNode.invoke.length || sourceNode.always?.length || sourceNode.after?.length) return;
+		const transitions = sourceNode.transitions.get(event.type);
+		if (transitions?.length !== 1) return;
+		const selected = transitions[0];
+		if (!selected) return;
+		if (selected.guard || selected.actions || selected.to || selected.reenter || selected.input || typeof selected.context === "function" || selected.target && selected.target.length !== 1) return;
+		const targetNode = selected.target?.[0] ?? sourceNode;
+		const stateChanged = targetNode !== sourceNode;
+		if (targetNode.parent !== this.root || targetNode.type !== "atomic" || stateChanged && (targetNode.entry || targetNode.invoke.length || targetNode.always?.length || targetNode.after?.length)) return;
+		const context = selected.context !== void 0 ? {
+			...snapshot.context,
+			...selected.context
+		} : snapshot.context;
+		if (!isInertActorScope(actorScope) && (actorScope.system._hasInspectionObservers?.() ?? true)) {
+			const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+			collectedMicrosteps.push(selected);
+			actorScope.self._collectedMicrosteps = collectedMicrosteps;
+		}
+		return cloneMachineSnapshot(snapshot, {
+			...context !== snapshot.context ? { context } : {},
+			...stateChanged ? { _nodes: [this.root, targetNode] } : {}
+		});
+	}
+	/**
+	* Determines the next state given the current `state` and `event`. Calculates
+	* a microstep.
+	*
+	* @param state The current state
+	* @param event The received event
+	*/
+	microstep(snapshot, event, actorScope) {
+		const { microsteps } = macrostep(snapshot, event, actorScope, []);
+		const snapshots = new Array(microsteps.length);
+		for (const [i, microstep] of microsteps.entries()) snapshots[i] = microstep[0];
+		return snapshots;
+	}
+	getTransitionData(snapshot, event, actorScope, selectionResults) {
+		this._microstepHooks?.begin(actorScope.self);
+		return transitionNode(this.root, snapshot.value, snapshot, event, actorScope, selectionResults) || [];
+	}
+	isInternalEventType(eventType) {
+		if (eventType === "xstate.timer") return true;
+		for (const descriptor of this.internalEventDescriptors) if (matchesEventDescriptor(eventType, descriptor)) return true;
+		return false;
+	}
+	/**
+	* Determines whether sending the `event` to the given snapshot would select a
+	* non-forbidden transition. Backs `snapshot.can(...)`; lives here so that
+	* non-machine bundles don't pay for the transition-resolution machinery.
+	*
+	* @internal
+	*/
+	_canTransition(snapshot, event) {
+		const emptyActorScope = getEmptyCanActorScope();
+		const transitionData = this.getTransitionData(snapshot, event, emptyActorScope);
+		if (!transitionData?.length) return false;
+		for (const transition of transitionData) {
+			if (transition.target !== void 0) return true;
+			const res = getTransitionResult(transition, snapshot, event, emptyActorScope, { resolveActions: false });
+			if (res.targets?.length || res.context || hasEffect(transition, snapshot.context, event, snapshot, emptyActorScope)) return true;
+		}
+		return false;
+	}
+	/**
+	* Returns the error event that the actor should transition with to recover
+	* from an execution error, if any active state node declares `onError`.
+	*
+	* @internal
+	*/
+	getExecutionErrorEvent(snapshot, error) {
+		if (snapshot?.status !== "active" || !snapshot.nodes?.some((stateNode) => stateNode.config.onError)) return;
+		return createErrorPlatformEvent("execution", error);
+	}
+	/**
+	* The initial state _before_ evaluating any microsteps. This "pre-initial"
+	* state is provided to initial actions executed in the initial state.
+	*
+	* @internal
+	*/
+	_getPreInitialState(actorScope, initEvent) {
+		const { context } = this.config;
+		const preInitial = createMachineSnapshot({
+			context: typeof context !== "function" && context ? context : {},
+			_nodes: [this.root],
+			children: {},
+			status: "active"
+		}, this);
+		if (typeof context === "function") {
+			const children = {};
+			const spawn = createSpawner(actorScope, this.sources.actors, children);
+			const resolvedContext = context(withActorSelf({
+				spawn,
+				input: initEvent.input,
+				actors: this.sources.actors
+			}, actorScope));
+			const [nextState] = resolveActionsWithContext(preInitial, initEvent, actorScope, []);
+			if (resolvedContext) nextState.context = resolvedContext;
+			if (Object.keys(children).length > 0) {
+				nextState.children = {
+					...nextState.children,
+					...children
+				};
+				const counters = takeSpawnAllocationCounters(actorScope);
+				if (counters) nextState._nextActorIds = mergeActorIdCounters(nextState._nextActorIds, counters);
+			}
+			return nextState;
+		}
+		return preInitial;
+	}
+	/**
+	* Returns the initial `State` instance, with reference to `self` as an
+	* `ActorRef`.
+	*/
+	getInitialSnapshot(actorScope, input) {
+		return this.initialTransition(input, actorScope)[0];
+	}
+	initialTransition(input, actorScope) {
+		if (this.validator) assertValid(this.validator, {
+			kind: "input",
+			logic: this,
+			input
+		});
+		const usesInertScope = !actorScope;
+		const resolvedActorScope = actorScope ?? createInertActorScope(this);
+		beginSpawnAllocation(resolvedActorScope);
+		const initEvent = createInitEvent(input);
+		const internalQueue = [];
+		const finalizeInitialResult = (macroState, microsteps) => {
+			if (usesInertScope) setInertActorScopeSnapshot(resolvedActorScope, macroState, false);
+			const returnedSnapshot = usesInertScope ? attachSnapshotActorRef(resolvedActorScope, macroState) : this._attachPureActorRef(macroState, resolvedActorScope, true);
+			const effects = this._collectEffects(microsteps);
+			if (this.validator && macroState.status !== "error") assertValid(this.validator, {
+				kind: "result",
+				logic: this,
+				snapshot: returnedSnapshot,
+				effects
+			});
+			return [returnedSnapshot, effects];
+		};
+		let preInitialState;
+		try {
+			preInitialState = this._getPreInitialState(resolvedActorScope, initEvent);
+		} catch (error) {
+			return finalizeInitialResult(cloneMachineSnapshot(createMachineSnapshot({
+				context: typeof this.config.context !== "function" && this.config.context ? this.config.context : {},
+				_nodes: [this.root],
+				children: {},
+				status: "active"
+			}, this), {
+				status: "error",
+				error
+			}), []);
+		}
+		const contextSpawnEffects = Object.values(preInitialState.children).filter(Boolean).map((actor) => createSpawnEffect(actor));
+		try {
+			const [nextState, initialActions] = initialMicrostep(this.root, preInitialState, resolvedActorScope, initEvent, internalQueue);
+			const { snapshot: macroState, microsteps } = macrostep(nextState, initEvent, resolvedActorScope, internalQueue, [[nextState, [...contextSpawnEffects, ...initialActions]]]);
+			return finalizeInitialResult(macroState, microsteps);
+		} catch (err) {
+			if (!this.root.config.onError) throw err;
+			const errorEvent = createErrorPlatformEvent("execution", err);
+			const errorMacrostep = macrostep(preInitialState, errorEvent, resolvedActorScope, [], [[preInitialState, contextSpawnEffects]]);
+			return finalizeInitialResult(errorMacrostep.snapshot, errorMacrostep.microsteps);
+		}
+	}
+	start(snapshot, actorScope) {
+		if (!snapshot?.children) return;
+		const children = snapshot.children;
+		for (const child of Object.values(children)) if (child._rehydrated && child.getSnapshot?.().status === "active") {
+			if (actorScope) actorScope.actionExecutor(createStartEffect(child));
+			else child.system.startActor(child);
+		}
+	}
+	getStateNodeById(stateId) {
+		const fullPath = toStatePath(stateId);
+		const relativePath = fullPath.slice(1);
+		const firstSegment = fullPath[0];
+		if (firstSegment === void 0) throw new Error(`Invalid state ID '${stateId}'`);
+		const resolvedStateId = isStateId(firstSegment) ? firstSegment.slice(1) : firstSegment;
+		const stateNode = this.idMap.get(resolvedStateId);
+		if (!stateNode) throw new Error(`Child state node '#${resolvedStateId}' does not exist on machine '${this.id}'`);
+		return getStateNodeByPath(stateNode, relativePath);
+	}
+	getPersistedSnapshot(snapshot, options, warn) {
+		return getPersistedSnapshot(snapshot, options, warn);
+	}
+	/**
+	* The original JSON definition this machine was created from (set by
+	* `createMachineFromConfig`), if any. Used by `serializeMachine` for lossless
+	* round-trips.
+	*
+	* @internal
+	*/
+	_json;
+	/**
+	* @internal Builds a machine-shaped `'error'` snapshot (root configuration,
+	* no children) for a persisted snapshot that failed to restore, so
+	* consumers keep `matches()`, `can()` and friends.
+	*/
+	_createRestoreErrorSnapshot(persisted, error) {
+		const context = persisted?.context;
+		return cloneMachineSnapshot(createMachineSnapshot({
+			context: context && typeof context === "object" ? context : {},
+			_nodes: [this.root],
+			children: {},
+			status: "active"
+		}, this), {
+			status: "error",
+			error
+		});
+	}
+	restoreSnapshot(snapshot, actorScope) {
+		const usesInertScope = !actorScope;
+		const resolvedActorScope = actorScope ?? createInertActorScope(this);
+		const snapshotMachine = snapshot.machine;
+		const persistedMachine = snapshotMachine && typeof snapshotMachine === "object" && typeof snapshotMachine.transition === "function" && "root" in snapshotMachine ? void 0 : snapshotMachine;
+		const legacyPersistedVersion = snapshot.version;
+		const persistedVersion = typeof persistedMachine?.version === "string" ? persistedMachine.version : legacyPersistedVersion;
+		if (legacyPersistedVersion !== void 0 && persistedMachine?.version !== void 0 && persistedMachine.version !== legacyPersistedVersion) throw new Error(`Persisted snapshot version '${legacyPersistedVersion}' conflicts with machine version '${persistedMachine.version}'.`);
+		if (persistedMachine && typeof persistedMachine.id === "string" && persistedMachine.id !== this.id) throw new Error(`Machine ID mismatch: persisted snapshot machine '${persistedMachine.id}' does not match '${this.id}'.`);
+		if (persistedVersion !== this.version) {
+			const migrate = this.config.migrate;
+			if (typeof migrate !== "function") throw new Error(`Persisted snapshot version '${persistedVersion}' does not match machine version '${this.version}'.`);
+			snapshot = migrate(snapshot, persistedVersion);
+		}
+		const snapshotData = snapshot;
+		const children = {};
+		const snapshotChildren = snapshotData.children;
+		for (const [actorId, actorData] of Object.entries(snapshotChildren)) {
+			if (actorData.remote === true && actorData.address !== void 0) {
+				if (typeof actorData.src !== "string") throw new Error(`Unable to restore remote child '${actorId}': a child referenced by address requires a registered source key.`);
+				const handle = createRemoteActorRef(resolvedActorScope.system, {
+					id: actorId,
+					address: actorData.address,
+					src: actorData.src,
+					parent: resolvedActorScope.self,
+					registryKey: actorData.registryKey,
+					syncSnapshot: actorData.syncSnapshot,
+					incarnation: actorData.incarnation
+				});
+				if (actorData.registryKey) resolvedActorScope.system._set(actorData.registryKey, handle);
+				children[actorId] = handle;
+				continue;
+			}
+			const childState = actorData.snapshot;
+			const src = actorData.src;
+			const logic = typeof src === "string" ? resolveReferencedActor(this, src) : src;
+			if (!logic) throw new Error(`Unable to restore child actor '${actorId}': child source '${typeof src === "string" ? src : "<unknown>"}' is not provided in machine '${this.id}'.`);
+			const actor = resolvedActorScope.system.createActorRef(logic, {
+				id: actorId,
+				parent: resolvedActorScope.self,
+				...actorData.syncSnapshot !== void 0 && { syncSnapshot: actorData.syncSnapshot },
+				...childState !== void 0 && { snapshot: childState },
+				src,
+				...actorData.registryKey !== void 0 && { registryKey: actorData.registryKey }
+			});
+			actor._rehydrated = true;
+			children[actorId] = actor;
+		}
+		const timers = {};
+		const persistedTimers = snapshotData.timers ?? {};
+		for (const [id, timer] of Object.entries(persistedTimers)) {
+			let event = timer.event;
+			if (event.type === "xstate.timeout.actor") {
+				const actorId = event["actorId"];
+				const child = children[actorId];
+				if (child) event = createInvokeTimeoutEvent(actorId, child.sessionId);
+			}
+			const target = typeof timer.target === "string" ? timer.target === "self" ? "self" : children[timer.target] : resolvedActorScope.self._parent;
+			if (!target) {
+				const targetDescription = typeof timer.target === "string" ? timer.target : timer.target.type;
+				throw new Error(`Unable to restore timer '${id}': target actor '${targetDescription}' is unavailable.`);
+			}
+			timers[id] = {
+				...timer,
+				event,
+				target
+			};
+		}
+		const reviveHistoryValue = (historyValue) => {
+			if (!historyValue || typeof historyValue !== "object") return {};
+			const revived = {};
+			for (const [key, arr] of Object.entries(historyValue)) for (const item of arr) {
+				let resolved;
+				if (item instanceof StateNode) resolved = item;
+				else try {
+					resolved = this.root.machine.getStateNodeById(item.id);
+				} catch {}
+				if (!resolved) continue;
+				revived[key] ??= [];
+				revived[key].push(resolved);
+			}
+			return revived;
+		};
+		const revivedHistoryValue = reviveHistoryValue(snapshotData.historyValue);
+		const validateStateValue = (stateValue, node, path) => {
+			const missingStateError = (statePath) => /* @__PURE__ */ new Error(`Persisted snapshot references state '${statePath.join(".")}' which does not exist on machine '${this.id}'.`);
+			if (typeof stateValue === "string") {
+				if (!node.states[stateValue]) throw missingStateError(path.concat(stateValue));
+				return;
+			}
+			if (!stateValue || typeof stateValue !== "object") return;
+			for (const key of Object.keys(stateValue)) {
+				const childNode = node.states[key];
+				if (!childNode) throw missingStateError(path.concat(key));
+				validateStateValue(stateValue[key], childNode, path.concat(key));
+			}
+		};
+		validateStateValue(snapshotData.value, this.root, []);
+		const nodes = Array.from(getAllStateNodes(getStateNodes(this.root, snapshotData.value)));
+		const { version: _persistedSnapshotVersion, _nextActorId: _legacyNextActorId, ...persistedRest } = snapshot;
+		let restoredCounters = persistedRest._nextActorIds;
+		for (const childId of Object.keys(snapshotChildren)) {
+			const generated = parseGeneratedActorId(childId);
+			if (generated && (restoredCounters?.[generated.prefix] ?? 0) <= generated.index) restoredCounters = {
+				...restoredCounters,
+				[generated.prefix]: generated.index + 1
+			};
+		}
+		const restoredSnapshot = createMachineSnapshot({
+			...persistedRest,
+			children,
+			timers,
+			_nextActorIds: restoredCounters,
+			_nodes: nodes,
+			value: snapshotData.value,
+			historyValue: revivedHistoryValue,
+			_stateInputs: snapshotData.stateInputs ?? {}
+		}, this, resolvedActorScope.self);
+		const seen = /* @__PURE__ */ new WeakSet();
+		function reviveContext(contextPart) {
+			if (seen.has(contextPart)) return;
+			seen.add(contextPart);
+			for (const key of Object.keys(contextPart)) {
+				const value = contextPart[key];
+				if (value && typeof value === "object") {
+					if ("xstate$type" in value && value.xstate$type === "actorRef") {
+						contextPart[key] = children[value.id];
+						continue;
+					}
+					reviveContext(value);
+				}
+			}
+		}
+		reviveContext(restoredSnapshot.context);
+		if (usesInertScope) {
+			setInertActorScopeSnapshot(resolvedActorScope, restoredSnapshot, false);
+			return attachSnapshotActorRef(resolvedActorScope, restoredSnapshot);
+		}
+		return this._attachPureActorRef(restoredSnapshot, resolvedActorScope);
+	}
+};
+// src/createMachine.ts
+function createMachine(config) {
+	return new StateMachine(config);
+}
+/**
+* Builds a machine from a config produced by a compiler (JSON, SCXML) without
+* running the author-config v5 diagnostics.
+*
+* @experimental Used by `@xstate/scxml`; not part of the stable API.
+*/
+function createMachineFromCompiledConfig(config) {
+	return new StateMachine(config);
+}
+/** @public */
+function createStateConfig(config) {
+	return config;
+}
+// src/createMachineFromConfig.ts
+function delayToMs(delay) {
+	const parsedDelay = parseDelayToMilliseconds(delay);
+	if (parsedDelay !== void 0) return parsedDelay;
+	return typeof delay === "string" ? parseFloat(delay) || 0 : delay;
+}
+function isExpression(value) {
+	return !!value && typeof value === "object" && typeof value["@expr"] === "string";
+}
+function isCode(value) {
+	return !!value && typeof value === "object" && typeof value["@code"] === "string";
+}
+function isResolvable(value) {
+	return isExpression(value) || isCode(value);
+}
+function isBuiltInActionType(type) {
+	return type.startsWith("@xstate.");
+}
+function toPath(parent, key) {
+	return typeof key === "number" ? `${parent}[${key}]` : `${parent}.${key}`;
+}
+function extractSerializableDelays(delays) {
+	const result = {};
+	if (!delays) return result;
+	for (const key of Object.keys(delays)) {
+		const value = delays[key];
+		if (typeof value === "number") result[key] = value;
+		else if (value && typeof value === "object" && typeof value.duration === "number") result[key] = value.duration;
+	}
+	return result;
+}
+function mergeSources(json, sources) {
+	return {
+		actions: sources.actions ?? {},
+		guards: sources.guards ?? {},
+		actors: sources.actors ?? {},
+		delays: {
+			...extractSerializableDelays(json.delays),
+			...sources.delays ?? {}
+		},
+		evaluators: sources.evaluators ?? {}
+	};
+}
+function createExpressionResolver(expressionLanguage, sources) {
+	function getEvaluator(value, path) {
+		const lang = value["@lang"] ?? expressionLanguage;
+		if (!lang) throw new Error(`Missing @exprLang for expression at ${path}`);
+		const evaluator = sources.evaluators[lang];
+		if (!evaluator) throw new Error(`Missing evaluator for @lang '${lang}' at ${path}`);
+		return evaluator;
+	}
+	function evaluateResolvable(value, slot, scope, path) {
+		const kind = isExpression(value) ? "expr" : "code";
+		const source = isExpression(value) ? value["@expr"] : value["@code"];
+		return getEvaluator(value, path)({
+			source,
+			kind,
+			slot,
+			scope,
+			path
+		});
+	}
+	function resolveValue(value, slot, scope, path) {
+		if (isResolvable(value)) return evaluateResolvable(value, slot, scope, path);
+		if (Array.isArray(value)) return value.map((item, index) => resolveValue(item, slot, scope, toPath(path, index)));
+		if (!value || typeof value !== "object") return value;
+		const result = {};
+		for (const key of Object.keys(value)) result[key] = resolveValue(value[key], slot, scope, toPath(path, key));
+		return result;
+	}
+	function makeScope(x, extra) {
+		return {
+			context: x.context,
+			event: x.event,
+			input: x.input,
+			self: x.self,
+			children: x.children,
+			params: x.params,
+			...extra
+		};
+	}
+	function getDurationConfig(value, path) {
+		if (!isResolvable(value)) return value;
+		return (args) => delayToMs(resolveValue(value, "delay", makeScope(args), path));
+	}
+	function assertResolvable(value, path) {
+		if (isResolvable(value)) {
+			getEvaluator(value, path);
+			return;
+		}
+		if (Array.isArray(value)) {
+			value.forEach((item, index) => assertResolvable(item, toPath(path, index)));
+			return;
+		}
+		if (!value || typeof value !== "object") return;
+		for (const key of Object.keys(value)) assertResolvable(value[key], toPath(path, key));
+	}
+	return {
+		evaluateResolvable,
+		resolveValue,
+		makeScope,
+		getDurationConfig,
+		assertResolvable
+	};
+}
+function toActionArray(actions) {
+	return actions === void 0 ? [] : Array.isArray(actions) ? actions : [actions];
+}
+function validateChoiceConfig(choice, path) {
+	if (!Array.isArray(choice)) return;
+	choice.forEach((branch, index) => {
+		if (branch.when === void 0 && index !== choice.length - 1) throw new Error(`Choice fallback branch at ${path}[${index}] must be last.`);
+	});
+}
+function assertMachineJSON(json, resolvedSources, expressionResolver) {
+	const { assertResolvable } = expressionResolver;
+	function assertCondition(condition, path) {
+		if (!condition) return;
+		if (isResolvable(condition)) {
+			assertResolvable(condition, path);
+			return;
+		}
+		assertResolvable(condition.params, `${path}.params`);
+		const guard = json.guards?.[condition.type];
+		if (guard) {
+			assertCondition(guard.when, `$.guards.${condition.type}.when`);
+			return;
+		}
+		if (!resolvedSources.guards[condition.type] && !["xstate.stateIn", "xstate.not"].includes(condition.type)) throw new Error(`Missing guard source "${condition.type}"`);
+	}
+	function assertAction(action, path, stack = []) {
+		if (isResolvable(action)) {
+			assertResolvable(action, path);
+			return;
+		}
+		if (!action || typeof action.type !== "string") throw new Error(`Invalid action at ${path}`);
+		assertResolvable(action.params, `${path}.params`);
+		if (isBuiltInActionType(action.type)) {
+			assertResolvable(action, path);
+			return;
+		}
+		const definition = json.actions?.[action.type];
+		if (definition) {
+			if (stack.includes(action.type)) throw new Error(`Circular action reference: ${stack.concat(action.type).join(" -> ")}`);
+			const definitions = Array.isArray(definition) ? definition : [definition];
+			definitions.forEach((item, index) => assertAction(item, `${path}.actions.${action.type}${definitions.length > 1 ? `[${index}]` : ""}`, stack.concat(action.type)));
+			return;
+		}
+		if (!resolvedSources.actions[action.type]) throw new Error(`Missing action source "${action.type}"`);
+	}
+	function assertActions(actions, path) {
+		toActionArray(actions).forEach((action, index) => assertAction(action, `${path}[${index}]`));
+	}
+	function assertTransition(transition, path) {
+		(Array.isArray(transition) ? transition : transition ? [transition] : []).forEach((t, index) => {
+			const transitionPath = Array.isArray(transition) ? `${path}[${index}]` : path;
+			if (isResolvable(t)) {
+				assertResolvable(t, transitionPath);
+				return;
+			}
+			assertCondition(t.guard, `${transitionPath}.guard`);
+			assertActions(t.actions, `${transitionPath}.actions`);
+			assertResolvable(t.context, `${transitionPath}.context`);
+			assertResolvable(t.input, `${transitionPath}.input`);
+		});
+	}
+	function assertStateNode(node, path) {
+		if ((node.type === "history" || node.history !== void 0) && !(typeof node.target === "string" && node.target.trim().length > 0 || Array.isArray(node.target) && node.target.length > 0 && node.target.every((target) => target.trim().length > 0))) throw new Error(`History state at ${path} must declare a non-empty target.`);
+		assertResolvable(node.context, `${path}.context`);
+		assertResolvable(node.input, `${path}.input`);
+		assertResolvable(node.output, `${path}.output`);
+		assertResolvable(node.timeout, `${path}.timeout`);
+		assertActions(node.entry, `${path}.entry`);
+		assertActions(node.exit, `${path}.exit`);
+		if (node.type === "choice") {
+			if (!node.choice) throw new Error(`Choice state at ${path} must declare choice.`);
+			if (Array.isArray(node.choice)) {
+				validateChoiceConfig(node.choice, `${path}.choice`);
+				node.choice.forEach((branch, index) => {
+					assertCondition(branch.when, `${path}.choice[${index}].when`);
+					assertResolvable(branch.context, `${path}.choice[${index}].context`);
+					assertResolvable(branch.input, `${path}.choice[${index}].input`);
+				});
+			} else assertResolvable(node.choice, `${path}.choice`);
+		}
+		if (isResolvable(node.route)) assertResolvable(node.route, `${path}.route`);
+		if (node.invoke) (Array.isArray(node.invoke) ? node.invoke : [node.invoke]).forEach((invoke, index) => {
+			const invokePath = `${path}.invoke${Array.isArray(node.invoke) ? `[${index}]` : ""}`;
+			if (!resolvedSources.actors[invoke.src]) throw new Error(`Missing actor source "${invoke.src}"`);
+			assertResolvable(invoke.input, `${invokePath}.input`);
+			assertResolvable(invoke.timeout, `${invokePath}.timeout`);
+			assertTransition(invoke.onDone, `${invokePath}.onDone`);
+			assertTransition(invoke.onError, `${invokePath}.onError`);
+			assertTransition(invoke.onSnapshot, `${invokePath}.onSnapshot`);
+			assertTransition(invoke.onTimeout, `${invokePath}.onTimeout`);
+		});
+		if (node.on) for (const descriptor of Object.keys(node.on)) assertTransition(node.on[descriptor], `${path}.on.${descriptor}`);
+		if (node.after) for (const delay of Object.keys(node.after)) {
+			if (Number.isNaN(Number(delay)) && parseDelayToMilliseconds(delay) === void 0 && !json.delays?.[delay] && !resolvedSources.delays[delay]) throw new Error(`Missing delay source "${delay}"`);
+			assertTransition(node.after[delay], `${path}.after.${delay}`);
+		}
+		assertTransition(node.always, `${path}.always`);
+		assertTransition(node.onError, `${path}.onError`);
+		assertTransition(node.onTimeout, `${path}.onTimeout`);
+		if (node.states) for (const [key, state] of Object.entries(node.states)) assertStateNode(state, `${path}.states.${key}`);
+	}
+	if (json.actions) for (const key of Object.keys(json.actions)) {
+		const entry = json.actions[key];
+		if (entry === void 0) continue;
+		const actions = Array.isArray(entry) ? entry : [entry];
+		actions.forEach((action, index) => assertAction(action, `$.actions.${key}${actions.length > 1 ? `[${index}]` : ""}`, [key]));
+	}
+	if (json.guards) for (const [key, guard] of Object.entries(json.guards)) assertCondition(guard.when, `$.guards.${key}.when`);
+	if (json.delays) for (const key of Object.keys(json.delays)) {
+		const delay = json.delays[key];
+		assertResolvable(delay && typeof delay === "object" && "duration" in delay ? delay.duration : delay, `$.delays.${key}`);
+	}
+	assertStateNode(json, "$");
+}
+/** @public */
+function createMachineFromConfig(json, sources = {}) {
+	const resolvedSources = mergeSources(json, sources);
+	const expressionResolver = createExpressionResolver(json["@exprLang"], resolvedSources);
+	const { evaluateResolvable, resolveValue, makeScope, getDurationConfig } = expressionResolver;
+	function resolveCondition(condition, slot, path) {
+		if (!condition) return void 0;
+		if (isResolvable(condition)) return (args) => !!evaluateResolvable(condition, slot, makeScope(args), path);
+		return (args) => {
+			const params = resolveValue(condition.params, slot, makeScope(args), `${path}.params`);
+			const declarativeGuard = json.guards?.[condition.type];
+			if (declarativeGuard) return !!resolveCondition(declarativeGuard.when, "guard", `$.guards.${condition.type}.when`)?.({
+				...args,
+				params
+			});
+			const guardImpl = args.guards?.[condition.type];
+			if (!guardImpl) throw new Error(getMissingGuardMessage(condition.type, args.guards ?? {}));
+			return guardImpl(args, params);
+		};
+	}
+	function getMissingGuardMessage(type, guards) {
+		return `Guard '${type}' is not implemented in machine '${json.id ?? "(machine)"}'. Available guards: ${Object.keys(guards).map((key) => `'${key}'`).join(", ") || "(none)"}.`;
+	}
+	function makeChoiceConfig(choice, path) {
+		if (!choice) return void 0;
+		if (isResolvable(choice)) return (args) => evaluateResolvable(choice, "choice", makeScope(args), path);
+		validateChoiceConfig(choice, path);
+		return (args) => {
+			for (let index = 0; index < choice.length; index++) {
+				const branch = choice[index];
+				if (!branch) continue;
+				const guard = resolveCondition(branch.when, "choice", `${path}[${index}].when`);
+				if (!guard || guard(args)) return {
+					target: branch.target,
+					context: branch.context ? resolveValue(branch.context, "transitionContext", makeScope(args), `${path}[${index}].context`) : void 0,
+					input: branch.input !== void 0 ? resolveValue(branch.input, "input", makeScope(args), `${path}[${index}].input`) : void 0,
+					description: branch.description,
+					reenter: branch.reenter,
+					meta: branch.meta
+				};
+			}
+			throw new Error(`Choice state at ${path} did not match any branch.`);
+		};
+	}
+	function resolveRouteConfig(route, path) {
+		if (!route || typeof route === "function") return route;
+		if (isResolvable(route)) return (args) => evaluateResolvable(route, "transition", makeScope(args), path);
+		const { guard, ...routeConfig } = route;
+		if (!guard) return routeConfig;
+		const resolvedGuard = resolveCondition({ type: guard }, "guard", path);
+		return (args) => resolvedGuard(args) ? routeConfig : void 0;
+	}
+	function executeActions(actions, x, enq, stack = []) {
+		let context;
+		for (const action of actions) {
+			if (isResolvable(action)) {
+				const result = evaluateResolvable(action, "action", makeScope(x, {
+					params: x.params,
+					enq
+				}), "$.actions");
+				if (result && typeof result === "object" && "context" in result && result.context) {
+					context ??= {};
+					Object.assign(context, result.context);
+				}
+				continue;
+			}
+			if (isBuiltInActionJSON(action)) {
+				switch (action.type) {
+					case "@xstate.raise":
+						enq.raise(resolveValue(action.event, "actionParams", makeScope(x, { params: x.params }), "$.actions.event"), {
+							id: action.id,
+							delay: action.delay
+						});
+						break;
+					case "@xstate.cancel":
+						enq.cancel(action.id);
+						break;
+					case "@xstate.log":
+						enq.log(...action.args);
+						break;
+					case "@xstate.emit":
+						enq.emit(resolveValue(action.event, "actionParams", makeScope(x, { params: x.params }), "$.actions.event"));
+						break;
+					case "@xstate.assign":
+						context ??= {};
+						Object.assign(context, resolveValue(action.context, "transitionContext", makeScope(x, { params: x.params }), "$.actions.context"));
+				}
+				continue;
+			}
+			const params = resolveValue(action.params, "actionParams", makeScope(x, { params: x.params }), "$.actions.params");
+			const definition = json.actions?.[action.type];
+			if (!definition) {
+				enq(x.actions[action.type], params);
+				continue;
+			}
+			if (stack.includes(action.type)) throw new Error(`Circular action reference: ${stack.concat(action.type).join(" -> ")}`);
+			const result = executeActions(Array.isArray(definition) ? definition : [definition], {
+				...x,
+				context: {
+					...x.context,
+					...context
+				},
+				params
+			}, enq, stack.concat(action.type));
+			if (result.context) context = result.context;
+		}
+		return { context: context ? {
+			...x.context,
+			...context
+		} : void 0 };
+	}
+	function iterActions(actions) {
+		const actionArray = toActionArray(actions);
+		return ((x, enq) => executeActions(actionArray, x, enq));
+	}
+	function getTransitionConfig(transition) {
+		const transitions = Array.isArray(transition) ? transition : [transition];
+		return transitions.map((item, index) => {
+			if (isResolvable(item)) return (x, enq) => evaluateResolvable(item, "transition", makeScope(x, { enq }), `$.transition${transitions.length > 1 ? `[${index}]` : ""}`);
+			const context = item.context ? (x) => resolveValue(item.context, "transitionContext", makeScope(x), "$.transition.context") : void 0;
+			const input = item.input !== void 0 ? (x) => resolveValue(item.input, "input", makeScope(x), "$.transition.input") : void 0;
+			const dynamic = !!context || !!item.actions?.length;
+			return {
+				matches: item.matches,
+				target: dynamic ? void 0 : item.target,
+				to: dynamic ? (x, enq) => {
+					const resolvedContext = context?.(x);
+					const result = item.actions?.length ? executeActions(item.actions, resolvedContext ? {
+						...x,
+						context: {
+							...x.context,
+							...resolvedContext
+						}
+					} : x, enq) : void 0;
+					return {
+						target: item.target,
+						context: result?.context ?? resolvedContext,
+						reenter: item.reenter
+					};
+				} : void 0,
+				guard: resolveCondition(item.guard, "guard", "$.transition.guard"),
+				description: item.description,
+				reenter: item.reenter,
+				meta: item.meta,
+				input
+			};
+		});
+	}
+	function iterInvokeConfigs(invokes) {
+		return (Array.isArray(invokes) ? invokes : [invokes]).map((inv) => ({
+			src: inv.src,
+			id: inv.id,
+			registryKey: inv.registryKey,
+			input: inv.input !== void 0 ? (args) => resolveValue(inv.input, "input", makeScope(args), "$.invoke.input") : void 0,
+			onDone: inv.onDone ? getTransitionConfig(inv.onDone) : void 0,
+			onError: inv.onError ? getTransitionConfig(inv.onError) : void 0,
+			onSnapshot: inv.onSnapshot ? getTransitionConfig(inv.onSnapshot) : void 0,
+			timeout: getDurationConfig(inv.timeout, "$.invoke.timeout"),
+			onTimeout: inv.onTimeout ? getTransitionConfig(inv.onTimeout) : void 0
+		}));
+	}
+	function iterNode(node, nodeKey) {
+		return {
+			id: node.id,
+			initial: node.initial,
+			type: node.type,
+			history: node.history,
+			target: node.target,
+			description: node.description,
+			tags: node.tags,
+			input: node.input,
+			timeout: getDurationConfig(node.timeout, `$.states.${nodeKey}.timeout`),
+			states: node.states ? Object.fromEntries(Object.entries(node.states).map(([key, value]) => [key, iterNode(value, key)])) : void 0,
+			on: node.on ? Object.fromEntries(Object.entries(node.on).map(([key, value]) => [key, getTransitionConfig(value)])) : void 0,
+			always: node.always ? getTransitionConfig(node.always) : void 0,
+			onError: node.onError ? getTransitionConfig(node.onError) : void 0,
+			choice: makeChoiceConfig(node.choice, `$.states.${nodeKey}.choice`),
+			route: resolveRouteConfig(node.route, `$.states.${nodeKey}.route`),
+			after: node.after ? Object.fromEntries(Object.entries(node.after).map(([key, value]) => [key, getTransitionConfig(value)])) : void 0,
+			onTimeout: node.onTimeout ? getTransitionConfig(node.onTimeout) : void 0,
+			entry: node.entry ? iterActions(node.entry) : void 0,
+			exit: node.exit ? iterActions(node.exit) : void 0,
+			invoke: node.invoke ? iterInvokeConfigs(node.invoke) : void 0,
+			meta: node.meta,
+			output: isResolvable(node.output) ? ({ context, event, self }) => evaluateResolvable(node.output, "output", {
+				context,
+				event,
+				self
+			}, `$.states.${nodeKey}.output`) : node.output
+		};
+	}
+	if (json.delays) {
+		for (const [key, delay] of Object.entries(json.delays)) if (typeof delay === "number") resolvedSources.delays[key] = delay;
+		else if (typeof delay === "string") resolvedSources.delays[key] = delayToMs(delay);
+		else if (delay && typeof delay === "object") resolvedSources.delays[key] = (args) => delayToMs(resolveValue(delay.duration, "delay", makeScope(args), `$.delays.${key}.duration`));
+	}
+	assertMachineJSON(json, resolvedSources, expressionResolver);
+	const contextConfig = json.context ? { context: (args) => resolveValue(json.context, "context", args, "$.context") } : {};
+	const machine = createMachineFromCompiledConfig({
+		...iterNode(json),
+		...contextConfig,
+		version: json.version
+	});
+	if (json.internalEvents?.length) machine.internalEventDescriptors = [...machine.internalEventDescriptors, ...json.internalEvents];
+	const provided = machine.provide({
+		actions: resolvedSources.actions,
+		actors: resolvedSources.actors,
+		guards: {
+			"xstate.stateIn": (args, params) => {
+				const stateId = params?.stateId;
+				const snapshot = args._snapshot;
+				return !!stateId && !!snapshot?.nodes?.some((node) => node.id === stateId.replace(/^#/, ""));
+			},
+			"xstate.not": (args, params) => {
+				const inner = params?.guard;
+				const impl = inner && args.guards?.[inner.type];
+				if (!impl) throw new Error(`Guard '${inner?.type}' referenced by 'xstate.not' is not implemented.`);
+				return !impl(args, inner.params);
+			},
+			...resolvedSources.guards
+		},
+		delays: resolvedSources.delays
+	});
+	provided._json = json;
+	return provided;
+}
+function isBuiltInActionJSON(action) {
+	return !isResolvable(action) && action.type.startsWith("@xstate.");
+}
+// src/machineVersions.ts
+function isObject(value) {
+	return value !== null && typeof value === "object";
+}
+function isVersionedStateMachine(entry) {
+	return "transition" in entry && typeof entry.transition === "function";
+}
+function hasSnapshotSchema(entry) {
+	return "snapshotSchema" in entry && entry.snapshotSchema !== void 0;
+}
+function hasEventSchema(entry) {
+	return "eventSchema" in entry && entry.eventSchema !== void 0;
+}
+function getSnapshotSource(raw, defaultId) {
+	if (!isObject(raw)) return {};
+	if (isObject(raw["machine"])) return {
+		id: typeof raw["machine"]["id"] === "string" ? raw["machine"]["id"] : void 0,
+		version: typeof raw["machine"]["version"] === "string" ? raw["machine"]["version"] : void 0
+	};
+	return {
+		id: typeof raw["version"] === "string" ? defaultId : void 0,
+		version: typeof raw["version"] === "string" ? raw["version"] : void 0
+	};
+}
+async function validate(schema, value, description) {
+	if (!schema) return value;
+	const result = await schema["~standard"].validate(value);
+	if (result.issues) throw new Error(`Invalid ${description}: ${result.issues[0]?.message}`);
+	return result.value;
+}
+async function finalizeSnapshot(snapshot, target) {
+	return await validate(target.snapshotSchema, {
+		...snapshot,
+		machine: {
+			id: target.id,
+			version: target.version
+		},
+		version: target.version
+	}, `snapshot for machine '${target.id}' version '${target.version}'`);
+}
+async function validateEvents(events, source) {
+	return Promise.all(events.map(async (event, index) => {
+		const result = await source.eventSchema["~standard"].validate(event);
+		if (result.issues) {
+			const message = result.issues[0]?.message;
+			if (message?.startsWith("Unknown event ")) throw new Error(message);
+			const type = isObject(event) ? event["type"] : void 0;
+			throw new Error(typeof type === "string" ? `Invalid event '${type}' at index ${index}${message ? `: ${message}` : "."}` : `Invalid event at index ${index}${message ? `: ${message}` : "."}`);
+		}
+		const validated = result.value;
+		if (!isObject(validated) || typeof validated.type !== "string") throw new Error(`Invalid event at index ${index}.`);
+		return validated;
+	}));
+}
+/**
+* Creates migration and adaptation utilities for versions of one machine.
+*
+* @public
+*/
+function machineVersions(entries, options) {
+	const byIdentity = /* @__PURE__ */ new Map();
+	const machinesByIdentity = /* @__PURE__ */ new Map();
+	const machineId = entries[0].id;
+	for (const entry of entries) {
+		if (entry.version === void 0) throw new Error(`Machine '${entry.id}' must define a version.`);
+		if (entry.version === "*") throw new Error("Machine version '*' is reserved for wildcard migrations.");
+		if (entry.id !== machineId) throw new Error(`Machine '${entry.id}' does not match machine ID '${machineId}'.`);
+		const key = `${entry.id}\0${entry.version}`;
+		if (byIdentity.has(key)) throw new Error(`Duplicate machine identity '${entry.id}' version '${entry.version}'.`);
+		byIdentity.set(key, entry);
+		if (isVersionedStateMachine(entry)) machinesByIdentity.set(key, entry);
+	}
+	if (options?.unversioned !== void 0 && !byIdentity.has(`${machineId}\0${options.unversioned}`)) throw new Error(`Unversioned snapshot version '${options.unversioned}' is not retained for machine '${machineId}'.`);
+	const parseSnapshot = async (raw) => {
+		if (!isObject(raw)) throw new Error("Persisted snapshot is missing machine identity.");
+		let id;
+		let version;
+		if (isObject(raw["machine"])) {
+			({id, version} = raw["machine"]);
+			if (typeof id !== "string" || typeof version !== "string") throw new Error("Persisted snapshot has an invalid machine identity.");
+		} else if (typeof raw["version"] === "string") {
+			id = machineId;
+			version = raw["version"];
+		} else if (raw["version"] === void 0 && options?.unversioned !== void 0) {
+			id = machineId;
+			version = options.unversioned;
+		} else throw new Error("Persisted snapshot is missing machine identity.");
+		if (raw["version"] !== void 0 && typeof raw["version"] !== "string") throw new Error("Persisted snapshot has an invalid version.");
+		if (raw["version"] !== void 0 && raw["version"] !== version) throw new Error(`Persisted snapshot version '${raw["version"]}' conflicts with machine version '${version}'.`);
+		const source = byIdentity.get(`${id}\0${version}`);
+		if (!source) throw new Error(`Unknown machine identity '${id}' version '${version}'.`);
+		if (!hasSnapshotSchema(source)) throw new Error(`Machine version '${version}' does not define a snapshot schema.`);
+		const snapshot = await validate(source.snapshotSchema, raw, `snapshot for machine '${id}' version '${version}'`);
+		return {
+			source,
+			...isVersionedStateMachine(source) && { machine: source },
+			snapshot: {
+				...snapshot,
+				machine: {
+					id,
+					version
+				}
+			}
+		};
+	};
+	return {
+		parseSnapshot,
+		async adaptEvents(events, adaptationOptions) {
+			const target = machinesByIdentity.get(`${machineId}\0${adaptationOptions.to}`);
+			if (!target) throw new Error(`Target version '${adaptationOptions.to}' is not backed by a machine for '${machineId}'.`);
+			const sourceId = adaptationOptions.from.id ?? machineId;
+			const source = byIdentity.get(`${sourceId}\0${adaptationOptions.from.version}`);
+			let sourceError;
+			let sourceValidationFailed = false;
+			const hasTypedSource = source && hasEventSchema(source);
+			if (hasTypedSource) {
+				let sourceEvents;
+				try {
+					sourceEvents = await validateEvents(events, source);
+				} catch (error) {
+					sourceError = error;
+					sourceValidationFailed = true;
+				}
+				if (sourceEvents) {
+					if (source === target) return sourceEvents;
+					const adapter = adaptationOptions.adapters[source.version];
+					if (adapter) return validateEvents(await adapter(sourceEvents), target);
+				}
+			}
+			const wildcardAdapter = adaptationOptions.adapters["*"];
+			if (wildcardAdapter) return validateEvents(await wildcardAdapter(events, adaptationOptions.from), target);
+			if (hasTypedSource) {
+				if (sourceValidationFailed) throw sourceError instanceof Error ? sourceError : new Error(`Unable to validate event history for machine '${source.id}' version '${source.version}'.`, { cause: sourceError });
+				throw new Error(`No event adapter from version '${source.version}' to '${target.version}' for machine '${target.id}'.`);
+			}
+			if (source) throw new Error(`Machine version '${source.version}' does not define an event schema; only the '*' adapter can handle its event history.`);
+			throw new Error(`Unknown event history source '${sourceId}' version '${adaptationOptions.from.version}'.`);
+		},
+		async migrateSnapshot(raw, migrationOptions) {
+			const target = machinesByIdentity.get(`${machineId}\0${migrationOptions.to}`);
+			if (!target) throw new Error(`Target version '${migrationOptions.to}' is not backed by a machine for '${machineId}'.`);
+			let source;
+			let parseError;
+			try {
+				source = await parseSnapshot(raw);
+			} catch (error) {
+				parseError = error;
+			}
+			if (source) {
+				if (source.source.version === target.version) return finalizeSnapshot(source.snapshot, target);
+				const exactMigration = migrationOptions.migrations[source.source.version];
+				if (exactMigration) return finalizeSnapshot(await exactMigration(source.snapshot), target);
+			}
+			const wildcardMigration = migrationOptions.migrations["*"];
+			if (!wildcardMigration) {
+				if (source) throw new Error(`No snapshot migration from version '${source.source.version}' to '${target.version}' for machine '${target.id}'.`);
+				throw parseError;
+			}
+			return finalizeSnapshot(await wildcardMigration(raw, getSnapshotSource(raw, machineId)), target);
+		}
+	};
+}
+// src/mapState.ts
+const ownResultOf = (snapshot, stateNode, mapper) => mapper.map === void 0 ? [] : [{
+	stateNode,
+	result: mapper.map(snapshot)
+}];
+const mappedStatesOf = (snapshot, active, stateNode, mapper) => mapper === void 0 ? [] : [...Object.values(stateNode.states).filter((child) => active.has(child)).flatMap((child) => mappedStatesOf(snapshot, active, child, mapper.states?.[child.key])), ...ownResultOf(snapshot, stateNode, mapper)];
+const mapActiveStates = (snapshot, mapper) => snapshot.nodes.some(isAtomicStateNode) ? mappedStatesOf(snapshot, new Set(snapshot.nodes), snapshot.machine.root, mapper) : [];
+function mapState(...args) {
+	if (args.length === 1) {
+		const [mapper] = args;
+		return (snapshot) => mapActiveStates(snapshot, mapper);
+	}
+	return mapActiveStates(args[0], args[1]);
+}
+// src/serialize.ts
+/**
+* Returns the JSON-serializable definition of a machine.
+*
+* Inline functions are represented as `{ "@code": string, "@lang": "ts" }`. A
+* machine created via `createMachineFromConfig` returns its original JSON
+* config (lossless round-trip):
+*
+* ```ts
+* import { serializeMachine, createMachineFromConfig } from '@systemfsoftware/xstate';
+*
+* const json = serializeMachine(machine);
+* const revived = createMachineFromConfig(
+*   JSON.parse(JSON.stringify(json))
+* );
+* ```
+*
+* @public
+*/
+function serializeMachine(machine) {
+	return machine._json ?? machineConfigToJSON(machine.config);
+}
+function codeExpression(fn) {
+	return {
+		"@code": fn.toString(),
+		"@lang": "ts"
+	};
+}
+function isActorLogic(value) {
+	return !!value && typeof value === "object" && typeof value.transition === "function" && typeof value.getInitialSnapshot === "function";
+}
+function isRuntimeSchema(value) {
+	return !!value && typeof value === "object" && "~standard" in value;
+}
+/** JSON-safe deep copy of a plain value; functions become code expressions. */
+function valueToJSON(value) {
+	if (typeof value === "function") return codeExpression(value);
+	if (value === null || typeof value !== "object") return typeof value === "bigint" || typeof value === "symbol" ? void 0 : value;
+	if (isActorLogic(value)) return;
+	if (isRuntimeSchema(value)) return;
+	if (Array.isArray(value)) return value.map(valueToJSON).filter((item) => item !== void 0);
+	if (value.constructor !== Object && value.constructor !== void 0) return;
+	const result = {};
+	for (const key of Object.keys(value)) {
+		const v = value[key];
+		if (v !== void 0) {
+			const jsonValue = valueToJSON(v);
+			if (jsonValue !== void 0) result[key] = jsonValue;
+		}
+	}
+	return result;
+}
+function invokeToJSON(invoke) {
+	if (Array.isArray(invoke)) {
+		const values = invoke.map(invokeToJSON).filter((value) => value !== void 0);
+		return values.length ? values : void 0;
+	}
+	const def = invoke;
+	const result = {};
+	for (const key of Object.keys(def)) {
+		const value = def[key];
+		if (value === void 0) continue;
+		result[key] = key === "src" && typeof value !== "string" ? value.id : valueToJSON(value);
+		if (result[key] === void 0) delete result[key];
+	}
+	return result["src"] === void 0 ? void 0 : result;
+}
+function sourcesToJSON(map) {
+	if (!map) return;
+	const result = {};
+	for (const key of Object.keys(map)) {
+		const value = map[key];
+		if (typeof value === "function") result[key] = void 0;
+		else result[key] = valueToJSON(value);
+		if (result[key] === void 0) delete result[key];
+	}
+	return result;
+}
+function stateNodeConfigToJSON(config) {
+	const result = {};
+	for (const key of Object.keys(config)) {
+		if (key === "states" || key === "invoke") continue;
+		const value = config[key];
+		if (value !== void 0) result[key] = valueToJSON(value);
+	}
+	if (config["invoke"] !== void 0) {
+		const invoke = invokeToJSON(config["invoke"]);
+		if (invoke !== void 0) result["invoke"] = invoke;
+	}
+	if (config["states"]) {
+		const states = {};
+		for (const [key, stateConfig] of Object.entries(config["states"])) states[key] = stateNodeConfigToJSON(stateConfig);
+		result["states"] = states;
+	}
+	return result;
+}
+/**
+* Converts a machine config (as passed to `createMachine`) to its JSON-safe
+* definition.
+*
+* @public
+*/
+function machineConfigToJSON(config) {
+	const result = stateNodeConfigToJSON(config);
+	const internalEvents = Object.keys(config["schemas"]?.["internalEvents"] ?? {});
+	delete result["internalEvents"];
+	if (internalEvents.length) result["internalEvents"] = internalEvents;
+	if (config["schemas"]) {
+		const schemas = {};
+		for (const key of Object.keys(config["schemas"])) {
+			const value = config["schemas"][key];
+			if (value && typeof value === "object" && !("~standard" in value)) schemas[key] = sourcesToJSON(value);
+			else schemas[key] = valueToJSON(value);
+			if (schemas[key] === void 0) delete schemas[key];
+		}
+		result["schemas"] = schemas;
+	}
+	for (const key of [
+		"actions",
+		"guards",
+		"actors",
+		"delays"
+	]) if (config[key]) {
+		const value = sourcesToJSON(config[key]);
+		if (value && Object.keys(value).length) result[key] = value;
+		else delete result[key];
+	}
+	return result;
+}
+// src/hotSwap.ts
+/**
+* Switches a running machine actor to another version of its machine, for
+* development hot reloading. The live snapshot is carried over in memory and
+* never serialized, so context may hold values that `getPersistedSnapshot()`
+* cannot represent (DOM nodes, cycles).
+*
+* Children whose logic is unchanged by identity keep running; other children
+* are stopped and restarted from the new machine's logic. Returns `false`,
+* leaving the actor unchanged, when the actor is not a running machine actor
+* with the same machine id, a state or history id does not exist on the new
+* machine, a child's logic cannot be resolved statically, context or a pending
+* timer references a child that would restart, or the new machine's validator
+* rejects the snapshot.
+*
+* @experimental Used by framework integrations; not part of the stable API.
+*/
+function hotSwapActorLogic(actorRef, machine) {
+	const actor = actorRef;
+	const snapshot = actor.getSnapshot();
+	if (actor._processingStatus !== 1 || snapshot.status !== "active" || snapshot.machine?.id !== machine.id) return false;
+	let nodes;
+	const historyValue = {};
+	try {
+		nodes = [...getAllStateNodes(getStateNodes(machine.root, snapshot.value))];
+		for (const [key, items] of Object.entries(snapshot.historyValue ?? {})) {
+			if (machine.getStateNodeById(key).type !== "history") return false;
+			historyValue[key] = items.map((item) => machine.getStateNodeById(item.id));
+		}
+	} catch {
+		return false;
+	}
+	const children = {};
+	const restarts = [];
+	for (const [childId, child] of Object.entries(snapshot.children)) {
+		if (!child) continue;
+		if (typeof child.src !== "string") {
+			children[childId] = child;
+			continue;
+		}
+		let logic;
+		try {
+			logic = resolveReferencedActor(machine, child.src);
+		} catch {}
+		if (!logic || typeof logic === "function") return false;
+		if (logic === child.logic) children[childId] = child;
+		else restarts.push([
+			childId,
+			child,
+			logic
+		]);
+	}
+	const restarting = new Set(restarts.map(([, child]) => child));
+	if (restarting.size && (Object.values(snapshot.timers ?? {}).some((timer) => restarting.has(timer.target)) || holdsActorRef(snapshot.context, restarting))) return false;
+	const buildSnapshot = () => createMachineSnapshot({
+		...snapshot,
+		_nodes: nodes,
+		value: void 0,
+		children,
+		historyValue
+	}, machine);
+	if (machine.validator?.check({
+		kind: "result",
+		logic: machine,
+		snapshot: buildSnapshot(),
+		effects: []
+	})) return false;
+	for (const [childId, child, logic] of restarts) {
+		actor._stopChild(child);
+		children[childId] = actor.system.createActorRef(logic, {
+			id: childId,
+			parent: actor,
+			syncSnapshot: child._syncSnapshot,
+			src: child.src,
+			registryKey: child.registryKey,
+			input: child.options?.input
+		});
+	}
+	if (actor.src === actor.logic) actor.src = machine;
+	actor.logic = machine;
+	const next = buildSnapshot();
+	actor._setSnapshot(next);
+	actor._next(next);
+	for (const [childId] of restarts) children[childId].start();
+	return true;
+}
+/**
+* Whether `value` holds any of `refs`, searching plain objects, arrays, maps
+* and sets. Actor refs, class instances and host objects (DOM nodes) are not
+* searched into.
+*/
+function holdsActorRef(value, refs, visited = /* @__PURE__ */ new Set()) {
+	if (!value || typeof value !== "object" || visited.has(value)) return false;
+	visited.add(value);
+	if (isActorRefLike(value)) return refs.has(value);
+	const proto = Object.getPrototypeOf(value);
+	return (value instanceof Map || value instanceof Set ? [...value.values()] : Array.isArray(value) || proto === Object.prototype || proto === null ? Object.values(value) : []).some((item) => holdsActorRef(item, refs, visited));
+}
+// src/setup.ts
+/**
+* Sets up a state machine with state input schemas and other configuration.
+*
+* @example
+*
+* ```ts
+* import { setup } from '@systemfsoftware/xstate';
+* import z from 'zod';
+*
+* const s = setup({
+*   states: {
+*     loading: {
+*       schemas: {
+*         input: z.object({
+*           userId: z.string()
+*         })
+*       }
+*     }
+*   }
+* });
+*
+* const machine = s.createMachine({
+*   initial: {
+*     target: 'loading',
+*     input: { userId: '123' }
+*   },
+*   states: {
+*     loading: {
+*       entry: ({ input }) => {
+*         console.log(input.userId);
+*       }
+*     }
+*   }
+* });
+* ```
+* @public
+*/
+const setup = function setupImplementation(config = {}) {
+	const { validator, states = {}, schemas, actions, actors, guards, delays } = config;
+	return {
+		extend(extension) {
+			return setup(mergeSetupConfigs(config, extension));
+		},
+		createMachine(machineConfig) {
+			const configSchemas = machineConfig.schemas;
+			const mergedSchemas = mergeSchemas(configSchemas, schemas);
+			const mergedStates = mergeStateSchemas(machineConfig.states, states);
+			const mergedActions = mergeMaps(actions, machineConfig.actions);
+			const mergedActors = mergeMaps(actors, machineConfig.actors);
+			const mergedGuards = mergeMaps(guards, machineConfig.guards);
+			const mergedDelays = mergeMaps(delays, machineConfig.delays);
+			return new StateMachine({
+				...machineConfig,
+				...mergedSchemas ? { schemas: mergedSchemas } : void 0,
+				...mergedStates ? { states: mergedStates } : void 0,
+				...mergedActions ? { actions: mergedActions } : void 0,
+				...mergedActors ? { actors: mergedActors } : void 0,
+				...mergedGuards ? { guards: mergedGuards } : void 0,
+				...mergedDelays ? { delays: mergedDelays } : void 0
+			}, void 0, validator);
+		},
+		createInvoke(invokeConfig, ..._check) {
+			return typeof invokeConfig.src === "function" ? {
+				...invokeConfig,
+				src: createAsyncLogic({
+					schemas: invokeConfig.schemas,
+					run: invokeConfig.src
+				})
+			} : invokeConfig;
+		},
+		createStateConfig(...args) {
+			return args.length > 1 ? args[1] : args[0];
+		},
+		states,
+		schemas: schemas ?? {}
+	};
+};
+/** @public */
+function createSystem(_config = {}) {
+	const runtimeRef = {};
+	const pending = [];
+	const flushObservers = () => {
+		const runtime = runtimeRef.current;
+		if (!runtime) return;
+		for (const entry of pending) if (entry.active && !entry.subscription) entry.subscription = entry.subscribe(runtime);
+	};
+	const subscribeToSystem = (subscribe) => {
+		const runtime = runtimeRef.current;
+		if (runtime) return subscribe(runtime);
+		const entry = {
+			subscribe,
+			active: true
+		};
+		pending.push(entry);
+		return { unsubscribe() {
+			entry.active = false;
+			entry.subscription?.unsubscribe();
+		} };
+	};
+	return {
+		createActor(logic, ...[options]) {
+			const actor = createActor(logic, {
+				...options,
+				_systemRef: runtimeRef
+			});
+			flushObservers();
+			return actor;
+		},
+		get(key) {
+			return runtimeRef.current?.get(key);
+		},
+		getAll() {
+			return runtimeRef.current?.getAll() ?? {};
+		},
+		inspect(observer) {
+			return subscribeToSystem((system) => system.inspect(observer));
+		},
+		onRejectedEvent(listener) {
+			return subscribeToSystem((system) => system.onRejectedEvent(listener));
+		},
+		setup
+	};
+}
+function mergeMaps(left, right) {
+	return left || right ? {
+		...left,
+		...right
+	} : void 0;
+}
+function mergeSetupStateSchemas(left, right) {
+	if (!left && !right) return;
+	if (!left) return right;
+	if (!right) return left;
+	return Object.fromEntries(Array.from(/* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])).map((key) => {
+		const leftState = left[key];
+		const rightState = right[key];
+		if (!leftState) {
+			if (!rightState) throw new Error(`Missing state schema for '${key}'.`);
+			return [key, rightState];
+		}
+		if (!rightState) return [key, leftState];
+		const schemas = mergeSchemas(leftState.schemas, rightState.schemas);
+		const states = mergeSetupStateSchemas(leftState.states, rightState.states);
+		return [key, {
+			...leftState,
+			...rightState,
+			...schemas ? { schemas } : void 0,
+			...states ? { states } : void 0
+		}];
+	}));
+}
+function mergeSchemas(left, right) {
+	if (!left && !right) return;
+	return {
+		...left,
+		...right,
+		events: mergeMaps(left?.events, right?.events),
+		internalEvents: mergeMaps(left?.internalEvents, right?.internalEvents),
+		actions: mergeMaps(left?.actions, right?.actions),
+		guards: mergeMaps(left?.guards, right?.guards),
+		emitted: mergeMaps(left?.emitted, right?.emitted),
+		children: mergeMaps(left?.children, right?.children)
+	};
+}
+/**
+* Setup schemas win over inline config schemas (same precedence as root
+* `mergeSchemas`); setup states with no matching config state are skipped.
+*/
+function mergeStateSchemas(configStates, setupStates) {
+	if (!configStates || !setupStates) return configStates;
+	return Object.fromEntries(Object.entries(configStates).map(([key, configState]) => {
+		const setupState = setupStates[key];
+		if (!setupState) return [key, configState];
+		const schemas = mergeMaps(configState.schemas, setupState.schemas);
+		const states = mergeStateSchemas(configState.states, setupState.states);
+		const structural = Object.fromEntries([
+			"type",
+			"id",
+			"initial",
+			"history",
+			"target",
+			"route"
+		].flatMap((field) => configState[field] === void 0 && setupState[field] !== void 0 ? [[field, setupState[field]]] : []));
+		return [key, {
+			...configState,
+			...structural,
+			...schemas ? { schemas } : void 0,
+			...states ? { states } : void 0
+		}];
+	}));
+}
+function mergeSetupConfigs(base, extension) {
+	return {
+		...base,
+		...extension,
+		schemas: mergeSchemas(base.schemas, extension.schemas),
+		states: mergeSetupStateSchemas(base.states, extension.states),
+		actions: mergeMaps(base.actions, extension.actions),
+		actors: mergeMaps(base.actors, extension.actors),
+		guards: mergeMaps(base.guards, extension.guards),
+		delays: mergeMaps(base.delays, extension.delays)
+	};
+}
+// src/IndexedHeap.ts
+/** An ordered queue whose entries can be removed without retaining cancelled work. @internal */
+var IndexedHeap = class {
+	before;
+	entries = [];
+	indices = /* @__PURE__ */ new Map();
+	constructor(before) {
+		this.before = before;
+	}
+	push(entry) {
+		this.entries.push(entry);
+		this.up(this.entries.length - 1, entry);
+	}
+	peek() {
+		return this.entries[0];
+	}
+	at(index) {
+		const entry = this.entries[index];
+		if (entry === void 0) throw new Error("IndexedHeap index out of range.");
+		return entry;
+	}
+	pop() {
+		const first = this.peek();
+		if (first) this.remove(first);
+		return first;
+	}
+	remove(entry) {
+		const index = this.indices.get(entry);
+		if (index === void 0) return;
+		const last = this.entries.pop();
+		this.indices.delete(entry);
+		if (index === this.entries.length) return;
+		if (index > 0 && this.before(last, this.at(index - 1 >> 1))) this.up(index, last);
+		else this.down(index, last);
+	}
+	up(index, entry) {
+		while (index > 0) {
+			const parent = index - 1 >> 1;
+			if (!this.before(entry, this.at(parent))) break;
+			this.place(index, this.at(parent));
+			index = parent;
+		}
+		this.place(index, entry);
+	}
+	down(index, entry) {
+		while (index * 2 + 1 < this.entries.length) {
+			let child = index * 2 + 1;
+			if (child + 1 < this.entries.length && this.before(this.at(child + 1), this.at(child))) child++;
+			if (!this.before(this.at(child), entry)) break;
+			this.place(index, this.at(child));
+			index = child;
+		}
+		this.place(index, entry);
+	}
+	place(index, entry) {
+		this.entries[index] = entry;
+		this.indices.set(entry, index);
+	}
+};
+// src/SimulatedClock.ts
+var SimulatedClock = class {
+	timeouts = /* @__PURE__ */ new Map();
+	deadlines = new IndexedHeap((a, b) => {
+		const aTime = a.start + a.timeout;
+		const bTime = b.start + b.timeout;
+		return aTime < bTime || aTime === bTime && a.id < b.id;
+	});
+	_now = 0;
+	_id = 0;
+	_flushing = false;
+	now() {
+		return this._now;
+	}
+	getId() {
+		return this._id++;
+	}
+	setTimeout(fn, timeout) {
+		if (!Number.isFinite(timeout)) throw new Error("Timer delay must be finite");
+		const id = this.getId();
+		const timer = {
+			id,
+			start: this.now(),
+			timeout: Math.max(0, timeout),
+			fn
+		};
+		this.timeouts.set(id, timer);
+		this.deadlines.push(timer);
+		return id;
+	}
+	clearTimeout(id) {
+		const timer = this.timeouts.get(id);
+		if (timer) this.deadlines.remove(timer);
+		this.timeouts.delete(id);
+	}
+	set(time) {
+		if (!Number.isFinite(time) || this._now > time) throw new Error("Clock time must be finite; unable to travel back in time");
+		if (this._flushing) throw new Error("Cannot advance a clock during a timer callback");
+		this.flushTimeouts(time);
+	}
+	flushTimeouts(destination) {
+		this._flushing = true;
+		try {
+			let count = 0;
+			while (true) {
+				const next = this.deadlines.peek();
+				if (!next || next.start + next.timeout > destination) break;
+				if (++count > 1e4) throw new Error("Clock exceeded 10,000 timer callbacks; check for a zero-delay loop");
+				this.deadlines.pop();
+				this._now = Math.max(this._now, next.start + next.timeout);
+				this.timeouts.delete(next.id);
+				next.fn.call(null);
+			}
+			this._now = destination;
+		} finally {
+			this._flushing = false;
+		}
+	}
+	increment(ms) {
+		this.set(this._now + ms);
+	}
+};
+// src/systemTransition.ts
+function timerKey(source, id) {
+	return JSON.stringify([
+		source.$actor,
+		source.incarnation,
+		id
+	]);
+}
+function isReference(value) {
+	return !!value && typeof value.$actor === "string" && Number.isSafeInteger(value.incarnation);
+}
+function isHandle(value) {
+	return !!value && typeof value.address === "string" && typeof value.getSnapshot === "function";
+}
+const systemActorHandle = Symbol("xstate.systemActorHandle");
+const systemLogger = () => {};
+/** Converts runtime-shaped, reduction-local capabilities to snapshot data. */
+function encode(value, seen = /* @__PURE__ */ new Set(), mappers) {
+	if (typeof value === "function" && mappers?.has(value)) return { $systemMapper: mappers.get(value) };
+	if (isHandle(value)) {
+		if (!value[systemActorHandle]) throw new Error("Live actors cannot be stored in a pure system snapshot.");
+		return {
+			$actor: value.address,
+			incarnation: Number(value.sessionId)
+		};
+	}
+	if (!value || typeof value !== "object") {
+		if (typeof value === "function" || typeof value === "symbol" || typeof value === "bigint" || typeof value === "number" && !Number.isFinite(value)) throw new Error("System snapshots require data, not executable capabilities.");
+		return value;
+	}
+	if (seen.has(value)) throw new Error("System snapshots cannot contain cyclic data.");
+	seen.add(value);
+	let result;
+	if (value.machine && typeof value.machine.transition === "function" && typeof value.id === "string" && Array.isArray(value.path)) result = { $stateNode: value.id };
+	else if (value instanceof Error) result = {
+		$error: value.name,
+		message: value.message
+	};
+	else if (Array.isArray(value)) result = value.map((item) => encode(item, seen, mappers));
+	else {
+		if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new Error("System snapshot values must be plain data.");
+		result = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, encode(item, seen, mappers)]));
+	}
+	seen.delete(value);
+	return result;
+}
+function snapshotData(snapshot, mappers) {
+	if (!isMachineSnapshot(snapshot)) return encode(snapshot, /* @__PURE__ */ new Set(), mappers);
+	const { machine, nodes, tags, matches, can, hasTag, getMeta, getInputs, toJSON, ...data } = snapshot;
+	return encode({
+		...data,
+		nodeIds: nodes.map((node) => node.id)
+	}, /* @__PURE__ */ new Set(), mappers);
+}
+function definitions(systemLogic) {
+	const result = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	function add(key, logic) {
+		result.set(key, logic);
+		if (visited.has(logic)) return;
+		visited.add(logic);
+		const machine = logic;
+		for (const [name, child] of Object.entries(machine.sources?.actors ?? {})) add(`${key}/actors/${encodeAddressSegment(name)}`, child);
+		function visit(node) {
+			for (const invoke of node.invoke ?? []) if (typeof invoke.logic === "object") add(`${key}/invoke/${encodeAddressSegment(node.id)}/${encodeAddressSegment(invoke.id)}`, invoke.logic);
+			for (const child of Object.values(node.states ?? {})) visit(child);
+		}
+		if (machine.root) visit(machine.root);
+	}
+	add("root", systemLogic.root);
+	for (const [key, logic] of Object.entries(systemLogic.actors ?? {})) add(`actors/${encodeAddressSegment(key)}`, logic);
+	add("xstate.listener", listenerLogic);
+	add("xstate.subscription", subscriptionLogic);
+	return result;
+}
+var SystemReduction = class {
+	snapshot;
+	effects = [];
+	logic;
+	handles = /* @__PURE__ */ new Map();
+	snapshots = /* @__PURE__ */ new Map();
+	initialEffects = /* @__PURE__ */ new Map();
+	stopping = /* @__PURE__ */ new Set();
+	deadlines = new IndexedHeap((a, b) => a.dueAt < b.dueAt || a.dueAt === b.dueAt && a.sequence < b.sequence);
+	effectNames = /* @__PURE__ */ new Map([[systemLogger, "xstate.log"]]);
+	mapperNames;
+	mappers;
+	remaining;
+	constructor(logic, snapshot, maxSteps = 1e4) {
+		if (!Number.isSafeInteger(maxSteps) || maxSteps < 1) throw new Error("maxSteps must be a positive integer.");
+		this.logic = definitions(logic);
+		this.mappers = logic.mappers ?? {};
+		this.mapperNames = new Map(Object.entries(this.mappers).map(([key, mapper]) => [mapper, key]));
+		for (const [key, implementation] of Object.entries(logic.effects ?? {})) this.effectNames.set(implementation, key);
+		for (const [key, definition] of this.logic) for (const [name, implementation] of Object.entries(definition.sources?.actions ?? {})) if (typeof implementation === "function" && !this.effectNames.has(implementation)) this.effectNames.set(implementation, `${key}/actions/${encodeAddressSegment(name)}`);
+		this.snapshot = {
+			...snapshot,
+			actors: Object.assign(Object.create(null), snapshot.actors),
+			registry: Object.assign(Object.create(null), snapshot.registry),
+			messages: [...snapshot.messages],
+			timers: { ...snapshot.timers },
+			externalEffects: { ...snapshot.externalEffects },
+			counters: { ...snapshot.counters }
+		};
+		this.remaining = maxSteps;
+		for (const timer of Object.values(snapshot.timers)) this.deadlines.push(timer);
+	}
+	step() {
+		if (--this.remaining < 0) throw new Error("System transition exceeded maxSteps; the input snapshot is unchanged.");
+	}
+	reference(actor) {
+		return {
+			$actor: actor.address,
+			incarnation: Number(actor.sessionId)
+		};
+	}
+	current(ref) {
+		const actor = this.snapshot.actors[ref.$actor];
+		return actor?.incarnation === ref.incarnation ? actor : void 0;
+	}
+	decode(value, machine) {
+		if (isReference(value)) return this.handle(value);
+		if (!value || typeof value !== "object") return value;
+		if (typeof value.$systemMapper === "string") {
+			const mapper = Object.hasOwn(this.mappers, value.$systemMapper) && this.mappers[value.$systemMapper];
+			if (!mapper) throw new Error(`Missing pure mapper '${value.$systemMapper}'.`);
+			return mapper;
+		}
+		if (typeof value.$stateNode === "string") return machine.getStateNodeById(value.$stateNode);
+		if (typeof value.$error === "string") {
+			const error = new Error(value.message);
+			error.name = value.$error;
+			if (error.name === "TimeoutError") Object.setPrototypeOf(error, TimeoutError.prototype);
+			return error;
+		}
+		if (Array.isArray(value)) return value.map((item) => this.decode(item, machine));
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, this.decode(item, machine)]));
+	}
+	encode(value) {
+		return encode(value, /* @__PURE__ */ new Set(), this.mapperNames);
+	}
+	attachedKind(actor) {
+		return this.logic.get(actor.logic)?.[systemLogicMetadata]?.kind;
+	}
+	relayAttachments(source, emitted) {
+		for (const actor of Object.values(this.snapshot.actors)) {
+			const kind = this.attachedKind(actor);
+			if (!actor.started || actor.snapshot["status"] !== "active" || kind !== "xstate.listener" && kind !== "xstate.subscription") continue;
+			const target = actor.input.actor;
+			if (!target || target.$actor !== source.$actor || target.incarnation !== source.incarnation || !actor.parent || this.current(actor.parent)?.snapshot["status"] !== "active") continue;
+			const input = this.decode(actor.input);
+			let event;
+			if (kind === "xstate.listener") {
+				if (emitted && matchesEventDescriptor(emitted.type, input.eventType)) event = input.mapper(this.decode(this.encode(emitted)));
+			} else if (!emitted) {
+				const snapshot = this.hydrate(source);
+				const mapper = input.mappers[snapshot.status === "active" ? "snapshot" : snapshot.status === "done" ? "done" : snapshot.status === "error" ? "error" : ""];
+				if (mapper) event = mapper(snapshot.status === "done" ? snapshot.output : snapshot.status === "error" ? snapshot.error : snapshot);
+			}
+			if (event) this.enqueue({
+				$actor: actor.address,
+				incarnation: actor.incarnation
+			}, actor.parent, event);
+		}
+	}
+	stopAttachments(parent) {
+		for (const actor of Object.values(this.snapshot.actors)) {
+			const kind = this.attachedKind(actor);
+			if ((kind === "xstate.listener" || kind === "xstate.subscription") && actor.parent?.$actor === parent.$actor && actor.parent.incarnation === parent.incarnation) this.stop({
+				$actor: actor.address,
+				incarnation: actor.incarnation
+			});
+		}
+	}
+	hydrate(ref) {
+		const key = JSON.stringify(ref);
+		if (this.snapshots.has(key)) return this.snapshots.get(key);
+		const actor = this.current(ref);
+		if (!actor) return {
+			status: "stopped",
+			output: void 0,
+			error: void 0
+		};
+		const logic = this.logic.get(actor.logic);
+		if (!logic || logic.version !== actor.logicVersion) throw new Error(`Actor definition/version mismatch for '${actor.address}'.`);
+		const data = this.decode(actor.snapshot, logic);
+		const snapshot = typeof logic.getStateNodeById === "function" && data.nodeIds ? createMachineSnapshot({
+			...data,
+			_nodes: data.nodeIds.map((id) => logic.getStateNodeById(id))
+		}, logic) : data;
+		this.snapshots.set(key, snapshot);
+		return snapshot;
+	}
+	handle(ref) {
+		const key = JSON.stringify(ref);
+		const existing = this.handles.get(key);
+		if (existing) return existing;
+		const actor = this.current(ref);
+		const getState = () => this.current(ref) ?? actor;
+		const getLogic = () => this.logic.get(getState()?.logic ?? "");
+		const getParent = () => {
+			const parent = getState()?.parent;
+			return parent && this.handle(parent);
+		};
+		const getSnapshot = () => this.hydrate(ref);
+		const unsupported = () => {
+			throw new Error("Use enqueue operations and systemTransition; live actor capabilities are unavailable in a pure snapshot.");
+		};
+		const handle = {
+			[systemActorHandle]: true,
+			id: actor?.id ?? ref.$actor.split("/").at(-1),
+			address: ref.$actor,
+			sessionId: String(ref.incarnation),
+			options: {
+				_inert: true,
+				input: actor?.input
+			},
+			get logic() {
+				return getLogic();
+			},
+			get src() {
+				return getState()?.logic;
+			},
+			get registryKey() {
+				return getState()?.registryKey;
+			},
+			get _parent() {
+				return getParent();
+			},
+			get _snapshot() {
+				return getSnapshot();
+			},
+			getSnapshot,
+			send: unsupported,
+			start: unsupported,
+			stop: unsupported,
+			subscribe: unsupported,
+			on: unsupported,
+			system: void 0
+		};
+		this.handles.set(key, handle);
+		handle.system = this.system();
+		return handle;
+	}
+	system() {
+		return {
+			createActorRef: (logic, options) => this.allocate(logic, options),
+			_unregister: (actor) => {
+				this.stopping.add(JSON.stringify(this.reference(actor)));
+				for (const [key, ref] of Object.entries(this.snapshot.registry)) if (ref.$actor === actor.address && String(ref.incarnation) === actor.sessionId) delete this.snapshot.registry[key];
+			},
+			get: (key) => this.snapshot.registry[key] && this.handle(this.snapshot.registry[key]),
+			getAll: () => Object.fromEntries(Object.entries(this.snapshot.registry).map(([key, ref]) => [key, this.handle(ref)])),
+			_hasInspectionObservers: () => false,
+			_sendInspectionEvent: () => {},
+			_clock: {
+				now: () => this.snapshot.now,
+				setTimeout: () => {
+					throw new Error("Timers must be declared as logical effects.");
+				},
+				clearTimeout: () => {
+					throw new Error("Timers must be canceled as logical effects.");
+				}
+			},
+			_wallClock: { now: () => this.snapshot.now }
+		};
+	}
+	scope(ref, source) {
+		const self = this.handle(ref);
+		self._lastSourceRef = source && this.handle(source);
+		return {
+			self,
+			system: self.system,
+			id: self.id,
+			sessionId: self.sessionId,
+			logger: systemLogger,
+			warn: defaultWarn,
+			defer: () => {},
+			emit: () => {
+				throw new Error("Emit events through enqueue operations.");
+			},
+			actionExecutor: () => {
+				throw new Error("Execute external effects outside system transitions.");
+			},
+			stopChild: () => {
+				throw new Error("Stop children through enqueue operations.");
+			}
+		};
+	}
+	allocate(logic, options = {}) {
+		this.step();
+		const definition = [...this.logic].find(([, value]) => value === logic);
+		if (!definition) throw new Error("Register dynamically spawned logic in systemLogic.actors.");
+		const parent = options.parent && this.reference(options.parent);
+		const id = options.id ?? `${getActorIdPrefix(options.src ?? logic)}:${this.snapshot.counters.actor}`;
+		const address = `${parent ? parent.$actor + "/" : ""}${encodeAddressSegment(id)}`;
+		const occupied = this.snapshot.actors[address];
+		if (occupied?.snapshot["status"] === "active") {
+			const previous = {
+				$actor: address,
+				incarnation: occupied.incarnation
+			};
+			if (!this.stopping.has(JSON.stringify(previous))) throw new Error(`Actor address '${address}' is already occupied.`);
+			this.stop(previous);
+		}
+		const incarnation = this.snapshot.counters.actor++;
+		const ref = {
+			$actor: address,
+			incarnation
+		};
+		const state = {
+			id,
+			address,
+			incarnation,
+			logic: definition[0],
+			...logic.version !== void 0 && { logicVersion: logic.version },
+			parent,
+			registryKey: options.registryKey,
+			syncSnapshot: options.syncSnapshot,
+			started: false,
+			input: this.encode(options.input),
+			snapshot: {
+				status: "active",
+				output: void 0,
+				error: void 0
+			}
+		};
+		this.snapshot.actors[address] = state;
+		if (options.registryKey) {
+			if (this.snapshot.registry[options.registryKey]) throw new Error(`Registry key '${options.registryKey}' is already occupied.`);
+			this.snapshot.registry[options.registryKey] = ref;
+		}
+		const scope = this.scope(ref);
+		const result = logic.initialTransition(this.decode(state.input), scope);
+		const [snapshot, effects] = finalizeTransitionResult(scope, void 0, result);
+		this.store(ref, snapshot);
+		this.initialEffects.set(JSON.stringify(ref), effects);
+		return this.handle(ref);
+	}
+	store(ref, snapshot) {
+		const actor = this.current(ref);
+		if (!actor) return;
+		this.snapshots.set(JSON.stringify(ref), snapshot);
+		this.snapshot.actors[ref.$actor] = {
+			...actor,
+			snapshot: snapshotData(snapshot, this.mapperNames)
+		};
+	}
+	external(ref, effect) {
+		const value = effect;
+		if (value.kind === "action" && value.action === void 0) return;
+		const type = value.kind === "action" && !value.type.startsWith("xstate.logic.") ? this.effectNames.get(value.action) : value.type;
+		if (type === void 0) throw new Error("Register callable external actions in systemLogic.effects or the machine action sources.");
+		const id = `${this.snapshot.executionId}:${this.snapshot.counters.effect++}`;
+		const params = typeof value.params?.action === "function" ? Object.fromEntries(Object.entries(value.params).filter(([key]) => key !== "action" && key !== "args")) : value.params;
+		const result = {
+			id,
+			source: ref,
+			type,
+			kind: value.kind === "emit" ? "emit" : value.type === "@xstate.deadLetter" ? "deadLetter" : "action",
+			...params !== void 0 && { params: this.encode(params) },
+			args: this.encode(value.args ?? []),
+			...value.event && { event: this.encode(value.event) },
+			...value.reason && { reason: value.reason }
+		};
+		this.effects.push(result);
+		this.snapshot.externalEffects[id] = result;
+		if (value.kind === "emit") this.relayAttachments(ref, value.event);
+	}
+	enqueue(source, target, event, timerOccurrence) {
+		this.snapshot.messages.push({
+			source,
+			target,
+			event: this.encode(event),
+			sequence: this.snapshot.counters.sequence++,
+			...timerOccurrence !== void 0 && { timerOccurrence }
+		});
+	}
+	cancel(ref, id) {
+		for (const [key, timer] of Object.entries(this.snapshot.timers)) if (timer.source.$actor === ref.$actor && timer.source.incarnation === ref.incarnation && (id === void 0 || timer.id === id)) delete this.snapshot.timers[key];
+	}
+	effectsFor(ref, effects) {
+		for (const effect of effects) {
+			const value = effect;
+			if (value.kind !== "builtin") {
+				this.external(ref, effect);
+				continue;
+			}
+			switch (value.type) {
+				case "@xstate.spawn": break;
+				case "@xstate.start":
+					this.start(this.reference(value.actor));
+					break;
+				case "@xstate.stop":
+					this.stop(this.reference(value.actor));
+					break;
+				case "@xstate.cancel":
+					this.cancel(ref, value.id);
+					break;
+				case "@xstate.raise":
+				case "@xstate.sendTo":
+					if (value.delay !== void 0) {
+						if (!Number.isFinite(value.delay) || value.delay < 0) throw new Error("System timer delays must be finite and nonnegative.");
+						if (!this.current(ref)?.snapshot["timers"]?.[value.id]) break;
+						this.schedule(ref, value.id, value.delay);
+					} else if (value.target) this.enqueue(ref, this.reference(value.target), value.event);
+					break;
+				case "@xstate.terminate":
+					this.terminate(ref);
+					break;
+				default: this.external(ref, effect);
+			}
+		}
+	}
+	schedule(ref, id, delay, event) {
+		const dueAt = this.snapshot.now + delay;
+		if (!Number.isFinite(delay) || delay < 0 || !Number.isFinite(dueAt)) throw new Error("System timer deadlines must be finite and delays nonnegative.");
+		const timer = {
+			source: ref,
+			id,
+			occurrence: this.snapshot.counters.timer++,
+			scheduledAt: this.snapshot.now,
+			dueAt,
+			sequence: this.snapshot.counters.sequence++,
+			...event && { event: this.encode(event) }
+		};
+		this.snapshot.timers[timerKey(ref, id)] = timer;
+		this.deadlines.push(timer);
+	}
+	start(ref) {
+		const actor = this.current(ref);
+		if (!actor || actor.started || actor.snapshot["status"] === "stopped") return;
+		this.snapshot.actors[ref.$actor] = {
+			...actor,
+			started: true
+		};
+		this.effectsFor(ref, this.initialEffects.get(JSON.stringify(ref)) ?? []);
+		this.initialEffects.delete(JSON.stringify(ref));
+		if (this.attachedKind(actor) === "xstate.subscription") {
+			const input = this.decode(actor.input);
+			const target = this.reference(input.actor);
+			const observed = this.current(target);
+			if (observed?.started && observed.snapshot["status"] === "error" && input.mappers.error && actor.parent) this.enqueue(ref, actor.parent, input.mappers.error(this.hydrate(target).error));
+		}
+		if (this.current(ref)?.snapshot["status"] === "active") this.relayAttachments(ref);
+		const metadata = this.logic.get(actor.logic)[systemLogicMetadata];
+		if (metadata?.timeout !== void 0 && this.current(ref)?.snapshot["status"] === "active") {
+			const delay = parseDelayToMilliseconds(metadata.timeout);
+			if (delay === void 0) throw new Error("Unable to resolve async actor timeout.");
+			this.schedule(ref, "xstate.async.timeout", delay, {
+				type: "xstate.async.reject",
+				data: new TimeoutError(metadata.timeout)
+			});
+		}
+	}
+	stop(ref) {
+		const actor = this.current(ref);
+		if (!actor || actor.snapshot["status"] !== "active") return;
+		this.process({
+			source: ref,
+			target: ref,
+			event: { type: "@xstate.stop" },
+			sequence: this.snapshot.counters.sequence++
+		});
+		this.cancel(ref);
+		this.handle(ref).system._unregister(this.handle(ref));
+		this.snapshot.messages = this.snapshot.messages.filter((message) => message.target.$actor !== ref.$actor || message.target.incarnation !== ref.incarnation);
+		this.cancelExternal(ref);
+		this.stopAttachments(ref);
+	}
+	cancelExternal(ref) {
+		for (const [id, effect] of Object.entries(this.snapshot.externalEffects)) {
+			if (effect.kind !== "action" || effect.type === "xstate.system.cancelEffect" || effect.type === "xstate.logic.cleanup" || effect.source.$actor !== ref.$actor || effect.source.incarnation !== ref.incarnation) continue;
+			delete this.snapshot.externalEffects[id];
+			const cancellation = {
+				id: `${this.snapshot.executionId}:${this.snapshot.counters.effect++}`,
+				source: ref,
+				kind: "action",
+				type: "xstate.system.cancelEffect",
+				params: { effectId: id }
+			};
+			this.effects.push(cancellation);
+			this.snapshot.externalEffects[cancellation.id] = cancellation;
+		}
+	}
+	terminate(ref) {
+		const actor = this.current(ref);
+		if (!actor) return;
+		this.relayAttachments(ref);
+		this.cancel(ref);
+		this.cancelExternal(ref);
+		this.stopAttachments(ref);
+		if (actor.parent) {
+			const event = actor.snapshot["status"] === "done" ? createDoneActorEvent(actor.id, this.decode(actor.snapshot["output"]), String(actor.incarnation)) : createErrorActorEvent(actor.id, this.decode(actor.snapshot["error"]), String(actor.incarnation));
+			this.enqueue(ref, actor.parent, event);
+		}
+	}
+	process(message) {
+		this.step();
+		const actor = this.current(message.target);
+		if (!actor || actor.snapshot["status"] !== "active") return;
+		if (message.event.type === "xstate.timer" && message.timerOccurrence === void 0) throw new Error("Only the system scheduler may deliver a timer occurrence.");
+		const logic = this.logic.get(actor.logic);
+		if (!logic) throw new Error(`Missing actor definition '${actor.logic}'.`);
+		if (logic.isInternalEventType?.(message.event.type) && (!message.source || message.source.$actor !== actor.address || message.source.incarnation !== actor.incarnation)) throw new Error(`Internal event '${message.event.type}' cannot be injected into a pure system.`);
+		if (!message.source && /^(xstate\.after(?:\.|$)|xstate\.timeout(?:\.|$))/.test(message.event.type)) throw new Error("Select a pending timer instead of injecting its internal event.");
+		const scope = this.scope(message.target, message.source);
+		const previous = this.hydrate(message.target);
+		const [snapshot, effects] = finalizeTransitionResult(scope, previous, logic.transition(previous, this.decode(message.event), scope));
+		this.store(message.target, snapshot);
+		this.effectsFor(message.target, effects);
+		if (snapshot.status === "active") this.relayAttachments(message.target);
+		if (actor.syncSnapshot && actor.parent && snapshot.status === "active") this.enqueue(message.target, actor.parent, {
+			type: "xstate.snapshot.actor",
+			actorId: actor.id,
+			sessionId: String(actor.incarnation),
+			snapshot: snapshotData(snapshot, this.mapperNames)
+		});
+	}
+	settle() {
+		while (this.snapshot.messages.length) {
+			const message = this.snapshot.messages.shift();
+			this.process(message);
+		}
+	}
+	advance(time) {
+		if (!Number.isFinite(time) || time < this.snapshot.now) throw new Error("System time must be finite and cannot move backwards.");
+		this.settle();
+		while (true) {
+			const timer = this.deadlines.peek();
+			if (timer && this.snapshot.timers[timerKey(timer.source, timer.id)] !== timer) {
+				this.deadlines.pop();
+				continue;
+			}
+			if (!timer || timer.dueAt > time) break;
+			this.step();
+			this.deadlines.pop();
+			delete this.snapshot.timers[timerKey(timer.source, timer.id)];
+			this.snapshot.now = Math.max(this.snapshot.now, timer.dueAt);
+			const actor = this.current(timer.source);
+			if (!actor || actor.snapshot["status"] !== "active" || !timer.event && !actor.snapshot["timers"]?.[timer.id]) continue;
+			this.enqueue(timer.source, timer.source, timer.event ?? {
+				type: "xstate.timer",
+				id: timer.id
+			}, timer.occurrence);
+			this.settle();
+		}
+		this.snapshot.now = time;
+	}
+	send(path, event) {
+		if (event.type === "xstate.timer") {
+			const actor = this.snapshot.actors[path];
+			if (!actor) throw new Error(`Unknown actor address '${path}'.`);
+			const timer = this.snapshot.timers[timerKey({
+				$actor: path,
+				incarnation: actor.incarnation
+			}, event["id"])];
+			if (!timer || event["occurrence"] !== timer.occurrence) throw new Error("Select a current timer occurrence.");
+			this.advance(timer.dueAt);
+			return;
+		}
+		this.advance(this.snapshot.now);
+		const actor = this.snapshot.actors[path];
+		if (!actor) throw new Error(`Unknown actor address '${path}'.`);
+		const ref = {
+			$actor: path,
+			incarnation: actor.incarnation
+		};
+		if (event.type === "xstate.system.effect.result") {
+			const effect = this.snapshot.externalEffects[event["effectId"]];
+			if (!effect || effect.source.$actor !== path || event["event"] && (effect.source.incarnation !== actor.incarnation || actor.snapshot["status"] !== "active" || effect.type === "xstate.system.cancelEffect" || effect.type === "xstate.logic.cleanup")) throw new Error("External effect result does not match its owner or is stale.");
+			delete this.snapshot.externalEffects[event["effectId"]];
+			if (event["event"]) {
+				this.enqueue(ref, ref, event["event"]);
+				this.settle();
+			}
+			return;
+		}
+		if (event.type === "@xstate.stop") {
+			this.stop(ref);
+			this.settle();
+			return;
+		}
+		if (event.type.startsWith("xstate.async.") || event.type.startsWith("xstate.logic.effect.")) throw new Error("Deliver external work results with xstate.system.effect.result.");
+		this.enqueue(void 0, ref, event);
+		this.settle();
+	}
+	initialize(input, id, registryKey) {
+		const root = this.allocate(this.logic.get("root"), {
+			id,
+			input,
+			registryKey
+		});
+		this.snapshot.root = root.address;
+		this.start(this.reference(root));
+		this.settle();
+	}
+};
+/** Initialize all actors and return external work without executing it. @experimental */
+function initialSystemTransition(systemLogic, options = {}) {
+	const now = options.time ?? 0;
+	if (!Number.isFinite(now) || now < 0) throw new Error("Initial system time must be finite and nonnegative.");
+	const reduction = new SystemReduction(systemLogic, {
+		root: "",
+		executionId: options.executionId ?? "system",
+		now,
+		actors: {},
+		registry: {},
+		messages: [],
+		timers: {},
+		externalEffects: {},
+		counters: {
+			actor: 0,
+			timer: 0,
+			sequence: 0,
+			effect: 0
+		}
+	}, options.maxSteps);
+	reduction.initialize(options.input, options.id ?? systemLogic.root.id ?? "root", options.registryKey);
+	return [reduction.snapshot, reduction.effects];
+}
+/** Complete actor macrosteps and immediate communication in an immutable snapshot. @experimental */
+function systemTransition(systemLogic, snapshot, actorPath, event) {
+	const reduction = new SystemReduction(systemLogic, snapshot);
+	reduction.send(actorPath, event);
+	return [reduction.snapshot, reduction.effects];
+}
+/** Process every due timer chronologically across the entire system snapshot. @experimental */
+function advanceSystemTime(systemLogic, snapshot, options) {
+	const reduction = new SystemReduction(systemLogic, snapshot, options.maxSteps);
+	reduction.advance(options.time);
+	return [reduction.snapshot, reduction.effects];
+}
+// src/toPromise.ts
+/**
+* Returns a promise that resolves to the `output` of the actor when it is done.
+*
+* @example
+*
+* ```ts
+* const machine = createMachine({
+*   // ...
+*   output: {
+*     count: 42
+*   }
+* });
+*
+* const actor = createActor(machine);
+*
+* actor.start();
+*
+* const output = await toPromise(actor);
+*
+* console.log(output);
+* // logs { count: 42 }
+* ```
+* @public
+*/
+function toPromise(actor) {
+	return new Promise((resolve, reject) => {
+		actor.subscribe({
+			complete: () => {
+				resolve(actor.getSnapshot().output);
+			},
+			error: reject
+		});
+	});
+}
+// src/waitFor.ts
+const defaultWaitForOptions = { timeout: Infinity };
+/**
+* Subscribes to an actor ref and waits for its emitted value to satisfy a
+* predicate, and then resolves with that value. Will throw if the desired state
+* is not reached after an optional timeout. (defaults to Infinity).
+*
+* @example
+*
+* ```js
+* const state = await waitFor(someService, (state) => {
+*   return state.hasTag('loaded');
+* });
+*
+* state.hasTag('loaded'); // true
+* ```
+*
+* @param actorRef The actor ref to subscribe to
+* @param predicate Determines if a value matches the condition to wait for
+* @param options
+* @returns A promise that eventually resolves to the emitted value that matches
+*   the condition
+* @public
+*/
+function waitFor(actorRef, predicate, options) {
+	const resolvedOptions = {
+		...defaultWaitForOptions,
+		...options
+	};
+	return new Promise((res, rej) => {
+		const { signal } = resolvedOptions;
+		if (signal?.aborted) {
+			rej(signal.reason);
+			return;
+		}
+		let done = false;
+		const handle = resolvedOptions.timeout === Infinity ? void 0 : setTimeout(() => {
+			dispose();
+			rej(/* @__PURE__ */ new Error(`Timeout of ${resolvedOptions.timeout} ms exceeded`));
+		}, resolvedOptions.timeout);
+		const dispose = () => {
+			clearTimeout(handle);
+			done = true;
+			sub?.unsubscribe();
+			if (abortListener) signal.removeEventListener("abort", abortListener);
+		};
+		function checkEmitted(emitted) {
+			if (predicate(emitted)) {
+				dispose();
+				res(emitted);
+			}
+		}
+		/**
+		* If the `signal` option is provided, this will be the listener for its
+		* `abort` event
+		*/
+		let abortListener;
+		let sub;
+		checkEmitted(actorRef.getSnapshot());
+		if (done) return;
+		if (signal) {
+			abortListener = () => {
+				dispose();
+				rej(signal.reason);
+			};
+			signal.addEventListener("abort", abortListener);
+		}
+		sub = actorRef.subscribe({
+			next: checkEmitted,
+			error: (err) => {
+				dispose();
+				rej(err);
+			},
+			complete: () => {
+				dispose();
+				rej(/* @__PURE__ */ new Error(`Actor terminated without satisfying predicate`));
+			}
+		});
+		if (done) sub.unsubscribe();
+	});
+}
+export { createStateConfig as _, systemTransition as a, SpecialTargets as b, setup as c, serializeMachine as d, mapState as f, createMachineFromCompiledConfig as g, createMachine as h, initialSystemTransition as i, hotSwapActorLogic as l, createMachineFromConfig as m, toPromise as n, SimulatedClock as o, machineVersions as p, advanceSystemTime as r, createSystem as s, waitFor as t, machineConfigToJSON as u, StateMachine as v, assertEvent as y };