likec4 1.59.4 → 1.60.0

package/__app__/src/chunks/libs/@xstate/react.mjs

@@ -1,523 +1,838 @@
-import { i as e } from "../../rolldown-runtime.mjs";
-import { useCallback as t, useEffect as n, useLayoutEffect as r, useState as i } from "react";
-import { useSyncExternalStoreWithSelector as a } from "use-sync-external-store/shim/with-selector";
-//#region ../../node_modules/.pnpm/use-isomorphic-layout-effect@1.2.1_@types+react@19.2.18_react@19.2.8/node_modules/use-isomorphic-layout-effect/dist/use-isomorphic-layout-effect.browser.esm.js
-var o = r;
+import { i as __name } from "../../rolldown-runtime.mjs";
+import { f as useSyncExternalStoreWithSelector } from "../@tanstack.mjs";
+import { useCallback, useEffect, useLayoutEffect, useState } from "react";
+//#region ../../node_modules/.pnpm/use-isomorphic-layout-effect@1.2.1_@types+react@19.3.0_react@19.3.0/node_modules/use-isomorphic-layout-effect/dist/use-isomorphic-layout-effect.esm.js
+var index = typeof document !== "undefined" ? useLayoutEffect : function noop() {};
 //#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.6/node_modules/xstate/dist/xstate-dev.esm.js
+//#region ../../node_modules/.pnpm/xstate@5.33.2/node_modules/xstate/dist/xstate-dev.esm.js
 function getGlobal() {
-	if (typeof globalThis < "u") return globalThis;
-	if (typeof self < "u") return self;
-	if (typeof window < "u") return window;
-	if (typeof global < "u") return global;
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
 }
 function getDevTools() {
-	let e = getGlobal();
-	if (e.__xstate__) return e.__xstate__;
+	const w = getGlobal();
+	if (w.__xstate__) return w.__xstate__;
 }
-var devToolsAdapter = (e) => {
-	if (typeof window > "u") return;
-	let t = getDevTools();
-	t && t.register(e);
-}, Mailbox = class {
-	constructor(e) {
-		this._process = e, this._active = !1, this._current = null, this._last = null;
+var devToolsAdapter = (service) => {
+	if (typeof window === "undefined") return;
+	const devTools = getDevTools();
+	if (devTools) devTools.register(service);
+};
+//#endregion
+//#region ../../node_modules/.pnpm/xstate@5.33.2/node_modules/xstate/dist/raise-97446fd4.esm.js
+var Mailbox = class {
+	constructor(_process) {
+		this._process = _process;
+		this._active = false;
+		this._current = null;
+		this._last = null;
 	}
 	start() {
-		this._active = !0, this.flush();
+		this._active = true;
+		this.flush();
 	}
 	clear() {
-		this._current && (this._current.next = null, this._last = this._current);
+		if (this._current) {
+			this._current.next = null;
+			this._last = this._current;
+		}
 	}
-	enqueue(e) {
-		let t = {
-			value: e,
+	enqueue(event) {
+		const enqueued = {
+			value: event,
 			next: null
 		};
 		if (this._current) {
-			this._last.next = t, this._last = t;
+			this._last.next = enqueued;
+			this._last = enqueued;
 			return;
 		}
-		this._current = t, this._last = t, this._active && this.flush();
+		this._current = enqueued;
+		this._last = enqueued;
+		if (this._active) this.flush();
 	}
 	flush() {
-		for (; this._current;) {
-			let e = this._current;
-			this._process(e.value), this._current = e.next;
+		while (this._current) {
+			const consumed = this._current;
+			this._process(consumed.value);
+			this._current = consumed.next;
 		}
 		this._last = null;
 	}
-}, s = "", c = "#", l = "*", u = "xstate.init", d = "xstate.stop";
-function createAfterEvent(e, t) {
-	return { type: `xstate.after.${e}.${t}` };
-}
-function createDoneStateEvent(e, t) {
+};
+var TARGETLESS_KEY = "";
+var STATE_IDENTIFIER = "#";
+var WILDCARD = "*";
+var XSTATE_INIT = "xstate.init";
+var XSTATE_STOP = "xstate.stop";
+/**
+* Returns an event that represents an implicit event that is sent after the
+* specified `delay`.
+*
+* @param delayRef The delay in milliseconds
+* @param id The state node ID where this event is handled
+*/
+function createAfterEvent(delayRef, id) {
+	return { type: `xstate.after.${delayRef}.${id}` };
+}
+/**
+* Returns an event that represents that a final state node has been reached in
+* the parent state node.
+*
+* @param id The final state node's parent state node `id`
+* @param output The data to pass into the event
+*/
+function createDoneStateEvent(id, output) {
 	return {
-		type: `xstate.done.state.${e}`,
-		output: t
+		type: `xstate.done.state.${id}`,
+		output
 	};
 }
-function createDoneActorEvent(e, t) {
+/**
+* Returns an event that represents that an invoked service has terminated.
+*
+* An invoked service is terminated when it has reached a top-level final state
+* node, but not when it is canceled.
+*
+* @param invokeId The invoked service ID
+* @param output The data to pass into the event
+*/
+function createDoneActorEvent(invokeId, output) {
 	return {
-		type: `xstate.done.actor.${e}`,
-		output: t,
-		actorId: e
+		type: `xstate.done.actor.${invokeId}`,
+		output,
+		actorId: invokeId
 	};
 }
-function createErrorActorEvent(e, t) {
+function createErrorActorEvent(id, error) {
 	return {
-		type: `xstate.error.actor.${e}`,
-		error: t,
-		actorId: e
+		type: `xstate.error.actor.${id}`,
+		error,
+		actorId: id
 	};
 }
-function createInitEvent(e) {
+function createInitEvent(input) {
 	return {
-		type: u,
-		input: e
+		type: XSTATE_INIT,
+		input
 	};
 }
-function reportUnhandledError(e) {
+/**
+* This function makes sure that unhandled errors are thrown in a separate
+* macrotask. It allows those errors to be detected by global error handlers and
+* reported to bug tracking services without interrupting our own stack of
+* execution.
+*
+* @param err Error to be thrown
+*/
+function reportUnhandledError(err) {
 	setTimeout(() => {
-		throw e;
+		throw err;
 	});
 }
-var f = typeof Symbol == "function" && Symbol.observable || "@@observable";
-function matchesState(e, t) {
-	let n = toStateValue(e), r = toStateValue(t);
-	return typeof r == "string" ? typeof n == "string" && r === n : typeof n == "string" ? n in r : Object.keys(n).every((e) => e in r && matchesState(n[e], r[e]));
+var symbolObservable = (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
+function matchesState(parentStateId, childStateId) {
+	const parentStateValue = toStateValue(parentStateId);
+	const childStateValue = toStateValue(childStateId);
+	if (typeof childStateValue === "string") {
+		if (typeof parentStateValue === "string") return childStateValue === parentStateValue;
+		return false;
+	}
+	if (typeof parentStateValue === "string") return parentStateValue in childStateValue;
+	return Object.keys(parentStateValue).every((key) => {
+		if (!(key in childStateValue)) return false;
+		return matchesState(parentStateValue[key], childStateValue[key]);
+	});
 }
-function toStatePath(e) {
-	if (isArray(e)) return e;
-	let t = [], n = "";
-	for (let r = 0; r < e.length; r++) {
-		switch (e.charCodeAt(r)) {
+function toStatePath(stateId) {
+	if (isArray(stateId)) return stateId;
+	const result = [];
+	let segment = "";
+	for (let i = 0; i < stateId.length; i++) {
+		switch (stateId.charCodeAt(i)) {
 			case 92:
-				n += e[r + 1], r++;
+				segment += stateId[i + 1];
+				i++;
 				continue;
 			case 46:
-				t.push(n), n = "";
+				result.push(segment);
+				segment = "";
 				continue;
 		}
-		n += e[r];
+		segment += stateId[i];
 	}
-	return t.push(n), t;
+	result.push(segment);
+	return result;
 }
-function toStateValue(e) {
-	return isMachineSnapshot(e) ? e.value : typeof e == "string" ? pathToStateValue(toStatePath(e)) : e;
+function toStateValue(stateValue) {
+	if (isMachineSnapshot(stateValue)) return stateValue.value;
+	if (typeof stateValue !== "string") return stateValue;
+	return pathToStateValue(toStatePath(stateValue));
 }
-function pathToStateValue(e) {
-	if (e.length === 1) return e[0];
-	let t = {}, n = t;
-	for (let t = 0; t < e.length - 1; t++) if (t === e.length - 2) n[e[t]] = e[t + 1];
+function pathToStateValue(statePath) {
+	if (statePath.length === 1) return statePath[0];
+	const value = {};
+	let marker = value;
+	for (let i = 0; i < statePath.length - 1; i++) if (i === statePath.length - 2) marker[statePath[i]] = statePath[i + 1];
 	else {
-		let r = n;
-		n = {}, r[e[t]] = n;
-	}
-	return t;
-}
-function mapValues(e, t) {
-	let n = {}, r = Object.keys(e);
-	for (let i = 0; i < r.length; i++) {
-		let a = r[i];
-		n[a] = t(e[a], a, e, i);
-	}
-	return n;
-}
-function toArrayStrict(e) {
-	return isArray(e) ? e : [e];
-}
-function toArray(e) {
-	return e === void 0 ? [] : toArrayStrict(e);
-}
-function resolveOutput(e, t, n, r) {
-	return typeof e == "function" ? e({
-		context: t,
-		event: n,
-		self: r
-	}) : e;
+		const previous = marker;
+		marker = {};
+		previous[statePath[i]] = marker;
+	}
+	return value;
+}
+function mapValues(collection, iteratee) {
+	const result = {};
+	const collectionKeys = Object.keys(collection);
+	for (let i = 0; i < collectionKeys.length; i++) {
+		const key = collectionKeys[i];
+		result[key] = iteratee(collection[key], key, collection, i);
+	}
+	return result;
+}
+function toArrayStrict(value) {
+	if (isArray(value)) return value;
+	return [value];
+}
+function toArray(value) {
+	if (value === void 0) return [];
+	return toArrayStrict(value);
+}
+function resolveOutput(mapper, context, event, self) {
+	if (typeof mapper === "function") return mapper({
+		context,
+		event,
+		self
+	});
+	return mapper;
 }
-function isArray(e) {
-	return Array.isArray(e);
+function isArray(value) {
+	return Array.isArray(value);
 }
-function isErrorActorEvent(e) {
-	return e.type.startsWith("xstate.error.actor");
+function isErrorActorEvent(event) {
+	return event.type.startsWith("xstate.error.actor");
 }
-function toTransitionConfigArray(e) {
-	return toArrayStrict(e).map((e) => e === void 0 || typeof e == "string" ? { target: e } : e);
+function toTransitionConfigArray(configLike) {
+	return toArrayStrict(configLike).map((transitionLike) => {
+		if (typeof transitionLike === "undefined" || typeof transitionLike === "string") return { target: transitionLike };
+		return transitionLike;
+	});
 }
-function normalizeTarget(e) {
-	if (e !== void 0 && e !== s) return toArray(e);
+function normalizeTarget(target) {
+	if (target === void 0 || target === TARGETLESS_KEY) return;
+	return toArray(target);
 }
-function toObserver(e, t, n) {
-	let r = typeof e == "object", i = r ? e : void 0;
+function toObserver(nextHandler, errorHandler, completionHandler) {
+	const isObserver = typeof nextHandler === "object";
+	const self = isObserver ? nextHandler : void 0;
 	return {
-		next: (r ? e.next : e)?.bind(i),
-		error: (r ? e.error : t)?.bind(i),
-		complete: (r ? e.complete : n)?.bind(i)
+		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
 	};
 }
-function createInvokeId(e, t) {
-	return `${t}.${e}`;
-}
-function resolveReferencedActor(e, t) {
-	let n = t.match(/^xstate\.invoke\.(\d+)\.(.*)/);
-	if (!n) return e.implementations.actors[t];
-	let [, r, i] = n, a = e.getStateNodeById(i).config.invoke;
-	return (Array.isArray(a) ? a[r] : a).src;
-}
-function matchesEventDescriptor(e, t) {
-	if (t === e || t === l) return !0;
-	if (!t.endsWith(".*")) return !1;
-	let n = t.split("."), r = e.split(".");
-	for (let e = 0; e < n.length; e++) {
-		let t = n[e], i = r[e];
-		if (t === "*") return e === n.length - 1;
-		if (t !== i) return !1;
-	}
-	return !0;
-}
-function createScheduledEventId(e, t) {
-	return `${e.sessionId}.${t}`;
-}
-var p = 0;
-function createSystem(e, t) {
-	let n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new WeakMap(), a = /* @__PURE__ */ new Set(), o = {}, { clock: s, logger: c } = t, l = {
-		schedule: (e, t, n, r, i = Math.random().toString(36).slice(2)) => {
-			let a = {
-				source: e,
-				target: t,
-				event: n,
-				delay: r,
-				id: i,
+function createInvokeId(stateNodeId, index) {
+	return `${index}.${stateNodeId}`;
+}
+function resolveReferencedActor(machine, src) {
+	const match = src.match(/^xstate\.invoke\.(\d+)\.(.*)/);
+	if (!match) return machine.implementations.actors[src];
+	const [, indexStr, nodeId] = match;
+	const invokeConfig = machine.getStateNodeById(nodeId).config.invoke;
+	return (Array.isArray(invokeConfig) ? invokeConfig[indexStr] : invokeConfig).src;
+}
+/**
+* Checks if an event type matches an event descriptor, supporting wildcards.
+* Event descriptors can be:
+*
+* - Exact matches: "event.type"
+* - Wildcard: "*"
+* - Partial matches: "event.*"
+*
+* @param eventType - The actual event type string
+* @param descriptor - The event descriptor to match against
+* @returns True if the event type matches the descriptor
+*/
+function matchesEventDescriptor(eventType, descriptor) {
+	if (descriptor === eventType) return true;
+	if (descriptor === WILDCARD) return true;
+	if (!descriptor.endsWith(".*")) return false;
+	const partialEventTokens = descriptor.split(".");
+	const eventTokens = eventType.split(".");
+	for (let tokenIndex = 0; tokenIndex < partialEventTokens.length; tokenIndex++) {
+		const partialEventToken = partialEventTokens[tokenIndex];
+		const eventToken = eventTokens[tokenIndex];
+		if (partialEventToken === "*") return tokenIndex === partialEventTokens.length - 1;
+		if (partialEventToken !== eventToken) return false;
+	}
+	return true;
+}
+function createScheduledEventId(actorRef, id) {
+	return `${actorRef.sessionId}.${id}`;
+}
+var idCounter = 0;
+function createSystem(rootActor, options) {
+	const children = /* @__PURE__ */ new Map();
+	const keyedActors = /* @__PURE__ */ new Map();
+	const reverseKeyedActors = /* @__PURE__ */ new WeakMap();
+	const inspectionObservers = /* @__PURE__ */ new Set();
+	const timerMap = {};
+	const { clock, logger } = options;
+	const scheduler = {
+		schedule: (source, target, event, delay, id = Math.random().toString(36).slice(2)) => {
+			const scheduledEvent = {
+				source,
+				target,
+				event,
+				delay,
+				id,
 				startedAt: Date.now()
-			}, c = createScheduledEventId(e, i);
-			u._snapshot._scheduledEvents[c] = a;
-			let l = s.setTimeout(() => {
-				delete o[c], delete u._snapshot._scheduledEvents[c], u._relay(e, t, n);
-			}, r);
-			o[c] = l;
+			};
+			const scheduledEventId = createScheduledEventId(source, id);
+			system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
+			const timeout = clock.setTimeout(() => {
+				delete timerMap[scheduledEventId];
+				delete system._snapshot._scheduledEvents[scheduledEventId];
+				system._relay(source, target, event);
+			}, delay);
+			timerMap[scheduledEventId] = timeout;
 		},
-		cancel: (e, t) => {
-			let n = createScheduledEventId(e, t), r = o[n];
-			delete o[n], delete u._snapshot._scheduledEvents[n], r !== void 0 && s.clearTimeout(r);
+		cancel: (source, id) => {
+			const scheduledEventId = createScheduledEventId(source, id);
+			const timeout = timerMap[scheduledEventId];
+			delete timerMap[scheduledEventId];
+			delete system._snapshot._scheduledEvents[scheduledEventId];
+			if (timeout !== void 0) clock.clearTimeout(timeout);
 		},
-		cancelAll: (e) => {
-			for (let t in u._snapshot._scheduledEvents) {
-				let n = u._snapshot._scheduledEvents[t];
-				n.source === e && l.cancel(e, n.id);
+		cancelAll: (actorRef) => {
+			for (const scheduledEventId in system._snapshot._scheduledEvents) {
+				const scheduledEvent = system._snapshot._scheduledEvents[scheduledEventId];
+				if (scheduledEvent.source === actorRef) scheduler.cancel(actorRef, scheduledEvent.id);
 			}
 		}
-	}, sendInspectionEvent = (t) => {
-		if (!a.size) return;
-		let n = {
-			...t,
-			rootId: e.sessionId
+	};
+	const sendInspectionEvent = (event) => {
+		if (!inspectionObservers.size) return;
+		const resolvedInspectionEvent = {
+			...event,
+			rootId: rootActor.sessionId
 		};
-		a.forEach((e) => e.next?.(n));
-	}, u = {
-		_snapshot: { _scheduledEvents: (t?.snapshot && t.snapshot.scheduler) ?? {} },
-		_bookId: () => `x:${p++}`,
-		_register: (e, t) => (n.set(e, t), e),
-		_unregister: (e) => {
-			n.delete(e.sessionId);
-			let t = i.get(e);
-			t !== void 0 && (r.delete(t), i.delete(e));
+		inspectionObservers.forEach((observer) => observer.next?.(resolvedInspectionEvent));
+	};
+	const system = {
+		_snapshot: { _scheduledEvents: (options?.snapshot && options.snapshot.scheduler) ?? {} },
+		_bookId: () => `x:${idCounter++}`,
+		_register: (sessionId, actorRef) => {
+			children.set(sessionId, actorRef);
+			return sessionId;
 		},
-		get: (e) => r.get(e),
-		getAll: () => Object.fromEntries(r.entries()),
-		_set: (e, t) => {
-			let n = r.get(e);
-			if (n && n !== t) throw Error(`Actor with system ID '${e}' already exists.`);
-			r.set(e, t), i.set(t, e);
+		_unregister: (actorRef) => {
+			children.delete(actorRef.sessionId);
+			const systemId = reverseKeyedActors.get(actorRef);
+			if (systemId !== void 0) {
+				keyedActors.delete(systemId);
+				reverseKeyedActors.delete(actorRef);
+			}
 		},
-		inspect: (e) => {
-			let t = toObserver(e);
-			return a.add(t), { unsubscribe() {
-				a.delete(t);
+		get: (systemId) => {
+			return keyedActors.get(systemId);
+		},
+		getAll: () => {
+			return Object.fromEntries(keyedActors.entries());
+		},
+		_set: (systemId, actorRef) => {
+			const existing = keyedActors.get(systemId);
+			if (existing && existing !== actorRef) throw new Error(`Actor with system ID '${systemId}' already exists.`);
+			keyedActors.set(systemId, actorRef);
+			reverseKeyedActors.set(actorRef, systemId);
+		},
+		inspect: (observerOrFn) => {
+			const observer = toObserver(observerOrFn);
+			inspectionObservers.add(observer);
+			return { unsubscribe() {
+				inspectionObservers.delete(observer);
 			} };
 		},
 		_sendInspectionEvent: sendInspectionEvent,
-		_relay: (e, t, n) => {
-			u._sendInspectionEvent({
+		_relay: (source, target, event) => {
+			system._sendInspectionEvent({
 				type: "@xstate.event",
-				sourceRef: e,
-				actorRef: t,
-				event: n
-			}), t._send(n);
+				sourceRef: source,
+				actorRef: target,
+				event
+			});
+			target._send(event);
+		},
+		scheduler,
+		getSnapshot: () => {
+			return { _scheduledEvents: { ...system._snapshot._scheduledEvents } };
 		},
-		scheduler: l,
-		getSnapshot: () => ({ _scheduledEvents: { ...u._snapshot._scheduledEvents } }),
 		start: () => {
-			let e = u._snapshot._scheduledEvents;
-			u._snapshot._scheduledEvents = {};
-			for (let t in e) {
-				let { source: n, target: r, event: i, delay: a, id: o } = e[t];
-				l.schedule(n, r, i, a, o);
+			const scheduledEvents = system._snapshot._scheduledEvents;
+			system._snapshot._scheduledEvents = {};
+			for (const scheduledId in scheduledEvents) {
+				const { source, target, event, delay, id } = scheduledEvents[scheduledId];
+				scheduler.schedule(source, target, event, delay, id);
 			}
 		},
-		_clock: s,
-		_logger: c
+		_clock: clock,
+		_logger: logger
 	};
-	return u;
-}
-var m = !1, h = /*#__PURE__*/ function(e) {
-	return e[e.NotStarted = 0] = "NotStarted", e[e.Running = 1] = "Running", e[e.Stopped = 2] = "Stopped", e;
-}({}), g = {
+	return system;
+}
+var executingCustomAction = false;
+var ProcessingStatus = /*#__PURE__*/ function(ProcessingStatus) {
+	ProcessingStatus[ProcessingStatus["NotStarted"] = 0] = "NotStarted";
+	ProcessingStatus[ProcessingStatus["Running"] = 1] = "Running";
+	ProcessingStatus[ProcessingStatus["Stopped"] = 2] = "Stopped";
+	return ProcessingStatus;
+}({});
+var defaultOptions = {
 	clock: {
-		setTimeout: (e, t) => setTimeout(e, t),
-		clearTimeout: (e) => clearTimeout(e)
+		setTimeout: (fn, ms) => {
+			return setTimeout(fn, ms);
+		},
+		clearTimeout: (id) => {
+			return clearTimeout(id);
+		}
 	},
 	logger: console.log.bind(console),
-	devTools: !1
-}, Actor = class {
-	constructor(e, t) {
-		this.logic = e, this._snapshot = void 0, this.clock = void 0, this.options = void 0, this.id = void 0, this.mailbox = new Mailbox(this._process.bind(this)), this.observers = /* @__PURE__ */ new Set(), this.eventListeners = /* @__PURE__ */ new Map(), this.logger = void 0, this._processingStatus = h.NotStarted, this._parent = void 0, this._syncSnapshot = void 0, this.ref = void 0, this._actorScope = void 0, this.systemId = void 0, this.sessionId = void 0, this.system = void 0, this._doneEvent = void 0, this.src = void 0, this._deferred = [];
-		let n = {
-			...g,
-			...t
-		}, { clock: r, logger: i, parent: a, syncSnapshot: o, id: s, systemId: c, inspect: l } = n;
-		this.system = a ? a.system : createSystem(this, {
-			clock: r,
-			logger: i
-		}), l && !a && this.system.inspect(toObserver(l)), this.sessionId = this.system._bookId(), this.id = s ?? this.sessionId, this.logger = t?.logger ?? this.system._logger, this.clock = t?.clock ?? this.system._clock, this._parent = a, this._syncSnapshot = o, this.options = n, this.src = n.src ?? e, this.ref = this, this._actorScope = {
+	devTools: false
+};
+/**
+* An Actor is a running process that can receive events, send events and change
+* its behavior based on the events it receives, which can cause effects outside
+* of the actor. When you run a state machine, it becomes an actor.
+*/
+var Actor = class {
+	/**
+	* Creates a new actor instance for the given logic with the provided options,
+	* if any.
+	*
+	* @param logic The logic to create an actor from
+	* @param options Actor options
+	*/
+	constructor(logic, options) {
+		this.logic = logic;
+		/** The current internal state of the actor. */
+		this._snapshot = void 0;
+		/**
+		* The clock that is responsible for setting and clearing timeouts, such as
+		* delayed events and transitions.
+		*/
+		this.clock = void 0;
+		this.options = void 0;
+		/** The unique identifier for this actor relative to its parent. */
+		this.id = void 0;
+		this.mailbox = new Mailbox(this._process.bind(this));
+		this.observers = /* @__PURE__ */ new Set();
+		this.eventListeners = /* @__PURE__ */ new Map();
+		this.logger = void 0;
+		/** @internal */
+		this._processingStatus = ProcessingStatus.NotStarted;
+		this._parent = void 0;
+		/** @internal */
+		this._syncSnapshot = void 0;
+		this.ref = void 0;
+		this._actorScope = void 0;
+		this.systemId = void 0;
+		/** The globally unique process ID for this invocation. */
+		this.sessionId = void 0;
+		/** The system to which this actor belongs. */
+		this.system = void 0;
+		this._doneEvent = void 0;
+		this.src = void 0;
+		this._deferred = [];
+		const resolvedOptions = {
+			...defaultOptions,
+			...options
+		};
+		const { clock, logger, parent, syncSnapshot, id, systemId, inspect } = resolvedOptions;
+		this.system = parent ? parent.system : createSystem(this, {
+			clock,
+			logger
+		});
+		if (inspect && !parent) this.system.inspect(toObserver(inspect));
+		this.sessionId = this.system._bookId();
+		this.id = id ?? this.sessionId;
+		this.logger = options?.logger ?? this.system._logger;
+		this.clock = options?.clock ?? this.system._clock;
+		this._parent = parent;
+		this._syncSnapshot = syncSnapshot;
+		this.options = resolvedOptions;
+		this.src = resolvedOptions.src ?? logic;
+		this.ref = this;
+		this._actorScope = {
 			self: this,
 			id: this.id,
 			sessionId: this.sessionId,
 			logger: this.logger,
-			defer: (e) => {
-				this._deferred.push(e);
+			defer: (fn) => {
+				this._deferred.push(fn);
 			},
 			system: this.system,
-			stopChild: (e) => {
-				if (e._parent !== this) throw Error(`Cannot stop child actor ${e.id} of ${this.id} because it is not a child`);
-				e._stop();
+			stopChild: (child) => {
+				if (child._parent !== this) throw new Error(`Cannot stop child actor ${child.id} of ${this.id} because it is not a child`);
+				child._stop();
 			},
-			emit: (e) => {
-				let t = this.eventListeners.get(e.type), n = this.eventListeners.get("*");
-				if (!t && !n) return;
-				let r = [...t ? t.values() : [], ...n ? n.values() : []];
-				for (let t of r) try {
-					t(e);
-				} catch (e) {
-					reportUnhandledError(e);
+			emit: (emittedEvent) => {
+				const listeners = this.eventListeners.get(emittedEvent.type);
+				const wildcardListener = this.eventListeners.get("*");
+				if (!listeners && !wildcardListener) return;
+				const allListeners = [...listeners ? listeners.values() : [], ...wildcardListener ? wildcardListener.values() : []];
+				for (const handler of allListeners) try {
+					handler(emittedEvent);
+				} catch (err) {
+					reportUnhandledError(err);
 				}
 			},
-			actionExecutor: (e) => {
-				let exec = () => {
-					if (this._actorScope.system._sendInspectionEvent({
+			actionExecutor: (action) => {
+				const exec = () => {
+					this._actorScope.system._sendInspectionEvent({
 						type: "@xstate.action",
 						actorRef: this,
 						action: {
-							type: e.type,
-							params: e.params
+							type: action.type,
+							params: action.params
 						}
-					}), !e.exec) return;
-					let t = m;
+					});
+					if (!action.exec) return;
+					const saveExecutingCustomAction = executingCustomAction;
 					try {
-						m = !0, e.exec(e.info, e.params);
+						executingCustomAction = true;
+						action.exec(action.info, action.params);
 					} finally {
-						m = t;
+						executingCustomAction = saveExecutingCustomAction;
 					}
 				};
-				this._processingStatus === h.Running ? exec() : this._deferred.push(exec);
+				if (this._processingStatus === ProcessingStatus.Running) exec();
+				else this._deferred.push(exec);
 			}
-		}, this.send = this.send.bind(this), this.system._sendInspectionEvent({
+		};
+		this.send = this.send.bind(this);
+		this.system._sendInspectionEvent({
 			type: "@xstate.actor",
 			actorRef: this
-		}), c && (this.systemId = c, this.system._set(c, this)), this._initState(t?.snapshot ?? t?.state), c && this._snapshot.status !== "active" && this.system._unregister(this);
+		});
+		if (systemId) {
+			this.systemId = systemId;
+			this.system._set(systemId, this);
+		}
+		this._initState(options?.snapshot ?? options?.state);
+		if (systemId && this._snapshot.status !== "active") this.system._unregister(this);
 	}
-	_initState(e) {
+	_initState(persistedState) {
 		try {
-			this._snapshot = e ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(e, this._actorScope) : e : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
-		} catch (e) {
+			this._snapshot = persistedState ? this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState : this.logic.getInitialSnapshot(this._actorScope, this.options?.input);
+		} catch (err) {
 			this._snapshot = {
 				status: "error",
 				output: void 0,
-				error: e
+				error: err
 			};
 		}
 	}
-	update(e, t) {
-		this._snapshot = e;
-		let n;
-		for (; n = this._deferred.shift();) try {
-			n();
-		} catch (t) {
-			this._deferred.length = 0, this._snapshot = {
-				...e,
+	update(snapshot, event) {
+		this._snapshot = snapshot;
+		let deferredFn;
+		while (deferredFn = this._deferred.shift()) try {
+			deferredFn();
+		} catch (err) {
+			this._deferred.length = 0;
+			this._snapshot = {
+				...snapshot,
 				status: "error",
-				error: t
+				error: err
 			};
 		}
 		switch (this._snapshot.status) {
 			case "active":
-				for (let t of this.observers) try {
-					t.next?.(e);
-				} catch (e) {
-					reportUnhandledError(e);
+				for (const observer of this.observers) try {
+					observer.next?.(snapshot);
+				} catch (err) {
+					reportUnhandledError(err);
 				}
 				break;
 			case "done":
-				for (let t of this.observers) try {
-					t.next?.(e);
-				} catch (e) {
-					reportUnhandledError(e);
+				for (const observer of this.observers) try {
+					observer.next?.(snapshot);
+				} catch (err) {
+					reportUnhandledError(err);
 				}
-				this._stopProcedure(), this._complete(), this._doneEvent = createDoneActorEvent(this.id, this._snapshot.output), this._parent && this.system._relay(this, this._parent, this._doneEvent);
+				this._stopProcedure();
+				this._complete();
+				this._doneEvent = createDoneActorEvent(this.id, this._snapshot.output);
+				if (this._parent) this.system._relay(this, this._parent, this._doneEvent);
 				break;
 			case "error": this._error(this._snapshot.error);
 		}
 		this.system._sendInspectionEvent({
 			type: "@xstate.snapshot",
 			actorRef: this,
-			event: t,
-			snapshot: e
+			event,
+			snapshot
 		});
 	}
-	subscribe(e, t, n) {
-		let r = toObserver(e, t, n);
-		if (this._processingStatus !== h.Stopped) this.observers.add(r);
+	/**
+	* Subscribe an observer to an actor’s snapshot values.
+	*
+	* @remarks
+	* The observer will receive the actor’s snapshot value when it is emitted.
+	* The observer can be:
+	*
+	* - A plain function that receives the latest snapshot, or
+	* - An observer object whose `.next(snapshot)` method receives the latest
+	*   snapshot
+	*
+	* @example
+	*
+	* ```ts
+	* // Observer as a plain function
+	* const subscription = actor.subscribe((snapshot) => {
+	*   console.log(snapshot);
+	* });
+	* ```
+	*
+	* @example
+	*
+	* ```ts
+	* // Observer as an object
+	* const subscription = actor.subscribe({
+	*   next(snapshot) {
+	*     console.log(snapshot);
+	*   },
+	*   error(err) {
+	*     // ...
+	*   },
+	*   complete() {
+	*     // ...
+	*   }
+	* });
+	* ```
+	*
+	* The return value of `actor.subscribe(observer)` is a subscription object
+	* that has an `.unsubscribe()` method. You can call
+	* `subscription.unsubscribe()` to unsubscribe the observer:
+	*
+	* @example
+	*
+	* ```ts
+	* const subscription = actor.subscribe((snapshot) => {
+	*   // ...
+	* });
+	*
+	* // Unsubscribe the observer
+	* subscription.unsubscribe();
+	* ```
+	*
+	* When the actor is stopped, all of its observers will automatically be
+	* unsubscribed.
+	*
+	* @param observer - Either a plain function that receives the latest
+	*   snapshot, or an observer object whose `.next(snapshot)` method receives
+	*   the latest snapshot
+	*/
+	subscribe(nextListenerOrObserver, errorListener, completeListener) {
+		const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
+		if (this._processingStatus !== ProcessingStatus.Stopped) this.observers.add(observer);
 		else switch (this._snapshot.status) {
 			case "done":
 				try {
-					r.complete?.();
-				} catch (e) {
-					reportUnhandledError(e);
+					observer.complete?.();
+				} catch (err) {
+					reportUnhandledError(err);
 				}
 				break;
 			case "error": {
-				let e = this._snapshot.error;
-				if (!r.error) reportUnhandledError(e);
+				const err = this._snapshot.error;
+				if (!observer.error) reportUnhandledError(err);
 				else try {
-					r.error(e);
-				} catch (e) {
-					reportUnhandledError(e);
+					observer.error(err);
+				} catch (err) {
+					reportUnhandledError(err);
 				}
 				break;
 			}
 		}
 		return { unsubscribe: () => {
-			this.observers.delete(r);
+			this.observers.delete(observer);
 		} };
 	}
-	on(e, t) {
-		let n = this.eventListeners.get(e);
-		n || (n = /* @__PURE__ */ new Set(), this.eventListeners.set(e, n));
-		let r = t.bind(void 0);
-		return n.add(r), { unsubscribe: () => {
-			n.delete(r);
+	on(type, handler) {
+		let listeners = this.eventListeners.get(type);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.eventListeners.set(type, listeners);
+		}
+		const wrappedHandler = handler.bind(void 0);
+		listeners.add(wrappedHandler);
+		return { unsubscribe: () => {
+			listeners.delete(wrappedHandler);
 		} };
 	}
-	select(e, t = Object.is) {
+	select(selector, equalityFn = Object.is) {
 		return {
-			subscribe: (n) => {
-				let r = toObserver(n), i = e(this.getSnapshot());
-				return this.subscribe((n) => {
-					let a = e(n);
-					t(i, a) || (i = a, r.next?.(a));
+			subscribe: (observerOrFn) => {
+				const observer = toObserver(observerOrFn);
+				let previousSelected = selector(this.getSnapshot());
+				return this.subscribe((snapshot) => {
+					const nextSelected = selector(snapshot);
+					if (!equalityFn(previousSelected, nextSelected)) {
+						previousSelected = nextSelected;
+						observer.next?.(nextSelected);
+					}
 				});
 			},
-			get: () => e(this.getSnapshot())
+			get: () => selector(this.getSnapshot())
 		};
 	}
+	/** Starts the Actor from the initial state */
 	start() {
-		if (this._processingStatus === h.Running) return this;
-		this._syncSnapshot && this.subscribe({
-			next: (e) => {
-				e.status === "active" && this.system._relay(this, this._parent, {
+		if (this._processingStatus === ProcessingStatus.Running) return this;
+		if (this._syncSnapshot) this.subscribe({
+			next: (snapshot) => {
+				if (snapshot.status === "active") this.system._relay(this, this._parent, {
 					type: `xstate.snapshot.${this.id}`,
-					snapshot: e
+					snapshot
 				});
 			},
 			error: () => {}
-		}), this.system._register(this.sessionId, this), this.systemId && this.system._set(this.systemId, this), this._processingStatus = h.Running;
-		let e = createInitEvent(this.options.input);
-		switch (this.system._sendInspectionEvent({
+		});
+		this.system._register(this.sessionId, this);
+		if (this.systemId) this.system._set(this.systemId, this);
+		this._processingStatus = ProcessingStatus.Running;
+		const initEvent = createInitEvent(this.options.input);
+		this.system._sendInspectionEvent({
 			type: "@xstate.event",
 			sourceRef: this._parent,
 			actorRef: this,
-			event: e
-		}), this._snapshot.status) {
-			case "done": return this.update(this._snapshot, e), this;
-			case "error": return this._error(this._snapshot.error), this;
+			event: initEvent
+		});
+		switch (this._snapshot.status) {
+			case "done":
+				this.update(this._snapshot, initEvent);
+				return this;
+			case "error":
+				this._error(this._snapshot.error);
+				return this;
 		}
-		if (this._parent || this.system.start(), this.logic.start) try {
+		if (!this._parent) this.system.start();
+		if (this.logic.start) try {
 			this.logic.start(this._snapshot, this._actorScope);
-		} catch (e) {
-			return this._snapshot = {
+		} catch (err) {
+			this._snapshot = {
 				...this._snapshot,
 				status: "error",
-				error: e
-			}, this._error(e), this;
+				error: err
+			};
+			this._error(err);
+			return this;
 		}
-		return this.update(this._snapshot, e), this.options.devTools && this.attachDevTools(), this.mailbox.start(), this;
+		this.update(this._snapshot, initEvent);
+		if (this.options.devTools) this.attachDevTools();
+		this.mailbox.start();
+		return this;
 	}
-	_process(e) {
-		let t, n;
+	_process(event) {
+		let nextState;
+		let caughtError;
 		try {
-			t = this.logic.transition(this._snapshot, e, this._actorScope);
-		} catch (e) {
-			n = { err: e };
+			nextState = this.logic.transition(this._snapshot, event, this._actorScope);
+		} catch (err) {
+			caughtError = { err };
 		}
-		if (n) {
-			let { err: e } = n;
+		if (caughtError) {
+			const { err } = caughtError;
 			this._snapshot = {
 				...this._snapshot,
 				status: "error",
-				error: e
-			}, this._error(e);
+				error: err
+			};
+			this._error(err);
 			return;
 		}
-		this.update(t, e), e.type === "xstate.stop" && (this._stopProcedure(), this._complete());
+		this.update(nextState, event);
+		if (event.type === "xstate.stop") {
+			this._stopProcedure();
+			this._complete();
+		}
 	}
 	_stop() {
-		return this._processingStatus === h.Stopped ? this : (this.mailbox.clear(), this._processingStatus === h.NotStarted ? (this._processingStatus = h.Stopped, this) : (this.mailbox.enqueue({ type: d }), this));
+		if (this._processingStatus === ProcessingStatus.Stopped) return this;
+		this.mailbox.clear();
+		if (this._processingStatus === ProcessingStatus.NotStarted) {
+			this._processingStatus = ProcessingStatus.Stopped;
+			return this;
+		}
+		this.mailbox.enqueue({ type: XSTATE_STOP });
+		return this;
 	}
+	/** Stops the Actor and unsubscribe all listeners. */
 	stop() {
-		if (this._parent) throw Error("A non-root actor cannot be stopped directly.");
+		if (this._parent) throw new Error("A non-root actor cannot be stopped directly.");
 		return this._stop();
 	}
 	_complete() {
-		for (let e of this.observers) try {
-			e.complete?.();
-		} catch (e) {
-			reportUnhandledError(e);
+		for (const observer of this.observers) try {
+			observer.complete?.();
+		} catch (err) {
+			reportUnhandledError(err);
 		}
-		this.observers.clear(), this.eventListeners.clear();
+		this.observers.clear();
+		this.eventListeners.clear();
 	}
-	_reportError(e) {
+	_reportError(err) {
 		if (!this.observers.size) {
-			this._parent || reportUnhandledError(e), this.eventListeners.clear();
+			if (!this._parent) reportUnhandledError(err);
+			this.eventListeners.clear();
 			return;
 		}
-		let t = !1;
-		for (let n of this.observers) {
-			let r = n.error;
-			t ||= !r;
+		let reportError = false;
+		for (const observer of this.observers) {
+			const errorListener = observer.error;
+			reportError ||= !errorListener;
 			try {
-				r?.(e);
-			} catch (e) {
-				reportUnhandledError(e);
+				errorListener?.(err);
+			} catch (err2) {
+				reportUnhandledError(err2);
 			}
 		}
-		this.observers.clear(), this.eventListeners.clear(), t && reportUnhandledError(e);
+		this.observers.clear();
+		this.eventListeners.clear();
+		if (reportError) reportUnhandledError(err);
 	}
-	_error(e) {
-		this._stopProcedure(), this._reportError(e), this._parent && this.system._relay(this, this._parent, createErrorActorEvent(this.id, e));
+	_error(err) {
+		this._stopProcedure();
+		this._reportError(err);
+		if (this._parent) this.system._relay(this, this._parent, createErrorActorEvent(this.id, err));
 	}
 	_stopProcedure() {
-		return this._processingStatus === h.Running ? (this.system.scheduler.cancelAll(this), this.mailbox.clear(), this.mailbox = new Mailbox(this._process.bind(this)), this._processingStatus = h.Stopped, this.system._unregister(this), this) : this;
+		if (this._processingStatus !== ProcessingStatus.Running) return this;
+		this.system.scheduler.cancelAll(this);
+		this.mailbox.clear();
+		this.mailbox = new Mailbox(this._process.bind(this));
+		this._processingStatus = ProcessingStatus.Stopped;
+		this.system._unregister(this);
+		return this;
 	}
-	_send(e) {
-		this._processingStatus !== h.Stopped && this.mailbox.enqueue(e);
+	/** @internal */
+	_send(event) {
+		if (this._processingStatus === ProcessingStatus.Stopped) return;
+		this.mailbox.enqueue(event);
 	}
-	send(e) {
-		this.system._relay(void 0, this, e);
+	/**
+	* Sends an event to the running Actor to trigger a transition.
+	*
+	* @param event The event to send
+	*/
+	send(event) {
+		this.system._relay(void 0, this, event);
 	}
 	attachDevTools() {
-		let { devTools: e } = this.options;
-		e && (typeof e == "function" ? e : devToolsAdapter)(this);
+		const { devTools } = this.options;
+		if (devTools) (typeof devTools === "function" ? devTools : devToolsAdapter)(this);
 	}
 	toJSON() {
 		return {
@@ -525,988 +840,1763 @@ var m = !1, h = /*#__PURE__*/ function(e) {
 			id: this.id
 		};
 	}
-	getPersistedSnapshot(e) {
-		return this.logic.getPersistedSnapshot(this._snapshot, e);
-	}
-	[f]() {
+	/**
+	* Obtain the internal state of the actor, which can be persisted.
+	*
+	* @remarks
+	* The internal state can be persisted from any actor, not only machines.
+	*
+	* Note that the persisted state is not the same as the snapshot from
+	* {@link Actor.getSnapshot}. Persisted state represents the internal state of
+	* the actor, while snapshots represent the actor's last emitted value.
+	*
+	* Can be restored with {@link ActorOptions.state}
+	* @see https://stately.ai/docs/persistence
+	*/
+	getPersistedSnapshot(options) {
+		return this.logic.getPersistedSnapshot(this._snapshot, options);
+	}
+	[symbolObservable]() {
 		return this;
 	}
+	/**
+	* Read an actor’s snapshot synchronously.
+	*
+	* @remarks
+	* The snapshot represent an actor's last emitted value.
+	*
+	* When an actor receives an event, its internal state may change. An actor
+	* may emit a snapshot when a state transition occurs.
+	*
+	* Note that some actors, such as callback actors generated with
+	* `fromCallback`, will not emit snapshots.
+	* @see {@link Actor.subscribe} to subscribe to an actor’s snapshot values.
+	* @see {@link Actor.getPersistedSnapshot} to persist the internal state of an actor (which is more than just a snapshot).
+	*/
 	getSnapshot() {
 		return this._snapshot;
 	}
 };
-function createActor(e, ...[t]) {
-	return new Actor(e, t);
-}
-function resolveCancel(e, t, n, r, { sendId: i }) {
+/**
+* Creates a new actor instance for the given actor logic with the provided
+* options, if any.
+*
+* @remarks
+* When you create an actor from actor logic via `createActor(logic)`, you
+* implicitly create an actor system where the created actor is the root actor.
+* Any actors spawned from this root actor and its descendants are part of that
+* actor system.
+* @example
+*
+* ```ts
+* import { createActor } from 'xstate';
+* import { someActorLogic } from './someActorLogic.ts';
+*
+* // Creating the actor, which implicitly creates an actor system with itself as the root actor
+* const actor = createActor(someActorLogic);
+*
+* actor.subscribe((snapshot) => {
+*   console.log(snapshot);
+* });
+*
+* // Actors must be started by calling `actor.start()`, which will also start the actor system.
+* actor.start();
+*
+* // Actors can receive events
+* actor.send({ type: 'someEvent' });
+*
+* // You can stop root actors by calling `actor.stop()`, which will also stop the actor system and all actors in that system.
+* actor.stop();
+* ```
+*
+* @param logic - The actor logic to create an actor from. For a state machine
+*   actor logic creator, see {@link createMachine}. Other actor logic creators
+*   include {@link fromCallback}, {@link fromEventObservable},
+*   {@link fromObservable}, {@link fromPromise}, and {@link fromTransition}.
+* @param options - Actor options
+*/
+function createActor(logic, ...[options]) {
+	return new Actor(logic, options);
+}
+/**
+* @deprecated Use `Actor` instead.
+* @alias
+*/
+function resolveCancel(_, snapshot, actionArgs, actionParams, { sendId }) {
 	return [
-		t,
-		{ sendId: typeof i == "function" ? i(n, r) : i },
+		snapshot,
+		{ sendId: typeof sendId === "function" ? sendId(actionArgs, actionParams) : sendId },
 		void 0
 	];
 }
-function executeCancel(e, t) {
-	e.defer(() => {
-		e.system.scheduler.cancel(e.self, t.sendId);
+function executeCancel(actorScope, params) {
+	actorScope.defer(() => {
+		actorScope.system.scheduler.cancel(actorScope.self, params.sendId);
 	});
 }
-function cancel(e) {
-	function cancel(e, t) {}
-	return cancel.type = "xstate.cancel", cancel.sendId = e, cancel.resolve = resolveCancel, cancel.execute = executeCancel, cancel;
-}
-function resolveSpawn(e, t, n, r, { id: i, systemId: a, src: o, input: s, syncSnapshot: c }) {
-	let l = typeof o == "string" ? resolveReferencedActor(t.machine, o) : o, u = typeof i == "function" ? i(n) : i, d, f;
-	return l && (f = typeof s == "function" ? s({
-		context: t.context,
-		event: n.event,
-		self: e.self
-	}) : s, d = createActor(l, {
-		id: u,
-		src: o,
-		parent: e.self,
-		syncSnapshot: c,
-		systemId: a,
-		input: f
-	})), [
-		cloneMachineSnapshot(t, { children: {
-			...t.children,
-			[u]: d
+/**
+* Cancels a delayed `sendTo(...)` action that is waiting to be executed. The
+* canceled `sendTo(...)` action will not send its event or execute, unless the
+* `delay` has already elapsed before `cancel(...)` is called.
+*
+* @example
+*
+* ```ts
+* import { createMachine, sendTo, cancel } from 'xstate';
+*
+* const machine = createMachine({
+*   // ...
+*   on: {
+*     sendEvent: {
+*       actions: sendTo(
+*         'some-actor',
+*         { type: 'someEvent' },
+*         {
+*           id: 'some-id',
+*           delay: 1000
+*         }
+*       )
+*     },
+*     cancelEvent: {
+*       actions: cancel('some-id')
+*     }
+*   }
+* });
+* ```
+*
+* @param sendId The `id` of the `sendTo(...)` action to cancel.
+*/
+function cancel(sendId) {
+	function cancel(_args, _params) {}
+	cancel.type = "xstate.cancel";
+	cancel.sendId = sendId;
+	cancel.resolve = resolveCancel;
+	cancel.execute = executeCancel;
+	return cancel;
+}
+function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, { id, systemId, src, input, syncSnapshot }) {
+	const logic = typeof src === "string" ? resolveReferencedActor(snapshot.machine, src) : src;
+	const resolvedId = typeof id === "function" ? id(actionArgs) : id;
+	let actorRef;
+	let resolvedInput = void 0;
+	if (logic) {
+		resolvedInput = typeof input === "function" ? input({
+			context: snapshot.context,
+			event: actionArgs.event,
+			self: actorScope.self
+		}) : input;
+		actorRef = createActor(logic, {
+			id: resolvedId,
+			src,
+			parent: actorScope.self,
+			syncSnapshot,
+			systemId,
+			input: resolvedInput
+		});
+	}
+	return [
+		cloneMachineSnapshot(snapshot, { children: {
+			...snapshot.children,
+			[resolvedId]: actorRef
 		} }),
 		{
-			id: i,
-			systemId: a,
-			actorRef: d,
-			src: o,
-			input: f
+			id,
+			systemId,
+			actorRef,
+			src,
+			input: resolvedInput
 		},
 		void 0
 	];
 }
-function executeSpawn(e, { actorRef: t }) {
-	t && e.defer(() => {
-		t._processingStatus !== h.Stopped && t.start();
+function executeSpawn(actorScope, { actorRef }) {
+	if (!actorRef) return;
+	actorScope.defer(() => {
+		if (actorRef._processingStatus === ProcessingStatus.Stopped) return;
+		actorRef.start();
 	});
 }
-function spawnChild(...[e, { id: t, systemId: n, input: r, syncSnapshot: i = !1 } = {}]) {
-	function spawnChild(e, t) {}
-	return spawnChild.type = "xstate.spawnChild", spawnChild.id = t, spawnChild.systemId = n, spawnChild.src = e, spawnChild.input = r, spawnChild.syncSnapshot = i, spawnChild.resolve = resolveSpawn, spawnChild.execute = executeSpawn, spawnChild;
-}
-function resolveStop(e, t, n, r, { actorRef: i }) {
-	let a = typeof i == "function" ? i(n, r) : i, o = typeof a == "string" ? t.children[a] : a, s = t.children;
-	return o && (s = { ...s }, delete s[o.id]), [
-		cloneMachineSnapshot(t, { children: s }),
-		o,
+function spawnChild(...[src, { id, systemId, input, syncSnapshot = false } = {}]) {
+	function spawnChild(_args, _params) {}
+	spawnChild.type = "xstate.spawnChild";
+	spawnChild.id = id;
+	spawnChild.systemId = systemId;
+	spawnChild.src = src;
+	spawnChild.input = input;
+	spawnChild.syncSnapshot = syncSnapshot;
+	spawnChild.resolve = resolveSpawn;
+	spawnChild.execute = executeSpawn;
+	return spawnChild;
+}
+function resolveStop(_, snapshot, args, actionParams, { actorRef }) {
+	const actorRefOrString = typeof actorRef === "function" ? actorRef(args, actionParams) : actorRef;
+	const resolvedActorRef = typeof actorRefOrString === "string" ? snapshot.children[actorRefOrString] : actorRefOrString;
+	let children = snapshot.children;
+	if (resolvedActorRef) {
+		children = { ...children };
+		delete children[resolvedActorRef.id];
+	}
+	return [
+		cloneMachineSnapshot(snapshot, { children }),
+		resolvedActorRef,
 		void 0
 	];
 }
-function unregisterRecursively(e, t) {
-	let n = t.getSnapshot();
-	if (n && "children" in n) for (let t of Object.values(n.children)) unregisterRecursively(e, t);
-	e.system._unregister(t);
-}
-function executeStop(e, t) {
-	if (t) {
-		if (unregisterRecursively(e, t), t._processingStatus !== h.Running) {
-			e.stopChild(t);
-			return;
-		}
-		e.defer(() => {
-			e.stopChild(t);
-		});
-	}
-}
-function stopChild(e) {
-	function stop(e, t) {}
-	return stop.type = "xstate.stopChild", stop.actorRef = e, stop.resolve = resolveStop, stop.execute = executeStop, stop;
-}
-function checkNot(e, { context: t, event: n }, { guards: r }) {
-	return !evaluateGuard(r[0], t, n, e);
-}
-function not(e) {
-	function not(e, t) {
-		return !1;
-	}
-	return not.check = checkNot, not.guards = [e], not;
-}
-function checkAnd(e, { context: t, event: n }, { guards: r }) {
-	return r.every((r) => evaluateGuard(r, t, n, e));
-}
-function and(e) {
-	function and(e, t) {
-		return !1;
-	}
-	return and.check = checkAnd, and.guards = e, and;
-}
-function checkOr(e, { context: t, event: n }, { guards: r }) {
-	return r.some((r) => evaluateGuard(r, t, n, e));
+function unregisterRecursively(actorScope, actorRef) {
+	const snapshot = actorRef.getSnapshot();
+	if (snapshot && "children" in snapshot) for (const child of Object.values(snapshot.children)) unregisterRecursively(actorScope, child);
+	actorScope.system._unregister(actorRef);
 }
-function or(e) {
-	function or(e, t) {
-		return !1;
+function executeStop(actorScope, actorRef) {
+	if (!actorRef) return;
+	unregisterRecursively(actorScope, actorRef);
+	if (actorRef._processingStatus !== ProcessingStatus.Running) {
+		actorScope.stopChild(actorRef);
+		return;
 	}
-	return or.check = checkOr, or.guards = e, or;
-}
-function evaluateGuard(e, t, n, r) {
-	let { machine: i } = r, a = typeof e == "function", o = a ? e : i.implementations.guards[typeof e == "string" ? e : e.type];
-	if (!a && !o) throw Error(`Guard '${typeof e == "string" ? e : e.type}' is not implemented.'.`);
-	if (typeof o != "function") return evaluateGuard(o, t, n, r);
-	let s = {
-		context: t,
-		event: n
-	}, c = a || typeof e == "string" ? void 0 : "params" in e ? typeof e.params == "function" ? e.params({
-		context: t,
-		event: n
-	}) : e.params : void 0;
-	return "check" in o ? o.check(r, s, o) : o(s, c);
-}
-function isAtomicStateNode(e) {
-	return e.type === "atomic" || e.type === "final";
-}
-function getChildren(e) {
-	return Object.values(e.states).filter((e) => e.type !== "history");
-}
-function getProperAncestors(e, t) {
-	let n = [];
-	if (t === e) return n;
-	let r = e.parent;
-	for (; r && r !== t;) n.push(r), r = r.parent;
-	return n;
+	actorScope.defer(() => {
+		actorScope.stopChild(actorRef);
+	});
 }
-function getAllStateNodes(e) {
-	let t = new Set(e), n = getAdjList(t);
-	for (let e of t) if (e.type === "compound" && (!n.get(e) || !n.get(e).length)) getInitialStateNodesWithTheirAncestors(e).forEach((e) => t.add(e));
-	else if (e.type === "parallel") {
-		for (let n of getChildren(e)) if (n.type !== "history" && !t.has(n)) {
-			let e = getInitialStateNodesWithTheirAncestors(n);
-			for (let n of e) t.add(n);
+/**
+* Stops a child actor.
+*
+* @param actorRef The actor to stop.
+*/
+function stopChild(actorRef) {
+	function stop(_args, _params) {}
+	stop.type = "xstate.stopChild";
+	stop.actorRef = actorRef;
+	stop.resolve = resolveStop;
+	stop.execute = executeStop;
+	return stop;
+}
+function checkNot(snapshot, { context, event }, { guards }) {
+	return !evaluateGuard(guards[0], context, event, snapshot);
+}
+/**
+* Higher-order guard that evaluates to `true` if the `guard` passed to it
+* evaluates to `false`.
+*
+* @category Guards
+* @example
+*
+* ```ts
+* import { setup, not } from 'xstate';
+*
+* const machine = setup({
+*   guards: {
+*     someNamedGuard: () => false
+*   }
+* }).createMachine({
+*   on: {
+*     someEvent: {
+*       guard: not('someNamedGuard'),
+*       actions: () => {
+*         // will be executed if guard in `not(...)`
+*         // evaluates to `false`
+*       }
+*     }
+*   }
+* });
+* ```
+*
+* @returns A guard
+*/
+function not(guard) {
+	function not(_args, _params) {
+		return false;
+	}
+	not.check = checkNot;
+	not.guards = [guard];
+	return not;
+}
+function checkAnd(snapshot, { context, event }, { guards }) {
+	return guards.every((guard) => evaluateGuard(guard, context, event, snapshot));
+}
+/**
+* Higher-order guard that evaluates to `true` if all `guards` passed to it
+* evaluate to `true`.
+*
+* @category Guards
+* @example
+*
+* ```ts
+* import { setup, and } from 'xstate';
+*
+* const machine = setup({
+*   guards: {
+*     someNamedGuard: () => true
+*   }
+* }).createMachine({
+*   on: {
+*     someEvent: {
+*       guard: and([({ context }) => context.value > 0, 'someNamedGuard']),
+*       actions: () => {
+*         // will be executed if all guards in `and(...)`
+*         // evaluate to true
+*       }
+*     }
+*   }
+* });
+* ```
+*
+* @returns A guard action object
+*/
+function and(guards) {
+	function and(_args, _params) {
+		return false;
+	}
+	and.check = checkAnd;
+	and.guards = guards;
+	return and;
+}
+function checkOr(snapshot, { context, event }, { guards }) {
+	return guards.some((guard) => evaluateGuard(guard, context, event, snapshot));
+}
+/**
+* Higher-order guard that evaluates to `true` if any of the `guards` passed to
+* it evaluate to `true`.
+*
+* @category Guards
+* @example
+*
+* ```ts
+* import { setup, or } from 'xstate';
+*
+* const machine = setup({
+*   guards: {
+*     someNamedGuard: () => true
+*   }
+* }).createMachine({
+*   on: {
+*     someEvent: {
+*       guard: or([({ context }) => context.value > 0, 'someNamedGuard']),
+*       actions: () => {
+*         // will be executed if any of the guards in `or(...)`
+*         // evaluate to true
+*       }
+*     }
+*   }
+* });
+* ```
+*
+* @returns A guard action object
+*/
+function or(guards) {
+	function or(_args, _params) {
+		return false;
+	}
+	or.check = checkOr;
+	or.guards = guards;
+	return or;
+}
+function evaluateGuard(guard, context, event, snapshot) {
+	const { machine } = snapshot;
+	const isInline = typeof guard === "function";
+	const resolved = isInline ? guard : machine.implementations.guards[typeof guard === "string" ? guard : guard.type];
+	if (!isInline && !resolved) throw new Error(`Guard '${typeof guard === "string" ? guard : guard.type}' is not implemented.'.`);
+	if (typeof resolved !== "function") return evaluateGuard(resolved, context, event, snapshot);
+	const guardArgs = {
+		context,
+		event
+	};
+	const guardParams = isInline || typeof guard === "string" ? void 0 : "params" in guard ? typeof guard.params === "function" ? guard.params({
+		context,
+		event
+	}) : guard.params : void 0;
+	if (!("check" in resolved)) return resolved(guardArgs, guardParams);
+	return resolved.check(snapshot, guardArgs, resolved);
+}
+function isAtomicStateNode(stateNode) {
+	return stateNode.type === "atomic" || stateNode.type === "final";
+}
+function getChildren(stateNode) {
+	return Object.values(stateNode.states).filter((sn) => sn.type !== "history");
+}
+function getProperAncestors(stateNode, toStateNode) {
+	const ancestors = [];
+	if (toStateNode === stateNode) return ancestors;
+	let m = stateNode.parent;
+	while (m && m !== toStateNode) {
+		ancestors.push(m);
+		m = m.parent;
+	}
+	return ancestors;
+}
+function getAllStateNodes(stateNodes) {
+	const nodeSet = new Set(stateNodes);
+	const adjList = getAdjList(nodeSet);
+	for (const s of nodeSet) if (s.type === "compound" && (!adjList.get(s) || !adjList.get(s).length)) getInitialStateNodesWithTheirAncestors(s).forEach((sn) => nodeSet.add(sn));
+	else if (s.type === "parallel") for (const child of getChildren(s)) {
+		if (child.type === "history") continue;
+		if (!nodeSet.has(child)) {
+			const initialStates = getInitialStateNodesWithTheirAncestors(child);
+			for (const initialStateNode of initialStates) nodeSet.add(initialStateNode);
 		}
 	}
-	for (let e of t) {
-		let n = e.parent;
-		for (; n;) t.add(n), n = n.parent;
+	for (const s of nodeSet) {
+		let m = s.parent;
+		while (m) {
+			nodeSet.add(m);
+			m = m.parent;
+		}
 	}
-	return t;
+	return nodeSet;
 }
-function getValueFromAdj(e, t) {
-	let n = t.get(e);
-	if (!n) return {};
-	if (e.type === "compound") {
-		let e = n[0];
-		if (e) {
-			if (isAtomicStateNode(e)) return e.key;
+function getValueFromAdj(baseNode, adjList) {
+	const childStateNodes = adjList.get(baseNode);
+	if (!childStateNodes) return {};
+	if (baseNode.type === "compound") {
+		const childStateNode = childStateNodes[0];
+		if (childStateNode) {
+			if (isAtomicStateNode(childStateNode)) return childStateNode.key;
 		} else return {};
 	}
-	let r = {};
-	for (let e of n) r[e.key] = getValueFromAdj(e, t);
-	return r;
-}
-function getAdjList(e) {
-	let t = /* @__PURE__ */ new Map();
-	for (let n of e) t.has(n) || t.set(n, []), n.parent && (t.has(n.parent) || t.set(n.parent, []), t.get(n.parent).push(n));
-	return t;
-}
-function getStateValue(e, t) {
-	return getValueFromAdj(e, getAdjList(getAllStateNodes(t)));
-}
-function isInFinalState(e, t) {
-	return t.type === "compound" ? getChildren(t).some((t) => t.type === "final" && e.has(t)) : t.type === "parallel" ? getChildren(t).every((t) => isInFinalState(e, t)) : t.type === "final";
-}
-var isStateId = (e) => e[0] === c;
-function getCandidates(e, t) {
-	let n = e.transitions.get(t), r = [...e.transitions.keys()].filter((e) => e !== t && matchesEventDescriptor(t, e)).sort((e, t) => t.length - e.length).flatMap((t) => e.transitions.get(t));
-	return n ? [...n, ...r] : r;
-}
-function getDelayedTransitions(e) {
-	let t = e.config.after;
-	if (!t) return [];
-	let mutateEntryExit = (t) => {
-		let n = createAfterEvent(t, e.id), r = n.type;
-		return e.entry.push(raise(n, {
-			id: r,
-			delay: t
-		})), e.exit.push(cancel(r)), r;
+	const stateValue = {};
+	for (const childStateNode of childStateNodes) stateValue[childStateNode.key] = getValueFromAdj(childStateNode, adjList);
+	return stateValue;
+}
+function getAdjList(stateNodes) {
+	const adjList = /* @__PURE__ */ new Map();
+	for (const s of stateNodes) {
+		if (!adjList.has(s)) adjList.set(s, []);
+		if (s.parent) {
+			if (!adjList.has(s.parent)) adjList.set(s.parent, []);
+			adjList.get(s.parent).push(s);
+		}
+	}
+	return adjList;
+}
+function getStateValue(rootNode, stateNodes) {
+	return getValueFromAdj(rootNode, getAdjList(getAllStateNodes(stateNodes)));
+}
+function isInFinalState(stateNodeSet, stateNode) {
+	if (stateNode.type === "compound") return getChildren(stateNode).some((s) => s.type === "final" && stateNodeSet.has(s));
+	if (stateNode.type === "parallel") return getChildren(stateNode).every((sn) => isInFinalState(stateNodeSet, sn));
+	return stateNode.type === "final";
+}
+var isStateId = (str) => str[0] === STATE_IDENTIFIER;
+function getCandidates(stateNode, receivedEventType) {
+	const exactMatch = stateNode.transitions.get(receivedEventType);
+	const wildcardCandidates = [...stateNode.transitions.keys()].filter((eventDescriptor) => eventDescriptor !== receivedEventType && matchesEventDescriptor(receivedEventType, eventDescriptor)).sort((a, b) => b.length - a.length).flatMap((key) => stateNode.transitions.get(key));
+	return exactMatch ? [...exactMatch, ...wildcardCandidates] : wildcardCandidates;
+}
+/** All delayed transitions from the config. */
+function getDelayedTransitions(stateNode) {
+	const afterConfig = stateNode.config.after;
+	if (!afterConfig) return [];
+	const mutateEntryExit = (delay) => {
+		const afterEvent = createAfterEvent(delay, stateNode.id);
+		const eventType = afterEvent.type;
+		stateNode.entry.push(raise(afterEvent, {
+			id: eventType,
+			delay
+		}));
+		stateNode.exit.push(cancel(eventType));
+		return eventType;
 	};
-	return Object.keys(t).flatMap((e) => {
-		let n = t[e], r = typeof n == "string" ? { target: n } : n, i = Number.isNaN(+e) ? e : +e, a = mutateEntryExit(i);
-		return toArray(r).map((e) => ({
-			...e,
-			event: a,
-			delay: i
+	return Object.keys(afterConfig).flatMap((delay) => {
+		const configTransition = afterConfig[delay];
+		const resolvedTransition = typeof configTransition === "string" ? { target: configTransition } : configTransition;
+		const resolvedDelay = Number.isNaN(+delay) ? delay : +delay;
+		const eventType = mutateEntryExit(resolvedDelay);
+		return toArray(resolvedTransition).map((transition) => ({
+			...transition,
+			event: eventType,
+			delay: resolvedDelay
 		}));
-	}).map((t) => {
-		let { delay: n } = t;
+	}).map((delayedTransition) => {
+		const { delay } = delayedTransition;
 		return {
-			...formatTransition(e, t.event, t),
-			delay: n
+			...formatTransition(stateNode, delayedTransition.event, delayedTransition),
+			delay
 		};
 	});
 }
-function formatTransition(e, t, n) {
-	let r = normalizeTarget(n.target), i = n.reenter ?? !1, a = resolveTarget(e, r), o = {
-		...n,
-		actions: toArray(n.actions),
-		guard: n.guard,
-		target: a,
-		source: e,
-		reenter: i,
-		eventType: t,
+function formatTransition(stateNode, descriptor, transitionConfig) {
+	const normalizedTarget = normalizeTarget(transitionConfig.target);
+	const reenter = transitionConfig.reenter ?? false;
+	const target = resolveTarget(stateNode, normalizedTarget);
+	const transition = {
+		...transitionConfig,
+		actions: toArray(transitionConfig.actions),
+		guard: transitionConfig.guard,
+		target,
+		source: stateNode,
+		reenter,
+		eventType: descriptor,
 		toJSON: () => ({
-			...o,
-			source: `#${e.id}`,
-			target: a ? a.map((e) => `#${e.id}`) : void 0
+			...transition,
+			source: `#${stateNode.id}`,
+			target: target ? target.map((t) => `#${t.id}`) : void 0
 		})
 	};
-	return o;
-}
-function formatTransitions(e) {
-	let t = /* @__PURE__ */ new Map();
-	if (e.config.on) for (let n of Object.keys(e.config.on)) {
-		if (n === "") throw Error("Null events (\"\") cannot be specified as a transition key. Use `always: { ... }` instead.");
-		let r = e.config.on[n];
-		t.set(n, toTransitionConfigArray(r).map((t) => formatTransition(e, n, t)));
-	}
-	if (e.config.onDone) {
-		let n = `xstate.done.state.${e.id}`;
-		t.set(n, toTransitionConfigArray(e.config.onDone).map((t) => formatTransition(e, n, t)));
-	}
-	for (let n of e.invoke) {
-		if (n.onDone) {
-			let r = `xstate.done.actor.${n.id}`;
-			t.set(r, toTransitionConfigArray(n.onDone).map((t) => formatTransition(e, r, t)));
+	return transition;
+}
+function formatTransitions(stateNode) {
+	const transitions = /* @__PURE__ */ new Map();
+	if (stateNode.config.on) for (const descriptor of Object.keys(stateNode.config.on)) {
+		if (descriptor === "") throw new Error("Null events (\"\") cannot be specified as a transition key. Use `always: { ... }` instead.");
+		const transitionsConfig = stateNode.config.on[descriptor];
+		transitions.set(descriptor, toTransitionConfigArray(transitionsConfig).map((t) => formatTransition(stateNode, descriptor, t)));
+	}
+	if (stateNode.config.onDone) {
+		const descriptor = `xstate.done.state.${stateNode.id}`;
+		transitions.set(descriptor, toTransitionConfigArray(stateNode.config.onDone).map((t) => formatTransition(stateNode, descriptor, t)));
+	}
+	for (const invokeDef of stateNode.invoke) {
+		if (invokeDef.onDone) {
+			const descriptor = `xstate.done.actor.${invokeDef.id}`;
+			transitions.set(descriptor, toTransitionConfigArray(invokeDef.onDone).map((t) => formatTransition(stateNode, descriptor, t)));
 		}
-		if (n.onError) {
-			let r = `xstate.error.actor.${n.id}`;
-			t.set(r, toTransitionConfigArray(n.onError).map((t) => formatTransition(e, r, t)));
+		if (invokeDef.onError) {
+			const descriptor = `xstate.error.actor.${invokeDef.id}`;
+			transitions.set(descriptor, toTransitionConfigArray(invokeDef.onError).map((t) => formatTransition(stateNode, descriptor, t)));
 		}
-		if (n.onSnapshot) {
-			let r = `xstate.snapshot.${n.id}`;
-			t.set(r, toTransitionConfigArray(n.onSnapshot).map((t) => formatTransition(e, r, t)));
+		if (invokeDef.onSnapshot) {
+			const descriptor = `xstate.snapshot.${invokeDef.id}`;
+			transitions.set(descriptor, toTransitionConfigArray(invokeDef.onSnapshot).map((t) => formatTransition(stateNode, descriptor, t)));
 		}
 	}
-	for (let n of e.after) {
-		let e = t.get(n.eventType);
-		e || (e = [], t.set(n.eventType, e)), e.push(n);
-	}
-	return t;
-}
-function formatRouteTransitions(e) {
-	let t = [], collectRoutes = (n) => {
-		Object.values(n).forEach((n) => {
-			if (n.config.route && n.config.id) {
-				let r = n.config.id, i = n.config.route.guard, routeMatches = ({ event: e }) => e.to === `#${r}`, a = {
-					...n.config.route,
-					guard: i ? and([routeMatches, i]) : routeMatches,
-					target: `#${r}`
+	for (const delayedTransition of stateNode.after) {
+		let existing = transitions.get(delayedTransition.eventType);
+		if (!existing) {
+			existing = [];
+			transitions.set(delayedTransition.eventType, existing);
+		}
+		existing.push(delayedTransition);
+	}
+	return transitions;
+}
+/**
+* Collects route transitions from all descendants with explicit IDs. Called
+* once on the root node to avoid O(N²) repeated traversals.
+*/
+function formatRouteTransitions(rootStateNode) {
+	const routeTransitions = [];
+	const collectRoutes = (states) => {
+		Object.values(states).forEach((sn) => {
+			if (sn.config.route && sn.config.id) {
+				const routeId = sn.config.id;
+				const userGuard = sn.config.route.guard;
+				const routeMatches = ({ event }) => event.to === `#${routeId}`;
+				const transition = {
+					...sn.config.route,
+					guard: userGuard ? and([routeMatches, userGuard]) : routeMatches,
+					target: `#${routeId}`
 				};
-				t.push(formatTransition(e, "xstate.route", a));
+				routeTransitions.push(formatTransition(rootStateNode, "xstate.route", transition));
 			}
-			n.states && collectRoutes(n.states);
+			if (sn.states) collectRoutes(sn.states);
 		});
 	};
-	collectRoutes(e.states), t.length > 0 && e.transitions.set("xstate.route", t);
-}
-function formatInitialTransition(e, t) {
-	let n = typeof t == "string" ? e.states[t] : t ? e.states[t.target] : void 0;
-	if (!n && t) throw Error(`Initial state node "${t}" not found on parent state node #${e.id}`);
-	let r = {
-		source: e,
-		actions: !t || typeof t == "string" ? [] : toArray(t.actions),
+	collectRoutes(rootStateNode.states);
+	if (routeTransitions.length > 0) rootStateNode.transitions.set("xstate.route", routeTransitions);
+}
+function formatInitialTransition(stateNode, _target) {
+	const resolvedTarget = typeof _target === "string" ? stateNode.states[_target] : _target ? stateNode.states[_target.target] : void 0;
+	if (!resolvedTarget && _target) throw new Error(`Initial state node "${_target}" not found on parent state node #${stateNode.id}`);
+	const transition = {
+		source: stateNode,
+		actions: !_target || typeof _target === "string" ? [] : toArray(_target.actions),
 		eventType: null,
-		reenter: !1,
-		target: n ? [n] : [],
+		reenter: false,
+		target: resolvedTarget ? [resolvedTarget] : [],
+		meta: typeof _target === "object" ? _target.meta : void 0,
+		description: typeof _target === "object" ? _target.description : void 0,
 		toJSON: () => ({
-			...r,
-			source: `#${e.id}`,
-			target: n ? [`#${n.id}`] : []
+			...transition,
+			source: `#${stateNode.id}`,
+			target: resolvedTarget ? [`#${resolvedTarget.id}`] : []
 		})
 	};
-	return r;
-}
-function resolveTarget(e, t) {
-	if (t !== void 0) return t.map((t) => {
-		if (typeof t != "string") return t;
-		if (isStateId(t)) return e.machine.getStateNodeById(t);
-		let n = t[0] === ".";
-		if (n && !e.parent) return getStateNodeByPath(e, t.slice(1));
-		let r = n ? e.key + t : t;
-		if (e.parent) try {
-			return getStateNodeByPath(e.parent, r);
-		} catch (t) {
-			throw Error(`Invalid transition definition for state node '${e.id}':\n${t.message}`);
+	return transition;
+}
+function resolveTarget(stateNode, targets) {
+	if (targets === void 0) return;
+	return targets.map((target) => {
+		if (typeof target !== "string") return target;
+		if (isStateId(target)) return stateNode.machine.getStateNodeById(target);
+		const isInternalTarget = target[0] === ".";
+		if (isInternalTarget && !stateNode.parent) return getStateNodeByPath(stateNode, target.slice(1));
+		const resolvedTarget = isInternalTarget ? stateNode.key + target : target;
+		if (stateNode.parent) try {
+			return getStateNodeByPath(stateNode.parent, resolvedTarget);
+		} catch (err) {
+			throw new Error(`Invalid transition definition for state node '${stateNode.id}':\n${err.message}`);
 		}
-		throw Error(`Invalid target: "${t}" is not a valid target from the root node. Did you mean ".${t}"?`);
+		else throw new Error(`Invalid target: "${target}" is not a valid target from the root node. Did you mean ".${target}"?`);
 	});
 }
-function resolveHistoryDefaultTransition(e) {
-	let t = normalizeTarget(e.config.target);
-	return t ? { target: t.map((t) => typeof t == "string" ? getStateNodeByPath(e.parent, t) : t) } : e.parent.type === "parallel" ? { target: [e.parent] } : e.parent.initial;
-}
-function isHistoryNode(e) {
-	return e.type === "history";
-}
-function getInitialStateNodesWithTheirAncestors(e) {
-	let t = getInitialStateNodes(e);
-	for (let n of t) for (let r of getProperAncestors(n, e)) t.add(r);
-	return t;
-}
-function getInitialStateNodes(e) {
-	let t = /* @__PURE__ */ new Set();
-	function iter(e) {
-		if (!t.has(e)) {
-			if (t.add(e), e.type === "compound") iter(e.initial.target[0]);
-			else if (e.type === "parallel") for (let t of getChildren(e)) iter(t);
-		}
-	}
-	return iter(e), t;
-}
-function getStateNode(e, t) {
-	if (isStateId(t)) return e.machine.getStateNodeById(t);
-	if (!e.states) throw Error(`Unable to retrieve child state '${t}' from '${e.id}'; no child states exist.`);
-	let n = e.states[t];
-	if (!n) throw Error(`Child state '${t}' does not exist on '${e.id}'`);
-	return n;
-}
-function getStateNodeByPath(e, t) {
-	if (typeof t == "string" && isStateId(t)) try {
-		return e.machine.getStateNodeById(t);
+function resolveHistoryDefaultTransition(stateNode) {
+	const normalizedTarget = normalizeTarget(stateNode.config.target);
+	if (!normalizedTarget) {
+		if (stateNode.parent.type === "parallel") return { target: [stateNode.parent] };
+		return stateNode.parent.initial;
+	}
+	return { target: normalizedTarget.map((t) => typeof t === "string" ? getStateNodeByPath(stateNode.parent, t) : t) };
+}
+function isHistoryNode(stateNode) {
+	return stateNode.type === "history";
+}
+function getInitialStateNodesWithTheirAncestors(stateNode) {
+	const states = getInitialStateNodes(stateNode);
+	for (const initialState of states) for (const ancestor of getProperAncestors(initialState, stateNode)) states.add(ancestor);
+	return states;
+}
+function getInitialStateNodes(stateNode) {
+	const set = /* @__PURE__ */ new Set();
+	function iter(descStateNode) {
+		if (set.has(descStateNode)) return;
+		set.add(descStateNode);
+		if (descStateNode.type === "compound") iter(descStateNode.initial.target[0]);
+		else if (descStateNode.type === "parallel") for (const child of getChildren(descStateNode)) iter(child);
+	}
+	iter(stateNode);
+	return set;
+}
+/** Returns the child state node from its relative `stateKey`, or throws. */
+function getStateNode(stateNode, stateKey) {
+	if (isStateId(stateKey)) return stateNode.machine.getStateNodeById(stateKey);
+	if (!stateNode.states) throw new Error(`Unable to retrieve child state '${stateKey}' from '${stateNode.id}'; no child states exist.`);
+	const result = stateNode.states[stateKey];
+	if (!result) throw new Error(`Child state '${stateKey}' does not exist on '${stateNode.id}'`);
+	return result;
+}
+/**
+* Returns the relative state node from the given `statePath`, or throws.
+*
+* @param statePath The string or string array relative path to the state node.
+*/
+function getStateNodeByPath(stateNode, statePath) {
+	if (typeof statePath === "string" && isStateId(statePath)) try {
+		return stateNode.machine.getStateNodeById(statePath);
 	} catch {}
-	let n = toStatePath(t).slice(), r = e;
-	for (; n.length;) {
-		let e = n.shift();
-		if (!e.length) break;
-		r = getStateNode(r, e);
-	}
-	return r;
-}
-function getStateNodes(e, t) {
-	if (typeof t == "string") {
-		let n = e.states[t];
-		if (!n) throw Error(`State '${t}' does not exist on '${e.id}'`);
-		return [e, n];
-	}
-	let n = Object.keys(t), r = n.map((t) => getStateNode(e, t)).filter(Boolean);
-	return [e.machine.root, e].concat(r, n.reduce((n, r) => {
-		let i = getStateNode(e, r);
-		if (!i) return n;
-		let a = getStateNodes(i, t[r]);
-		return n.concat(a);
+	const arrayStatePath = toStatePath(statePath).slice();
+	let currentStateNode = stateNode;
+	while (arrayStatePath.length) {
+		const key = arrayStatePath.shift();
+		if (!key.length) break;
+		currentStateNode = getStateNode(currentStateNode, key);
+	}
+	return currentStateNode;
+}
+/**
+* Returns the state nodes represented by the current state value.
+*
+* @param stateValue The state value or State instance
+*/
+function getStateNodes(stateNode, stateValue) {
+	if (typeof stateValue === "string") {
+		const childStateNode = stateNode.states[stateValue];
+		if (!childStateNode) throw new Error(`State '${stateValue}' does not exist on '${stateNode.id}'`);
+		return [stateNode, childStateNode];
+	}
+	const childStateKeys = Object.keys(stateValue);
+	const childStateNodes = childStateKeys.map((subStateKey) => getStateNode(stateNode, subStateKey)).filter(Boolean);
+	return [stateNode.machine.root, stateNode].concat(childStateNodes, childStateKeys.reduce((allSubStateNodes, subStateKey) => {
+		const subStateNode = getStateNode(stateNode, subStateKey);
+		if (!subStateNode) return allSubStateNodes;
+		const subStateNodes = getStateNodes(subStateNode, stateValue[subStateKey]);
+		return allSubStateNodes.concat(subStateNodes);
 	}, []));
 }
-function transitionAtomicNode(e, t, n, r) {
-	let i = getStateNode(e, t).next(n, r);
-	return !i || !i.length ? e.next(n, r) : i;
-}
-function transitionCompoundNode(e, t, n, r) {
-	let i = Object.keys(t), a = transitionNode(getStateNode(e, i[0]), t[i[0]], n, r);
-	return !a || !a.length ? e.next(n, r) : a;
-}
-function transitionParallelNode(e, t, n, r) {
-	let i = [];
-	for (let a of Object.keys(t)) {
-		let o = t[a];
-		if (!o) continue;
-		let s = transitionNode(getStateNode(e, a), o, n, r);
-		s && i.push(...s);
-	}
-	return i.length ? i : e.next(n, r);
-}
-function transitionNode(e, t, n, r) {
-	return typeof t == "string" ? transitionAtomicNode(e, t, n, r) : Object.keys(t).length === 1 ? transitionCompoundNode(e, t, n, r) : transitionParallelNode(e, t, n, r);
-}
-function getHistoryNodes(e) {
-	return Object.keys(e.states).map((t) => e.states[t]).filter((e) => e.type === "history");
-}
-function isDescendant(e, t) {
-	let n = e;
-	for (; n.parent && n.parent !== t;) n = n.parent;
-	return n.parent === t;
-}
-function hasIntersection(e, t) {
-	let n = new Set(e), r = new Set(t);
-	for (let e of n) if (r.has(e)) return !0;
-	for (let e of r) if (n.has(e)) return !0;
-	return !1;
-}
-function removeConflictingTransitions(e, t, n) {
-	let r = /* @__PURE__ */ new Set();
-	for (let i of e) {
-		let e = !1, a = /* @__PURE__ */ new Set();
-		for (let o of r) if (hasIntersection(computeExitSet([i], t, n), computeExitSet([o], t, n))) {
-			if (isDescendant(i.source, o.source)) a.add(o);
+function transitionAtomicNode(stateNode, stateValue, snapshot, event) {
+	const next = getStateNode(stateNode, stateValue).next(snapshot, event);
+	if (!next || !next.length) return stateNode.next(snapshot, event);
+	return next;
+}
+function transitionCompoundNode(stateNode, stateValue, snapshot, event) {
+	const subStateKeys = Object.keys(stateValue);
+	const next = transitionNode(getStateNode(stateNode, subStateKeys[0]), stateValue[subStateKeys[0]], snapshot, event);
+	if (!next || !next.length) return stateNode.next(snapshot, event);
+	return next;
+}
+function transitionParallelNode(stateNode, stateValue, snapshot, event) {
+	const allInnerTransitions = [];
+	for (const subStateKey of Object.keys(stateValue)) {
+		const subStateValue = stateValue[subStateKey];
+		if (!subStateValue) continue;
+		const innerTransitions = transitionNode(getStateNode(stateNode, subStateKey), subStateValue, snapshot, event);
+		if (innerTransitions) allInnerTransitions.push(...innerTransitions);
+	}
+	if (!allInnerTransitions.length) return stateNode.next(snapshot, event);
+	return allInnerTransitions;
+}
+function transitionNode(stateNode, stateValue, snapshot, event) {
+	if (typeof stateValue === "string") return transitionAtomicNode(stateNode, stateValue, snapshot, event);
+	if (Object.keys(stateValue).length === 1) return transitionCompoundNode(stateNode, stateValue, snapshot, event);
+	return transitionParallelNode(stateNode, stateValue, snapshot, event);
+}
+function getHistoryNodes(stateNode) {
+	return Object.keys(stateNode.states).map((key) => stateNode.states[key]).filter((sn) => sn.type === "history");
+}
+function isDescendant(childStateNode, parentStateNode) {
+	let marker = childStateNode;
+	while (marker.parent && marker.parent !== parentStateNode) marker = marker.parent;
+	return marker.parent === parentStateNode;
+}
+function hasIntersection(s1, s2) {
+	const set1 = new Set(s1);
+	const set2 = new Set(s2);
+	for (const item of set1) if (set2.has(item)) return true;
+	for (const item of set2) if (set1.has(item)) return true;
+	return false;
+}
+function removeConflictingTransitions(enabledTransitions, stateNodeSet, historyValue) {
+	const filteredTransitions = /* @__PURE__ */ new Set();
+	for (const t1 of enabledTransitions) {
+		let t1Preempted = false;
+		const transitionsToRemove = /* @__PURE__ */ new Set();
+		for (const t2 of filteredTransitions) if (hasIntersection(computeExitSet([t1], stateNodeSet, historyValue), computeExitSet([t2], stateNodeSet, historyValue))) {
+			if (isDescendant(t1.source, t2.source)) transitionsToRemove.add(t2);
 			else {
-				e = !0;
+				t1Preempted = true;
 				break;
 			}
 		}
-		if (!e) {
-			for (let e of a) r.delete(e);
-			r.add(i);
+		if (!t1Preempted) {
+			for (const t3 of transitionsToRemove) filteredTransitions.delete(t3);
+			filteredTransitions.add(t1);
 		}
 	}
-	return Array.from(r);
-}
-function findLeastCommonAncestor(e) {
-	let [t, ...n] = e;
-	for (let e of getProperAncestors(t, void 0)) if (n.every((t) => isDescendant(t, e))) return e;
-}
-function getEffectiveTargetStates(e, t) {
-	if (!e.target) return [];
-	let n = /* @__PURE__ */ new Set();
-	for (let r of e.target) if (isHistoryNode(r)) {
-		if (t[r.id]) for (let e of t[r.id]) n.add(e);
-		else for (let e of getEffectiveTargetStates(resolveHistoryDefaultTransition(r), t)) n.add(e);
-	} else n.add(r);
-	return [...n];
-}
-function getTransitionDomain(e, t) {
-	let n = getEffectiveTargetStates(e, t);
-	if (!n) return;
-	if (!e.reenter && n.every((t) => t === e.source || isDescendant(t, e.source))) return e.source;
-	let r = findLeastCommonAncestor(n.concat(e.source));
-	if (r) return r;
-	if (!e.reenter) return e.source.machine.root;
-}
-function computeExitSet(e, t, n) {
-	let r = /* @__PURE__ */ new Set();
-	for (let i of e) if (i.target?.length) {
-		let e = getTransitionDomain(i, n);
-		i.reenter && i.source === e && r.add(e);
-		for (let n of t) isDescendant(n, e) && r.add(n);
-	}
-	return [...r];
-}
-function areStateNodeCollectionsEqual(e, t) {
-	if (e.length !== t.size) return !1;
-	for (let n of e) if (!t.has(n)) return !1;
-	return !0;
-}
-function initialMicrostep(e, t, n, r, i) {
+	return Array.from(filteredTransitions);
+}
+function findLeastCommonAncestor(stateNodes) {
+	const [head, ...tail] = stateNodes;
+	for (const ancestor of getProperAncestors(head, void 0)) if (tail.every((sn) => isDescendant(sn, ancestor))) return ancestor;
+}
+function getEffectiveTargetStates(transition, historyValue) {
+	if (!transition.target) return [];
+	const targets = /* @__PURE__ */ new Set();
+	for (const targetNode of transition.target) if (isHistoryNode(targetNode)) {
+		if (historyValue[targetNode.id]) for (const node of historyValue[targetNode.id]) targets.add(node);
+		else for (const node of getEffectiveTargetStates(resolveHistoryDefaultTransition(targetNode), historyValue)) targets.add(node);
+	} else targets.add(targetNode);
+	return [...targets];
+}
+function getTransitionDomain(transition, historyValue) {
+	const targetStates = getEffectiveTargetStates(transition, historyValue);
+	if (!targetStates) return;
+	if (!transition.reenter && targetStates.every((target) => target === transition.source || isDescendant(target, transition.source))) return transition.source;
+	const lca = findLeastCommonAncestor(targetStates.concat(transition.source));
+	if (lca) return lca;
+	if (transition.reenter) return;
+	return transition.source.machine.root;
+}
+function computeExitSet(transitions, stateNodeSet, historyValue) {
+	const statesToExit = /* @__PURE__ */ new Set();
+	for (const t of transitions) if (t.target?.length) {
+		const domain = getTransitionDomain(t, historyValue);
+		if (t.reenter && t.source === domain) statesToExit.add(domain);
+		for (const stateNode of stateNodeSet) if (isDescendant(stateNode, domain)) statesToExit.add(stateNode);
+	}
+	return [...statesToExit];
+}
+function areStateNodeCollectionsEqual(prevStateNodes, nextStateNodeSet) {
+	if (prevStateNodes.length !== nextStateNodeSet.size) return false;
+	for (const node of prevStateNodes) if (!nextStateNodeSet.has(node)) return false;
+	return true;
+}
+function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
 	return microstep([{
-		target: [...getInitialStateNodes(e)],
-		source: e,
-		reenter: !0,
+		target: [...getInitialStateNodes(root)],
+		source: root,
+		reenter: true,
 		actions: [],
 		eventType: null,
 		toJSON: null
-	}], t, n, r, !0, i);
-}
-function microstep(e, t, n, r, i, a) {
-	let o = [];
-	if (!e.length) return [t, o];
-	let s = n.actionExecutor;
-	n.actionExecutor = (e) => {
-		o.push(e), s(e);
+	}], preInitialState, actorScope, initEvent, true, internalQueue);
+}
+/** https://www.w3.org/TR/scxml/#microstepProcedure */
+function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue) {
+	const actions = [];
+	if (!transitions.length) return [currentSnapshot, actions];
+	const originalExecutor = actorScope.actionExecutor;
+	actorScope.actionExecutor = (action) => {
+		actions.push(action);
+		originalExecutor(action);
 	};
 	try {
-		let s = new Set(t._nodes), c = t.historyValue, l = removeConflictingTransitions(e, s, c), u = t;
-		i || ([u, c] = exitStates(u, r, n, l, s, c, a, n.actionExecutor)), u = resolveActionsAndContext(u, r, n, l.flatMap((e) => e.actions), a, void 0), u = enterStates(u, r, n, l, s, a, c, i);
-		let d = [...s];
-		u.status === "done" && (u = resolveActionsAndContext(u, r, n, d.sort((e, t) => t.order - e.order).flatMap((e) => e.exit), a, void 0));
+		const mutStateNodeSet = new Set(currentSnapshot._nodes);
+		let historyValue = currentSnapshot.historyValue;
+		const filteredTransitions = removeConflictingTransitions(transitions, mutStateNodeSet, historyValue);
+		let nextState = currentSnapshot;
+		if (!isInitial) [nextState, historyValue] = exitStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, historyValue, internalQueue, actorScope.actionExecutor);
+		nextState = resolveActionsAndContext(nextState, event, actorScope, filteredTransitions.flatMap((t) => t.actions), internalQueue, void 0);
+		nextState = enterStates(nextState, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial);
+		const nextStateNodes = [...mutStateNodeSet];
+		if (nextState.status === "done") nextState = resolveActionsAndContext(nextState, event, actorScope, nextStateNodes.sort((a, b) => b.order - a.order).flatMap((state) => state.exit), internalQueue, void 0);
 		try {
-			return c === t.historyValue && areStateNodeCollectionsEqual(t._nodes, s) ? [u, o] : [cloneMachineSnapshot(u, {
-				_nodes: d,
-				historyValue: c
-			}), o];
+			if (historyValue === currentSnapshot.historyValue && areStateNodeCollectionsEqual(currentSnapshot._nodes, mutStateNodeSet)) return [nextState, actions];
+			return [cloneMachineSnapshot(nextState, {
+				_nodes: nextStateNodes,
+				historyValue
+			}), actions];
 		} catch (e) {
 			throw e;
 		}
 	} finally {
-		n.actionExecutor = s;
-	}
-}
-function getMachineOutput(e, t, n, r, i) {
-	if (r.output === void 0) return;
-	let a = createDoneStateEvent(i.id, i.output !== void 0 && i.parent ? resolveOutput(i.output, e.context, t, n.self) : void 0);
-	return resolveOutput(r.output, e.context, a, n.self);
-}
-function enterStates(e, t, n, r, i, a, o, s) {
-	let c = e, l = /* @__PURE__ */ new Set(), u = /* @__PURE__ */ new Set();
-	computeEntrySet(r, o, u, l), s && u.add(e.machine.root);
-	let d = /* @__PURE__ */ new Set();
-	for (let e of [...l].sort((e, t) => e.order - t.order)) {
-		i.add(e);
-		let r = [];
-		r.push(...e.entry);
-		for (let t of e.invoke) r.push(spawnChild(t.src, {
-			...t,
-			syncSnapshot: !!t.onSnapshot
+		actorScope.actionExecutor = originalExecutor;
+	}
+}
+function getMachineOutput(snapshot, event, actorScope, rootNode, rootCompletionNode) {
+	if (rootNode.output === void 0) return;
+	const doneStateEvent = createDoneStateEvent(rootCompletionNode.id, rootCompletionNode.output !== void 0 && rootCompletionNode.parent ? resolveOutput(rootCompletionNode.output, snapshot.context, event, actorScope.self) : void 0);
+	return resolveOutput(rootNode.output, snapshot.context, doneStateEvent, actorScope.self);
+}
+function enterStates(currentSnapshot, event, actorScope, filteredTransitions, mutStateNodeSet, internalQueue, historyValue, isInitial) {
+	let nextSnapshot = currentSnapshot;
+	const statesToEnter = /* @__PURE__ */ new Set();
+	const statesForDefaultEntry = /* @__PURE__ */ new Set();
+	computeEntrySet(filteredTransitions, historyValue, statesForDefaultEntry, statesToEnter);
+	if (isInitial) statesForDefaultEntry.add(currentSnapshot.machine.root);
+	const completedNodes = /* @__PURE__ */ new Set();
+	for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
+		mutStateNodeSet.add(stateNodeToEnter);
+		const actions = [];
+		actions.push(...stateNodeToEnter.entry);
+		for (const invokeDef of stateNodeToEnter.invoke) actions.push(spawnChild(invokeDef.src, {
+			...invokeDef,
+			syncSnapshot: !!invokeDef.onSnapshot
 		}));
-		if (u.has(e)) {
-			let t = e.initial.actions;
-			r.push(...t);
+		if (statesForDefaultEntry.has(stateNodeToEnter)) {
+			const initialActions = stateNodeToEnter.initial.actions;
+			actions.push(...initialActions);
 		}
-		if (c = resolveActionsAndContext(c, t, n, r, a, e.invoke.map((e) => e.id)), e.type === "final") {
-			let r = e.parent, o = r?.type === "parallel" ? r : r?.parent, s = o || e;
-			for (r?.type === "compound" && a.push(createDoneStateEvent(r.id, e.output === void 0 ? void 0 : resolveOutput(e.output, c.context, t, n.self))); o?.type === "parallel" && !d.has(o) && isInFinalState(i, o);) d.add(o), a.push(createDoneStateEvent(o.id)), s = o, o = o.parent;
-			if (o) continue;
-			c = cloneMachineSnapshot(c, {
+		nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, actions, internalQueue, stateNodeToEnter.invoke.map((invokeDef) => invokeDef.id));
+		if (stateNodeToEnter.type === "final") {
+			const parent = stateNodeToEnter.parent;
+			let ancestorMarker = parent?.type === "parallel" ? parent : parent?.parent;
+			let rootCompletionNode = ancestorMarker || stateNodeToEnter;
+			if (parent?.type === "compound") internalQueue.push(createDoneStateEvent(parent.id, stateNodeToEnter.output !== void 0 ? resolveOutput(stateNodeToEnter.output, nextSnapshot.context, event, actorScope.self) : void 0));
+			while (ancestorMarker?.type === "parallel" && !completedNodes.has(ancestorMarker) && isInFinalState(mutStateNodeSet, ancestorMarker)) {
+				completedNodes.add(ancestorMarker);
+				internalQueue.push(createDoneStateEvent(ancestorMarker.id));
+				rootCompletionNode = ancestorMarker;
+				ancestorMarker = ancestorMarker.parent;
+			}
+			if (ancestorMarker) continue;
+			nextSnapshot = cloneMachineSnapshot(nextSnapshot, {
 				status: "done",
-				output: getMachineOutput(c, t, n, c.machine.root, s)
+				output: getMachineOutput(nextSnapshot, event, actorScope, nextSnapshot.machine.root, rootCompletionNode)
 			});
 		}
 	}
-	return c;
+	return nextSnapshot;
 }
-function computeEntrySet(e, t, n, r) {
-	for (let i of e) {
-		let e = getTransitionDomain(i, t);
-		for (let a of i.target || []) !isHistoryNode(a) && (i.source !== a || i.source !== e || i.reenter) && (r.add(a), n.add(a)), addDescendantStatesToEnter(a, t, n, r);
-		let a = getEffectiveTargetStates(i, t);
-		for (let o of a) {
-			let a = getProperAncestors(o, e);
-			e?.type === "parallel" && a.push(e), addAncestorStatesToEnter(r, t, n, a, !i.source.parent && i.reenter ? void 0 : e);
+function computeEntrySet(transitions, historyValue, statesForDefaultEntry, statesToEnter) {
+	for (const t of transitions) {
+		const domain = getTransitionDomain(t, historyValue);
+		for (const s of t.target || []) {
+			if (!isHistoryNode(s) && (t.source !== s || t.source !== domain || t.reenter)) {
+				statesToEnter.add(s);
+				statesForDefaultEntry.add(s);
+			}
+			addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+		}
+		const targetStates = getEffectiveTargetStates(t, historyValue);
+		for (const s of targetStates) {
+			const ancestors = getProperAncestors(s, domain);
+			if (domain?.type === "parallel") ancestors.push(domain);
+			addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, !t.source.parent && t.reenter ? void 0 : domain);
 		}
 	}
 }
-function addDescendantStatesToEnter(e, t, n, r) {
-	if (isHistoryNode(e)) {
-		if (t[e.id]) {
-			let i = t[e.id];
-			for (let e of i) r.add(e), addDescendantStatesToEnter(e, t, n, r);
-			for (let a of i) addProperAncestorStatesToEnter(a, e.parent, r, t, n);
+function addDescendantStatesToEnter(stateNode, historyValue, statesForDefaultEntry, statesToEnter) {
+	if (isHistoryNode(stateNode)) {
+		if (historyValue[stateNode.id]) {
+			const historyStateNodes = historyValue[stateNode.id];
+			for (const s of historyStateNodes) {
+				statesToEnter.add(s);
+				addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+			}
+			for (const s of historyStateNodes) addProperAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
 		} else {
-			let i = resolveHistoryDefaultTransition(e);
-			for (let a of i.target) r.add(a), i === e.parent?.initial && n.add(e.parent), addDescendantStatesToEnter(a, t, n, r);
-			for (let a of i.target) addProperAncestorStatesToEnter(a, e.parent, r, t, n);
+			const historyDefaultTransition = resolveHistoryDefaultTransition(stateNode);
+			for (const s of historyDefaultTransition.target) {
+				statesToEnter.add(s);
+				if (historyDefaultTransition === stateNode.parent?.initial) statesForDefaultEntry.add(stateNode.parent);
+				addDescendantStatesToEnter(s, historyValue, statesForDefaultEntry, statesToEnter);
+			}
+			for (const s of historyDefaultTransition.target) addProperAncestorStatesToEnter(s, stateNode.parent, statesToEnter, historyValue, statesForDefaultEntry);
+		}
+	} else if (stateNode.type === "compound") {
+		const [initialState] = stateNode.initial.target;
+		if (!isHistoryNode(initialState)) {
+			statesToEnter.add(initialState);
+			statesForDefaultEntry.add(initialState);
+		}
+		addDescendantStatesToEnter(initialState, historyValue, statesForDefaultEntry, statesToEnter);
+		addProperAncestorStatesToEnter(initialState, stateNode, statesToEnter, historyValue, statesForDefaultEntry);
+	} else if (stateNode.type === "parallel") {
+		for (const child of getChildren(stateNode).filter((sn) => !isHistoryNode(sn))) if (![...statesToEnter].some((s) => isDescendant(s, child))) {
+			if (!isHistoryNode(child)) {
+				statesToEnter.add(child);
+				statesForDefaultEntry.add(child);
+			}
+			addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
 		}
-	} else if (e.type === "compound") {
-		let [i] = e.initial.target;
-		isHistoryNode(i) || (r.add(i), n.add(i)), addDescendantStatesToEnter(i, t, n, r), addProperAncestorStatesToEnter(i, e, r, t, n);
-	} else if (e.type === "parallel") for (let i of getChildren(e).filter((e) => !isHistoryNode(e))) [...r].some((e) => isDescendant(e, i)) || (isHistoryNode(i) || (r.add(i), n.add(i)), addDescendantStatesToEnter(i, t, n, r));
-}
-function addAncestorStatesToEnter(e, t, n, r, i) {
-	for (let a of r) if ((!i || isDescendant(a, i)) && e.add(a), a.type === "parallel") for (let r of getChildren(a).filter((e) => !isHistoryNode(e))) [...e].some((e) => isDescendant(e, r)) || (e.add(r), addDescendantStatesToEnter(r, t, n, e));
-}
-function addProperAncestorStatesToEnter(e, t, n, r, i) {
-	addAncestorStatesToEnter(n, r, i, getProperAncestors(e, t));
-}
-function exitStates(e, t, n, r, i, a, o, s) {
-	let c = e, l = computeExitSet(r, i, a);
-	l.sort((e, t) => t.order - e.order);
-	let u;
-	for (let e of l) for (let t of getHistoryNodes(e)) {
-		let n;
-		n = t.history === "deep" ? (t) => isAtomicStateNode(t) && isDescendant(t, e) : (t) => t.parent === e, u ??= { ...a }, u[t.id] = Array.from(i).filter(n);
-	}
-	for (let e of l) c = resolveActionsAndContext(c, t, n, [...e.exit, ...e.invoke.map((e) => stopChild(e.id))], o, void 0), i.delete(e);
-	return [c, u || a];
-}
-function getAction(e, t) {
-	return e.implementations.actions[t];
-}
-function resolveAndExecuteActionsWithContext(e, t, n, r, i, a) {
-	let { machine: o } = e, s = e;
-	for (let e of r) {
-		let r = typeof e == "function", c = r ? e : getAction(o, typeof e == "string" ? e : e.type), l = {
-			context: s.context,
-			event: t,
-			self: n.self,
-			system: n.system
-		}, u = r || typeof e == "string" ? void 0 : "params" in e ? typeof e.params == "function" ? e.params({
-			context: s.context,
-			event: t
-		}) : e.params : void 0;
-		if (!c || !("resolve" in c)) {
-			n.actionExecutor({
-				type: typeof e == "string" ? e : typeof e == "object" ? e.type : e.name || "(anonymous)",
-				info: l,
-				params: u,
-				exec: c
+	}
+}
+function addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, ancestors, reentrancyDomain) {
+	for (const anc of ancestors) {
+		if (!reentrancyDomain || isDescendant(anc, reentrancyDomain)) statesToEnter.add(anc);
+		if (anc.type === "parallel") {
+			for (const child of getChildren(anc).filter((sn) => !isHistoryNode(sn))) if (![...statesToEnter].some((s) => isDescendant(s, child))) {
+				statesToEnter.add(child);
+				addDescendantStatesToEnter(child, historyValue, statesForDefaultEntry, statesToEnter);
+			}
+		}
+	}
+}
+function addProperAncestorStatesToEnter(stateNode, toStateNode, statesToEnter, historyValue, statesForDefaultEntry) {
+	addAncestorStatesToEnter(statesToEnter, historyValue, statesForDefaultEntry, getProperAncestors(stateNode, toStateNode));
+}
+function exitStates(currentSnapshot, event, actorScope, transitions, mutStateNodeSet, historyValue, internalQueue, _actionExecutor) {
+	let nextSnapshot = currentSnapshot;
+	const statesToExit = computeExitSet(transitions, mutStateNodeSet, historyValue);
+	statesToExit.sort((a, b) => b.order - a.order);
+	let changedHistory;
+	for (const exitStateNode of statesToExit) for (const historyNode of getHistoryNodes(exitStateNode)) {
+		let predicate;
+		if (historyNode.history === "deep") predicate = (sn) => isAtomicStateNode(sn) && isDescendant(sn, exitStateNode);
+		else predicate = (sn) => {
+			return sn.parent === exitStateNode;
+		};
+		changedHistory ??= { ...historyValue };
+		changedHistory[historyNode.id] = Array.from(mutStateNodeSet).filter(predicate);
+	}
+	for (const s of statesToExit) {
+		nextSnapshot = resolveActionsAndContext(nextSnapshot, event, actorScope, [...s.exit, ...s.invoke.map((def) => stopChild(def.id))], internalQueue, void 0);
+		mutStateNodeSet.delete(s);
+	}
+	return [nextSnapshot, changedHistory || historyValue];
+}
+function getAction(machine, actionType) {
+	return machine.implementations.actions[actionType];
+}
+function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, extra, retries) {
+	const { machine } = currentSnapshot;
+	let intermediateSnapshot = currentSnapshot;
+	for (const action of actions) {
+		const isInline = typeof action === "function";
+		const resolvedAction = isInline ? action : getAction(machine, typeof action === "string" ? action : action.type);
+		const actionArgs = {
+			context: intermediateSnapshot.context,
+			event,
+			self: actorScope.self,
+			system: actorScope.system
+		};
+		const actionParams = isInline || typeof action === "string" ? void 0 : "params" in action ? typeof action.params === "function" ? action.params({
+			context: intermediateSnapshot.context,
+			event
+		}) : action.params : void 0;
+		if (!resolvedAction || !("resolve" in resolvedAction)) {
+			actorScope.actionExecutor({
+				type: typeof action === "string" ? action : typeof action === "object" ? action.type : action.name || "(anonymous)",
+				info: actionArgs,
+				params: actionParams,
+				exec: resolvedAction
 			});
 			continue;
 		}
-		let d = c, [f, p, m] = d.resolve(n, s, l, u, c, i);
-		s = f, "retryResolve" in d && a?.push([d, p]), "execute" in d && n.actionExecutor({
-			type: d.type,
-			info: l,
-			params: p,
-			exec: d.execute.bind(null, n, p)
-		}), m && (s = resolveAndExecuteActionsWithContext(s, t, n, m, i, a));
-	}
-	return s;
-}
-function resolveActionsAndContext(e, t, n, r, i, a) {
-	let o = a ? [] : void 0, s = resolveAndExecuteActionsWithContext(e, t, n, r, {
-		internalQueue: i,
-		deferredActorIds: a
-	}, o);
-	return o?.forEach(([e, t]) => {
-		e.retryResolve(n, s, t);
-	}), s;
-}
-function macrostep(e, t, n, r) {
-	let i = e, a = [];
-	function addMicrostep(e, t, r) {
-		n.system._sendInspectionEvent({
+		const builtinAction = resolvedAction;
+		const [nextState, params, actions] = builtinAction.resolve(actorScope, intermediateSnapshot, actionArgs, actionParams, resolvedAction, extra);
+		intermediateSnapshot = nextState;
+		if ("retryResolve" in builtinAction) retries?.push([builtinAction, params]);
+		if ("execute" in builtinAction) actorScope.actionExecutor({
+			type: builtinAction.type,
+			info: actionArgs,
+			params,
+			exec: builtinAction.execute.bind(null, actorScope, params)
+		});
+		if (actions) intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions, extra, retries);
+	}
+	return intermediateSnapshot;
+}
+function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, internalQueue, deferredActorIds) {
+	const retries = deferredActorIds ? [] : void 0;
+	const nextState = resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope, actions, {
+		internalQueue,
+		deferredActorIds
+	}, retries);
+	retries?.forEach(([builtinAction, params]) => {
+		builtinAction.retryResolve(actorScope, nextState, params);
+	});
+	return nextState;
+}
+function macrostep(snapshot, event, actorScope, internalQueue) {
+	let nextSnapshot = snapshot;
+	const microsteps = [];
+	function addMicrostep(step, event, transitions) {
+		actorScope.system._sendInspectionEvent({
 			type: "@xstate.microstep",
-			actorRef: n.self,
-			event: t,
-			snapshot: e[0],
-			_transitions: r
-		}), a.push(e);
-	}
-	if (t.type === "xstate.stop") return i = cloneMachineSnapshot(stopChildren(i, t, n), { status: "stopped" }), addMicrostep([i, []], t, []), {
-		snapshot: i,
-		microsteps: a
-	};
-	let o = t;
-	if (o.type !== u) {
-		let t = o, s = isErrorActorEvent(t), c = selectTransitions(t, i);
-		if (s && !c.length) return i = cloneMachineSnapshot(e, {
-			status: "error",
-			error: t.error
-		}), addMicrostep([i, []], t, []), {
-			snapshot: i,
-			microsteps: a
+			actorRef: actorScope.self,
+			event,
+			snapshot: step[0],
+			_transitions: transitions
+		});
+		microsteps.push(step);
+	}
+	if (event.type === "xstate.stop") {
+		nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), { status: "stopped" });
+		addMicrostep([nextSnapshot, []], event, []);
+		return {
+			snapshot: nextSnapshot,
+			microsteps
 		};
-		let l = microstep(c, e, n, o, !1, r);
-		i = l[0], addMicrostep(l, t, c);
-	}
-	let s = !0, c = e.machine.options?.maxIterations ?? Infinity, l = 0;
-	for (; i.status === "active";) {
-		if (l++, l > c) throw Error(`Infinite loop detected: the machine has processed more than ${c} microsteps without reaching a stable state. This usually happens when there's a cycle of transitions (e.g., eventless transitions or raised events causing state A -> B -> C -> A).`);
-		let e = s ? selectEventlessTransitions(i, o) : [], t = e.length ? i : void 0;
-		if (!e.length) {
-			if (!r.length) break;
-			o = r.shift(), e = selectTransitions(o, i);
+	}
+	let nextEvent = event;
+	if (nextEvent.type !== XSTATE_INIT) {
+		const currentEvent = nextEvent;
+		const isErr = isErrorActorEvent(currentEvent);
+		const transitions = selectTransitions(currentEvent, nextSnapshot);
+		if (isErr && !transitions.length) {
+			nextSnapshot = cloneMachineSnapshot(snapshot, {
+				status: "error",
+				error: currentEvent.error
+			});
+			addMicrostep([nextSnapshot, []], currentEvent, []);
+			return {
+				snapshot: nextSnapshot,
+				microsteps
+			};
+		}
+		const step = microstep(transitions, snapshot, actorScope, nextEvent, false, internalQueue);
+		nextSnapshot = step[0];
+		addMicrostep(step, currentEvent, transitions);
+	}
+	let shouldSelectEventlessTransitions = true;
+	const maxIterations = snapshot.machine.options?.maxIterations ?? Infinity;
+	let iterationCount = 0;
+	while (nextSnapshot.status === "active") {
+		iterationCount++;
+		if (iterationCount > maxIterations) throw new Error(`Infinite loop detected: the machine has processed more than ${maxIterations} microsteps without reaching a stable state. This usually happens when there's a cycle of transitions (e.g., eventless transitions or raised events causing state A -> B -> C -> A).`);
+		let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextSnapshot, nextEvent) : [];
+		const previousState = enabledTransitions.length ? nextSnapshot : void 0;
+		if (!enabledTransitions.length) {
+			if (!internalQueue.length) break;
+			nextEvent = internalQueue.shift();
+			enabledTransitions = selectTransitions(nextEvent, nextSnapshot);
 		}
-		let a = microstep(e, i, n, o, !1, r);
-		i = a[0], s = i !== t, addMicrostep(a, o, e);
+		const step = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue);
+		nextSnapshot = step[0];
+		shouldSelectEventlessTransitions = nextSnapshot !== previousState;
+		addMicrostep(step, nextEvent, enabledTransitions);
 	}
-	return i.status !== "active" && stopChildren(i, o, n), {
-		snapshot: i,
-		microsteps: a
+	if (nextSnapshot.status !== "active") stopChildren(nextSnapshot, nextEvent, actorScope);
+	return {
+		snapshot: nextSnapshot,
+		microsteps
 	};
 }
-function stopChildren(e, t, n) {
-	return resolveActionsAndContext(e, t, n, Object.values(e.children).map((e) => stopChild(e)), [], void 0);
+function stopChildren(nextState, event, actorScope) {
+	return resolveActionsAndContext(nextState, event, actorScope, Object.values(nextState.children).map((child) => stopChild(child)), [], void 0);
 }
-function selectTransitions(e, t) {
-	return t.machine.getTransitionData(t, e);
+function selectTransitions(event, nextState) {
+	return nextState.machine.getTransitionData(nextState, event);
 }
-function selectEventlessTransitions(e, t) {
-	let n = /* @__PURE__ */ new Set(), r = e._nodes.filter(isAtomicStateNode);
-	for (let i of r) loop: for (let r of [i].concat(getProperAncestors(i, void 0))) if (r.always) {
-		for (let i of r.always) if (i.guard === void 0 || evaluateGuard(i.guard, e.context, t, e)) {
-			n.add(i);
+function selectEventlessTransitions(nextState, event) {
+	const enabledTransitionSet = /* @__PURE__ */ new Set();
+	const atomicStates = nextState._nodes.filter(isAtomicStateNode);
+	for (const stateNode of atomicStates) loop: for (const s of [stateNode].concat(getProperAncestors(stateNode, void 0))) {
+		if (!s.always) continue;
+		for (const transition of s.always) if (transition.guard === void 0 || evaluateGuard(transition.guard, nextState.context, event, nextState)) {
+			enabledTransitionSet.add(transition);
 			break loop;
 		}
 	}
-	return removeConflictingTransitions(Array.from(n), new Set(e._nodes), e.historyValue);
+	return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(nextState._nodes), nextState.historyValue);
 }
-function resolveStateValue(e, t) {
-	return getStateValue(e, [...getAllStateNodes(getStateNodes(e, t))]);
+/**
+* Resolves a partial state value with its full representation in the state
+* node's machine.
+*
+* @param stateValue The partial state value to resolve.
+*/
+function resolveStateValue(rootNode, stateValue) {
+	return getStateValue(rootNode, [...getAllStateNodes(getStateNodes(rootNode, stateValue))]);
 }
-function isMachineSnapshot(e) {
-	return !!e && typeof e == "object" && "machine" in e && "value" in e;
+function isMachineSnapshot(value) {
+	return !!value && typeof value === "object" && "machine" in value && "value" in value;
 }
-var _ = function matches(e) {
-	return matchesState(e, this.value);
-}, v = function hasTag(e) {
-	return this.tags.has(e);
-}, y = function can(e) {
-	let t = this.machine.getTransitionData(this, e);
-	return !!t?.length && t.some((e) => e.target !== void 0 || e.actions.length);
-}, b = function toJSON() {
-	let { _nodes: e, tags: t, machine: n, getMeta: r, toJSON: i, can: a, hasTag: o, matches: s, ...c } = this;
+var machineSnapshotMatches = function matches(testValue) {
+	return matchesState(testValue, this.value);
+};
+var machineSnapshotHasTag = function hasTag(tag) {
+	return this.tags.has(tag);
+};
+var machineSnapshotCan = function can(event) {
+	const transitionData = this.machine.getTransitionData(this, event);
+	return !!transitionData?.length && transitionData.some((t) => t.target !== void 0 || t.actions.length);
+};
+var machineSnapshotToJSON = function toJSON() {
+	const { _nodes: nodes, tags, machine, getMeta, toJSON, can, hasTag, matches, ...jsonValues } = this;
 	return {
-		...c,
-		tags: Array.from(t)
+		...jsonValues,
+		tags: Array.from(tags)
 	};
-}, x = function getMeta() {
-	return this._nodes.reduce((e, t) => (t.meta !== void 0 && (e[t.id] = t.meta), e), {});
 };
-function createMachineSnapshot(e, t) {
+var machineSnapshotGetMeta = function getMeta() {
+	return this._nodes.reduce((acc, stateNode) => {
+		if (stateNode.meta !== void 0) acc[stateNode.id] = stateNode.meta;
+		return acc;
+	}, {});
+};
+function createMachineSnapshot(config, machine) {
 	return {
-		status: e.status,
-		output: e.output,
-		error: e.error,
-		machine: t,
-		context: e.context,
-		_nodes: e._nodes,
-		value: getStateValue(t.root, e._nodes),
-		tags: new Set(e._nodes.flatMap((e) => e.tags)),
-		children: e.children,
-		historyValue: e.historyValue || {},
-		matches: _,
-		hasTag: v,
-		can: y,
-		getMeta: x,
-		toJSON: b
+		status: config.status,
+		output: config.output,
+		error: config.error,
+		machine,
+		context: config.context,
+		_nodes: config._nodes,
+		value: getStateValue(machine.root, config._nodes),
+		tags: new Set(config._nodes.flatMap((sn) => sn.tags)),
+		children: config.children,
+		historyValue: config.historyValue || {},
+		matches: machineSnapshotMatches,
+		hasTag: machineSnapshotHasTag,
+		can: machineSnapshotCan,
+		getMeta: machineSnapshotGetMeta,
+		toJSON: machineSnapshotToJSON
 	};
 }
-function cloneMachineSnapshot(e, t = {}) {
+function cloneMachineSnapshot(snapshot, config = {}) {
 	return createMachineSnapshot({
-		...e,
-		...t
-	}, e.machine);
-}
-function serializeHistoryValue(e) {
-	if (typeof e != "object" || !e) return {};
-	let t = {};
-	for (let n in e) {
-		let r = e[n];
-		Array.isArray(r) && (t[n] = r.map((e) => ({ id: e.id })));
-	}
-	return t;
-}
-function getPersistedSnapshot(e, t) {
-	let { _nodes: n, tags: r, machine: i, children: a, context: o, can: s, hasTag: c, matches: l, getMeta: u, toJSON: d, ...f } = e, p = {};
-	for (let e in a) {
-		let n = a[e];
-		p[e] = {
-			snapshot: n.getPersistedSnapshot(t),
-			src: n.src,
-			systemId: n.systemId,
-			syncSnapshot: n._syncSnapshot
+		...snapshot,
+		...config
+	}, snapshot.machine);
+}
+function serializeHistoryValue(historyValue) {
+	if (typeof historyValue !== "object" || historyValue === null) return {};
+	const result = {};
+	for (const key in historyValue) {
+		const value = historyValue[key];
+		if (Array.isArray(value)) result[key] = value.map((item) => ({ id: item.id }));
+	}
+	return result;
+}
+function getPersistedSnapshot(snapshot, options) {
+	const { _nodes: nodes, tags, machine, children, context, can, hasTag, matches, getMeta, toJSON, ...jsonValues } = snapshot;
+	const childrenJson = {};
+	for (const id in children) {
+		const child = children[id];
+		childrenJson[id] = {
+			snapshot: child.getPersistedSnapshot(options),
+			src: child.src,
+			systemId: child.systemId,
+			syncSnapshot: child._syncSnapshot
 		};
 	}
 	return {
-		...f,
-		context: persistContext(o),
-		children: p,
-		historyValue: serializeHistoryValue(f.historyValue)
+		...jsonValues,
+		context: persistContext(context),
+		children: childrenJson,
+		historyValue: serializeHistoryValue(jsonValues.historyValue)
 	};
 }
-function persistContext(e) {
-	let t;
-	for (let n in e) {
-		let r = e[n];
-		if (r && typeof r == "object") {
-			if ("sessionId" in r && "send" in r && "ref" in r) t ??= Array.isArray(e) ? e.slice() : { ...e }, t[n] = {
-				xstate$$type: 1,
-				id: r.id
-			};
-			else {
-				let i = persistContext(r);
-				i !== r && (t ??= Array.isArray(e) ? e.slice() : { ...e }, t[n] = i);
+function persistContext(contextPart) {
+	let copy;
+	for (const key in contextPart) {
+		const value = contextPart[key];
+		if (value && typeof value === "object") {
+			if ("sessionId" in value && "send" in value && "ref" in value) {
+				copy ??= Array.isArray(contextPart) ? contextPart.slice() : { ...contextPart };
+				copy[key] = {
+					xstate$$type: 1,
+					id: value.id
+				};
+			} else {
+				const result = persistContext(value);
+				if (result !== value) {
+					copy ??= Array.isArray(contextPart) ? contextPart.slice() : { ...contextPart };
+					copy[key] = result;
+				}
 			}
 		}
 	}
-	return t ?? e;
-}
-function resolveRaise(e, t, n, r, { event: i, id: a, delay: o }, { internalQueue: s }) {
-	let c = t.machine.implementations.delays;
-	if (typeof i == "string") throw Error(`Only event objects may be used with raise; use raise({ type: "${i}" }) instead`);
-	let l = typeof i == "function" ? i(n, r) : i, u;
-	if (typeof o == "string") {
-		let e = c && c[o];
-		u = typeof e == "function" ? e(n, r) : e;
-	} else u = typeof o == "function" ? o(n, r) : o;
-	return typeof u != "number" && s.push(l), [
-		t,
+	return copy ?? contextPart;
+}
+function resolveRaise(_, snapshot, args, actionParams, { event: eventOrExpr, id, delay }, { internalQueue }) {
+	const delaysMap = snapshot.machine.implementations.delays;
+	if (typeof eventOrExpr === "string") throw new Error(`Only event objects may be used with raise; use raise({ type: "${eventOrExpr}" }) instead`);
+	const resolvedEvent = typeof eventOrExpr === "function" ? eventOrExpr(args, actionParams) : eventOrExpr;
+	let resolvedDelay;
+	if (typeof delay === "string") {
+		const configDelay = delaysMap && delaysMap[delay];
+		resolvedDelay = typeof configDelay === "function" ? configDelay(args, actionParams) : configDelay;
+	} else resolvedDelay = typeof delay === "function" ? delay(args, actionParams) : delay;
+	if (typeof resolvedDelay !== "number") internalQueue.push(resolvedEvent);
+	return [
+		snapshot,
 		{
-			event: l,
-			id: a,
-			delay: u
+			event: resolvedEvent,
+			id,
+			delay: resolvedDelay
 		},
 		void 0
 	];
 }
-function executeRaise(e, t) {
-	let { event: n, delay: r, id: i } = t;
-	if (typeof r == "number") {
-		e.defer(() => {
-			let t = e.self;
-			e.system.scheduler.schedule(t, t, n, r, i);
+function executeRaise(actorScope, params) {
+	const { event, delay, id } = params;
+	if (typeof delay === "number") {
+		actorScope.defer(() => {
+			const self = actorScope.self;
+			actorScope.system.scheduler.schedule(self, self, event, delay, id);
 		});
 		return;
 	}
 }
-function raise(e, t) {
-	function raise(e, t) {}
-	return raise.type = "xstate.raise", raise.event = e, raise.id = t?.id, raise.delay = t?.delay, raise.resolve = resolveRaise, raise.execute = executeRaise, raise;
-}
-var S = /* #__PURE__ */ new WeakMap();
-function fromCallback(e) {
+/**
+* Raises an event. This places the event in the internal event queue, so that
+* the event is immediately consumed by the machine in the current step.
+*
+* @param eventType The event to raise.
+*/
+function raise(eventOrExpr, options) {
+	function raise(_args, _params) {}
+	raise.type = "xstate.raise";
+	raise.event = eventOrExpr;
+	raise.id = options?.id;
+	raise.delay = options?.delay;
+	raise.resolve = resolveRaise;
+	raise.execute = executeRaise;
+	return raise;
+}
+var instanceStates = /* #__PURE__ */ new WeakMap();
+/**
+* Represents an actor created by `fromCallback`.
+*
+* The type of `self` within the actor's logic.
+*
+* @example
+*
+* ```ts
+* import { fromCallback, createActor } from 'xstate';
+*
+* // The events the actor receives.
+* type Event = { type: 'someEvent' };
+* // The actor's input.
+* type Input = { name: string };
+*
+* // Actor logic that logs whenever it receives an event of type `someEvent`.
+* const logic = fromCallback<Event, Input>(({ self, input, receive }) => {
+*   self;
+*   // ^? CallbackActorRef<Event, Input>
+*
+*   receive((event) => {
+*     if (event.type === 'someEvent') {
+*       console.log(`${input.name}: received "someEvent" event`);
+*       // logs 'myActor: received "someEvent" event'
+*     }
+*   });
+* });
+*
+* const actor = createActor(logic, { input: { name: 'myActor' } });
+* //    ^? CallbackActorRef<Event, Input>
+* ```
+*
+* @see {@link fromCallback}
+*/
+/**
+* An actor logic creator which returns callback logic as defined by a callback
+* function.
+*
+* @remarks
+* Useful for subscription-based or other free-form logic that can send events
+* back to the parent actor.
+*
+* Actors created from callback logic (“callback actors”) can:
+*
+* - Receive events via the `receive` function
+* - Send events to the parent actor via the `sendBack` function
+*
+* Callback actors are a bit different from other actors in that they:
+*
+* - Do not work with `onDone`
+* - Do not produce a snapshot using `.getSnapshot()`
+* - Do not emit values when used with `.subscribe()`
+* - Can not be stopped with `.stop()`
+*
+* @example
+*
+* ```typescript
+* const callbackLogic = fromCallback(({ sendBack, receive }) => {
+*   let lockStatus = 'unlocked';
+*
+*   const handler = (event) => {
+*     if (lockStatus === 'locked') {
+*       return;
+*     }
+*     sendBack(event);
+*   };
+*
+*   receive((event) => {
+*     if (event.type === 'lock') {
+*       lockStatus = 'locked';
+*     } else if (event.type === 'unlock') {
+*       lockStatus = 'unlocked';
+*     }
+*   });
+*
+*   document.body.addEventListener('click', handler);
+*
+*   return () => {
+*     document.body.removeEventListener('click', handler);
+*   };
+* });
+* ```
+*
+* @param callback - The callback function used to describe the callback logic
+*   The callback function is passed an object with the following properties:
+*
+*   - `receive` - A function that can send events back to the parent actor; the
+*       listener is then called whenever events are received by the callback
+*       actor
+*   - `sendBack` - A function that can send events back to the parent actor
+*   - `input` - Data that was provided to the callback actor
+*   - `self` - The parent actor of the callback actor
+*   - `system` - The actor system to which the callback actor belongs The callback
+*       function can (optionally) return a cleanup function, which is called
+*       when the actor is stopped.
+*
+* @returns Callback logic
+* @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
+* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+*/
+function fromCallback(callback) {
 	return {
-		config: e,
-		start: (t, n) => {
-			let { self: r, system: i, emit: a } = n, o = {
+		config: callback,
+		start: (state, actorScope) => {
+			const { self, system, emit } = actorScope;
+			const callbackState = {
 				receivers: void 0,
 				dispose: void 0
 			};
-			S.set(r, o), o.dispose = e({
-				input: t.input,
-				system: i,
-				self: r,
-				sendBack: (e) => {
-					r.getSnapshot().status !== "stopped" && r._parent && i._relay(r, r._parent, e);
+			instanceStates.set(self, callbackState);
+			callbackState.dispose = callback({
+				input: state.input,
+				system,
+				self,
+				sendBack: (event) => {
+					if (self.getSnapshot().status === "stopped") return;
+					if (self._parent) system._relay(self, self._parent, event);
 				},
-				receive: (e) => {
-					o.receivers ??= /* @__PURE__ */ new Set(), o.receivers.add(e);
+				receive: (listener) => {
+					callbackState.receivers ??= /* @__PURE__ */ new Set();
+					callbackState.receivers.add(listener);
 				},
-				emit: a
+				emit
 			});
 		},
-		transition: (e, t, n) => {
-			let r = S.get(n.self);
-			return t.type === "xstate.stop" ? (e = {
-				...e,
-				status: "stopped",
-				error: void 0
-			}, S.delete(n.self), r.receivers?.clear(), r.dispose?.(), e) : (r.receivers?.forEach((e) => e(t)), e);
+		transition: (state, event, actorScope) => {
+			const callbackState = instanceStates.get(actorScope.self);
+			if (event.type === "xstate.stop") {
+				state = {
+					...state,
+					status: "stopped",
+					error: void 0
+				};
+				instanceStates.delete(actorScope.self);
+				callbackState.receivers?.clear();
+				callbackState.dispose?.();
+				return state;
+			}
+			callbackState.receivers?.forEach((receiver) => receiver(event));
+			return state;
 		},
-		getInitialSnapshot: (e, t) => ({
-			status: "active",
-			output: void 0,
-			error: void 0,
-			input: t
-		}),
-		getPersistedSnapshot: (e) => e,
-		restoreSnapshot: (e) => e
+		getInitialSnapshot: (_, input) => {
+			return {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				input
+			};
+		},
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
 	};
 }
-var C = "xstate.promise.resolve", w = "xstate.promise.reject", T = /* @__PURE__ */ new WeakMap();
-function fromPromise(e) {
+var XSTATE_PROMISE_RESOLVE = "xstate.promise.resolve";
+var XSTATE_PROMISE_REJECT = "xstate.promise.reject";
+/**
+* Represents an actor created by `fromPromise`.
+*
+* The type of `self` within the actor's logic.
+*
+* @example
+*
+* ```ts
+* import { fromPromise, createActor } from 'xstate';
+*
+* // The actor's resolved output
+* type Output = string;
+* // The actor's input.
+* type Input = { message: string };
+*
+* // Actor logic that fetches the url of an image of a cat saying `input.message`.
+* const logic = fromPromise<Output, Input>(async ({ input, self }) => {
+*   self;
+*   // ^? PromiseActorRef<Output, Input>
+*
+*   const data = await fetch(
+*     `https://cataas.com/cat/says/${input.message}`
+*   );
+*   const url = await data.json();
+*   return url;
+* });
+*
+* const actor = createActor(logic, { input: { message: 'hello world' } });
+* //    ^? PromiseActorRef<Output, Input>
+* ```
+*
+* @see {@link fromPromise}
+*/
+var controllerMap = /* @__PURE__ */ new WeakMap();
+/**
+* An actor logic creator which returns promise logic as defined by an async
+* process that resolves or rejects after some time.
+*
+* Actors created from promise actor logic (“promise actors”) can:
+*
+* - Emit the resolved value of the promise
+* - Output the resolved value of the promise
+*
+* Sending events to promise actors will have no effect.
+*
+* @example
+*
+* ```ts
+* const promiseLogic = fromPromise(async () => {
+*   const result = await fetch('https://example.com/...').then((data) =>
+*     data.json()
+*   );
+*
+*   return result;
+* });
+*
+* const promiseActor = createActor(promiseLogic);
+* promiseActor.subscribe((snapshot) => {
+*   console.log(snapshot);
+* });
+* promiseActor.start();
+* // => {
+* //   output: undefined,
+* //   status: 'active'
+* //   ...
+* // }
+*
+* // After promise resolves
+* // => {
+* //   output: { ... },
+* //   status: 'done',
+* //   ...
+* // }
+* ```
+*
+* @param promiseCreator A function which returns a Promise, and accepts an
+*   object with the following properties:
+*
+*   - `input` - Data that was provided to the promise actor
+*   - `self` - The parent actor of the promise actor
+*   - `system` - The actor system to which the promise actor belongs
+*
+* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
+*/
+function fromPromise(promiseCreator) {
 	return {
-		config: e,
-		transition: (e, t, n) => {
-			if (e.status !== "active") return e;
-			switch (t.type) {
-				case C: {
-					let n = t.data;
+		config: promiseCreator,
+		transition: (state, event, scope) => {
+			if (state.status !== "active") return state;
+			switch (event.type) {
+				case XSTATE_PROMISE_RESOLVE: {
+					const resolvedValue = event.data;
 					return {
-						...e,
+						...state,
 						status: "done",
-						output: n,
+						output: resolvedValue,
 						input: void 0
 					};
 				}
-				case w: return {
-					...e,
+				case XSTATE_PROMISE_REJECT: return {
+					...state,
 					status: "error",
-					error: t.data,
+					error: event.data,
 					input: void 0
 				};
-				case d: return T.get(n.self)?.abort(), T.delete(n.self), {
-					...e,
-					status: "stopped",
-					input: void 0
-				};
-				default: return e;
+				case XSTATE_STOP:
+					controllerMap.get(scope.self)?.abort();
+					controllerMap.delete(scope.self);
+					return {
+						...state,
+						status: "stopped",
+						input: void 0
+					};
+				default: return state;
 			}
 		},
-		start: (t, { self: n, system: r, emit: i }) => {
-			if (t.status !== "active") return;
-			let a = new AbortController();
-			T.set(n, a), Promise.resolve(e({
-				input: t.input,
-				system: r,
-				self: n,
-				signal: a.signal,
-				emit: i
-			})).then((e) => {
-				n.getSnapshot().status === "active" && (T.delete(n), r._relay(n, n, {
-					type: C,
-					data: e
-				}));
-			}, (e) => {
-				n.getSnapshot().status === "active" && (T.delete(n), r._relay(n, n, {
-					type: w,
-					data: e
-				}));
+		start: (state, { self, system, emit }) => {
+			if (state.status !== "active") return;
+			const controller = new AbortController();
+			controllerMap.set(self, controller);
+			Promise.resolve(promiseCreator({
+				input: state.input,
+				system,
+				self,
+				signal: controller.signal,
+				emit
+			})).then((response) => {
+				if (self.getSnapshot().status !== "active") return;
+				controllerMap.delete(self);
+				system._relay(self, self, {
+					type: XSTATE_PROMISE_RESOLVE,
+					data: response
+				});
+			}, (errorData) => {
+				if (self.getSnapshot().status !== "active") return;
+				controllerMap.delete(self);
+				system._relay(self, self, {
+					type: XSTATE_PROMISE_REJECT,
+					data: errorData
+				});
 			});
 		},
-		getInitialSnapshot: (e, t) => ({
-			status: "active",
-			output: void 0,
-			error: void 0,
-			input: t
-		}),
-		getPersistedSnapshot: (e) => e,
-		restoreSnapshot: (e) => e
+		getInitialSnapshot: (_, input) => {
+			return {
+				status: "active",
+				output: void 0,
+				error: void 0,
+				input
+			};
+		},
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.6/node_modules/xstate/dist/assign-54f9e2d3.esm.js
-function createSpawner(e, { machine: t, context: n }, r, i) {
-	let spawn = (a, o) => {
-		if (typeof a == "string") {
-			let s = resolveReferencedActor(t, a);
-			if (!s) throw Error(`Actor logic '${a}' not implemented in machine '${t.id}'`);
-			let c = createActor(s, {
-				id: o?.id,
-				parent: e.self,
-				syncSnapshot: o?.syncSnapshot,
-				input: typeof o?.input == "function" ? o.input({
-					context: n,
-					event: r,
-					self: e.self
-				}) : o?.input,
-				src: a,
-				systemId: o?.systemId
+//#region ../../node_modules/.pnpm/xstate@5.33.2/node_modules/xstate/dist/assign-b4b1f28f.esm.js
+function createSpawner(actorScope, { machine, context }, event, spawnedChildren) {
+	const spawn = (src, options) => {
+		if (typeof src === "string") {
+			const logic = resolveReferencedActor(machine, src);
+			if (!logic) throw new Error(`Actor logic '${src}' not implemented in machine '${machine.id}'`);
+			const actorRef = createActor(logic, {
+				id: options?.id,
+				parent: actorScope.self,
+				syncSnapshot: options?.syncSnapshot,
+				input: typeof options?.input === "function" ? options.input({
+					context,
+					event,
+					self: actorScope.self
+				}) : options?.input,
+				src,
+				systemId: options?.systemId
 			});
-			return i[c.id] = c, c;
-		}
-		return createActor(a, {
-			id: o?.id,
-			parent: e.self,
-			syncSnapshot: o?.syncSnapshot,
-			input: o?.input,
-			src: a,
-			systemId: o?.systemId
+			spawnedChildren[actorRef.id] = actorRef;
+			return actorRef;
+		} else return createActor(src, {
+			id: options?.id,
+			parent: actorScope.self,
+			syncSnapshot: options?.syncSnapshot,
+			input: options?.input,
+			src,
+			systemId: options?.systemId
 		});
 	};
-	return (t, n) => {
-		let r = spawn(t, n);
-		return i[r.id] = r, e.defer(() => {
-			r._processingStatus !== h.Stopped && r.start();
-		}), r;
+	return (src, options) => {
+		const actorRef = spawn(src, options);
+		spawnedChildren[actorRef.id] = actorRef;
+		actorScope.defer(() => {
+			if (actorRef._processingStatus === ProcessingStatus.Stopped) return;
+			actorRef.start();
+		});
+		return actorRef;
 	};
 }
-function resolveAssign(e, t, n, r, { assignment: i }) {
-	if (!t.context) throw Error("Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.");
-	let a = {}, o = {
-		context: t.context,
-		event: n.event,
-		spawn: createSpawner(e, t, n.event, a),
-		self: e.self,
-		system: e.system
-	}, s = {};
-	if (typeof i == "function") s = i(o, r);
-	else for (let e of Object.keys(i)) {
-		let t = i[e];
-		s[e] = typeof t == "function" ? t(o, r) : t;
+function resolveAssign(actorScope, snapshot, actionArgs, actionParams, { assignment }) {
+	if (!snapshot.context) throw new Error("Cannot assign to undefined `context`. Ensure that `context` is defined in the machine config.");
+	const spawnedChildren = {};
+	const assignArgs = {
+		context: snapshot.context,
+		event: actionArgs.event,
+		spawn: createSpawner(actorScope, snapshot, actionArgs.event, spawnedChildren),
+		self: actorScope.self,
+		system: actorScope.system
+	};
+	let partialUpdate = {};
+	if (typeof assignment === "function") partialUpdate = assignment(assignArgs, actionParams);
+	else for (const key of Object.keys(assignment)) {
+		const propAssignment = assignment[key];
+		partialUpdate[key] = typeof propAssignment === "function" ? propAssignment(assignArgs, actionParams) : propAssignment;
 	}
 	return [
-		cloneMachineSnapshot(t, {
-			context: Object.assign({}, t.context, s),
-			children: Object.keys(a).length ? {
-				...t.children,
-				...a
-			} : t.children
+		cloneMachineSnapshot(snapshot, {
+			context: Object.assign({}, snapshot.context, partialUpdate),
+			children: Object.keys(spawnedChildren).length ? {
+				...snapshot.children,
+				...spawnedChildren
+			} : snapshot.children
 		}),
 		void 0,
 		void 0
 	];
 }
-function assign(e) {
-	function assign(e, t) {}
-	return assign.type = "xstate.assign", assign.assignment = e, assign.resolve = resolveAssign, assign;
+/**
+* Updates the current context of the machine.
+*
+* @example
+*
+* ```ts
+* import { createMachine, assign } from 'xstate';
+*
+* const countMachine = createMachine({
+*   context: {
+*     count: 0,
+*     message: ''
+*   },
+*   on: {
+*     inc: {
+*       actions: assign({
+*         count: ({ context }) => context.count + 1
+*       })
+*     },
+*     updateMessage: {
+*       actions: assign(({ context, event }) => {
+*         return {
+*           message: event.message.trim()
+*         };
+*       })
+*     }
+*   }
+* });
+* ```
+*
+* @param assignment An object that represents the partial context to update, or
+*   a function that returns an object that represents the partial context to
+*   update.
+*/
+function assign(assignment) {
+	function assign(_args, _params) {}
+	assign.type = "xstate.assign";
+	assign.assignment = assignment;
+	assign.resolve = resolveAssign;
+	return assign;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.6/node_modules/xstate/dist/StateMachine-28a9f50e.esm.js
-var E = /* @__PURE__ */ new WeakMap();
-function memo$1(e, t, n) {
-	let r = E.get(e);
-	return r ? t in r || (r[t] = n()) : (r = { [t]: n() }, E.set(e, r)), r[t];
-}
-e(memo$1, "memo");
-var D = {}, toSerializableAction = (e) => typeof e == "string" ? { type: e } : typeof e == "function" ? "resolve" in e ? { type: e.type } : { type: e.name } : e, O = class StateNode {
-	constructor(e, t) {
-		if (this.config = e, this.key = void 0, this.id = void 0, this.type = void 0, this.path = void 0, this.states = void 0, this.history = void 0, this.entry = void 0, this.exit = void 0, this.parent = void 0, this.machine = void 0, this.meta = void 0, this.output = void 0, this.order = -1, this.description = void 0, this.tags = [], this.transitions = void 0, this.always = void 0, this.parent = t._parent, this.key = t._key, this.machine = t._machine, this.path = this.parent ? this.parent.path.concat(this.key) : [], this.id = this.config.id || [this.machine.id, ...this.path].join("."), this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? "compound" : this.config.history ? "history" : "atomic"), this.description = this.config.description, this.order = this.machine.idMap.size, this.machine.idMap.set(this.id, this), this.states = this.config.states ? mapValues(this.config.states, (e, t) => new StateNode(e, {
-			_parent: this,
-			_key: t,
-			_machine: this.machine
-		})) : D, this.type === "compound" && !this.config.initial) throw Error(`No initial state specified for compound state node "#${this.id}". Try adding { initial: "${Object.keys(this.states)[0]}" } to the state config.`);
-		this.history = this.config.history === !0 ? "shallow" : this.config.history || !1, this.entry = toArray(this.config.entry).slice(), this.exit = toArray(this.config.exit).slice(), this.meta = this.config.meta, this.output = this.type === "final" || !this.parent ? this.config.output : void 0, this.tags = toArray(e.tags).slice();
-	}
+//#region ../../node_modules/.pnpm/xstate@5.33.2/node_modules/xstate/dist/StateMachine-521e1f66.esm.js
+var cache = /* @__PURE__ */ new WeakMap();
+function memo$1(object, key, fn) {
+	let memoizedData = cache.get(object);
+	if (!memoizedData) {
+		memoizedData = { [key]: fn() };
+		cache.set(object, memoizedData);
+	} else if (!(key in memoizedData)) memoizedData[key] = fn();
+	return memoizedData[key];
+}
+__name(memo$1, "memo");
+var EMPTY_OBJECT = {};
+var toSerializableAction = (action) => {
+	if (typeof action === "string") return { type: action };
+	if (typeof action === "function") {
+		if ("resolve" in action) return { type: action.type };
+		return { type: action.name };
+	}
+	return action;
+};
+var StateNode = class StateNode {
+	constructor(config, options) {
+		this.config = config;
+		/**
+		* The relative key of the state node, which represents its location in the
+		* overall state value.
+		*/
+		this.key = void 0;
+		/** The unique ID of the state node. */
+		this.id = void 0;
+		/**
+		* The type of this state node:
+		*
+		* - `'atomic'` - no child state nodes
+		* - `'compound'` - nested child state nodes (XOR)
+		* - `'parallel'` - orthogonal nested child state nodes (AND)
+		* - `'history'` - history state node
+		* - `'final'` - final state node
+		*/
+		this.type = void 0;
+		/** The string path from the root machine node to this node. */
+		this.path = void 0;
+		/** The child state nodes. */
+		this.states = void 0;
+		/**
+		* The type of history on this state node. Can be:
+		*
+		* - `'shallow'` - recalls only top-level historical state value
+		* - `'deep'` - recalls historical state value at all levels
+		*/
+		this.history = void 0;
+		/** The action(s) to be executed upon entering the state node. */
+		this.entry = void 0;
+		/** The action(s) to be executed upon exiting the state node. */
+		this.exit = void 0;
+		/** The parent state node. */
+		this.parent = void 0;
+		/** The root machine node. */
+		this.machine = void 0;
+		/**
+		* The meta data associated with this state node, which will be returned in
+		* State instances.
+		*/
+		this.meta = void 0;
+		/**
+		* The output data sent with the "xstate.done.state._id_" event if this is a
+		* final state node.
+		*/
+		this.output = void 0;
+		/**
+		* The order this state node appears. Corresponds to the implicit document
+		* order.
+		*/
+		this.order = -1;
+		this.description = void 0;
+		this.tags = [];
+		this.transitions = void 0;
+		this.always = void 0;
+		this.parent = options._parent;
+		this.key = options._key;
+		this.machine = options._machine;
+		this.path = this.parent ? this.parent.path.concat(this.key) : [];
+		this.id = this.config.id || [this.machine.id, ...this.path].join(".");
+		this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? "compound" : this.config.history ? "history" : "atomic");
+		this.description = this.config.description;
+		this.order = this.machine.idMap.size;
+		this.machine.idMap.set(this.id, this);
+		this.states = this.config.states ? mapValues(this.config.states, (stateConfig, key) => {
+			return new StateNode(stateConfig, {
+				_parent: this,
+				_key: key,
+				_machine: this.machine
+			});
+		}) : EMPTY_OBJECT;
+		if (this.type === "compound" && !this.config.initial) throw new Error(`No initial state specified for compound state node "#${this.id}". Try adding { initial: "${Object.keys(this.states)[0]}" } to the state config.`);
+		this.history = this.config.history === true ? "shallow" : this.config.history || false;
+		this.entry = toArray(this.config.entry).slice();
+		this.exit = toArray(this.config.exit).slice();
+		this.meta = this.config.meta;
+		this.output = this.type === "final" || !this.parent ? this.config.output : void 0;
+		this.tags = toArray(config.tags).slice();
+	}
+	/** @internal */
 	_initialize() {
-		this.transitions = formatTransitions(this), this.config.always && (this.always = toTransitionConfigArray(this.config.always).map((e) => formatTransition(this, "", e))), Object.keys(this.states).forEach((e) => {
-			this.states[e]._initialize();
+		this.transitions = formatTransitions(this);
+		if (this.config.always) this.always = toTransitionConfigArray(this.config.always).map((t) => formatTransition(this, "", t));
+		Object.keys(this.states).forEach((key) => {
+			this.states[key]._initialize();
 		});
 	}
+	/** The well-structured state node definition. */
 	get definition() {
 		return {
 			id: this.id,
@@ -1518,20 +2608,24 @@ var D = {}, toSerializableAction = (e) => typeof e == "string" ? { type: e } : t
 				source: this,
 				actions: this.initial.actions.map(toSerializableAction),
 				eventType: null,
-				reenter: !1,
+				reenter: false,
+				meta: this.initial.meta,
+				description: this.initial.description,
 				toJSON: () => ({
-					target: this.initial.target.map((e) => `#${e.id}`),
+					target: this.initial.target.map((t) => `#${t.id}`),
 					source: `#${this.id}`,
 					actions: this.initial.actions.map(toSerializableAction),
-					eventType: null
+					eventType: null,
+					meta: this.initial.meta,
+					description: this.initial.description
 				})
 			} : void 0,
 			history: this.history,
-			states: mapValues(this.states, (e) => e.definition),
+			states: mapValues(this.states, (state) => state.definition),
 			on: this.on,
-			transitions: [...this.transitions.values()].flat().map((e) => ({
-				...e,
-				actions: e.actions.map(toSerializableAction)
+			transitions: [...this.transitions.values()].flat().map((t) => ({
+				...t,
+				actions: t.actions.map(toSerializableAction)
 			})),
 			entry: this.entry.map(toSerializableAction),
 			exit: this.exit.map(toSerializableAction),
@@ -1543,31 +2637,42 @@ var D = {}, toSerializableAction = (e) => typeof e == "string" ? { type: e } : t
 			tags: this.tags
 		};
 	}
+	/** @internal */
 	toJSON() {
 		return this.definition;
 	}
+	/** The logic invoked as actors by this state node. */
 	get invoke() {
-		return memo$1(this, "invoke", () => toArray(this.config.invoke).map((e, t) => {
-			let { src: n, systemId: r } = e, i = e.id ?? createInvokeId(this.id, t), a = typeof n == "string" ? n : `xstate.invoke.${createInvokeId(this.id, t)}`;
+		return memo$1(this, "invoke", () => toArray(this.config.invoke).map((invokeConfig, i) => {
+			const { src, systemId } = invokeConfig;
+			const resolvedId = invokeConfig.id ?? createInvokeId(this.id, i);
+			const sourceName = typeof src === "string" ? src : `xstate.invoke.${createInvokeId(this.id, i)}`;
 			return {
-				...e,
-				src: a,
-				id: i,
-				systemId: r,
+				...invokeConfig,
+				src: sourceName,
+				id: resolvedId,
+				systemId,
 				toJSON() {
-					let { onDone: t, onError: n, ...r } = e;
+					const { onDone, onError, ...invokeDefValues } = invokeConfig;
 					return {
-						...r,
+						...invokeDefValues,
 						type: "xstate.invoke",
-						src: a,
-						id: i
+						src: sourceName,
+						id: resolvedId
 					};
 				}
 			};
 		}));
 	}
+	/** The mapping of events to transitions. */
 	get on() {
-		return memo$1(this, "on", () => [...this.transitions].flatMap(([e, t]) => t.map((t) => [e, t])).reduce((e, [t, n]) => (e[t] = e[t] || [], e[t].push(n), e), {}));
+		return memo$1(this, "on", () => {
+			return [...this.transitions].flatMap(([descriptor, t]) => t.map((t) => [descriptor, t])).reduce((map, [descriptor, transition]) => {
+				map[descriptor] = map[descriptor] || [];
+				map[descriptor].push(transition);
+				return map;
+			}, {});
+		});
 	}
 	get after() {
 		return memo$1(this, "delayedTransitions", () => getDelayedTransitions(this));
@@ -1575,138 +2680,224 @@ var D = {}, toSerializableAction = (e) => typeof e == "string" ? { type: e } : t
 	get initial() {
 		return memo$1(this, "initial", () => formatInitialTransition(this, this.config.initial));
 	}
-	next(e, t) {
-		let n = t.type, r = [], i, a = memo$1(this, `candidates-${n}`, () => getCandidates(this, n));
-		for (let o of a) {
-			let { guard: a } = o, s = e.context, c = !1;
+	/** @internal */
+	next(snapshot, event) {
+		const eventType = event.type;
+		const actions = [];
+		let selectedTransition;
+		const candidates = memo$1(this, `candidates-${eventType}`, () => getCandidates(this, eventType));
+		for (const candidate of candidates) {
+			const { guard } = candidate;
+			const resolvedContext = snapshot.context;
+			let guardPassed = false;
 			try {
-				c = !a || evaluateGuard(a, s, t, e);
-			} catch (e) {
-				let t = typeof a == "string" ? a : typeof a == "object" ? a.type : void 0;
-				throw Error(`Unable to evaluate guard ${t ? `'${t}' ` : ""}in transition for event '${n}' in state node '${this.id}':\n${e.message}`);
+				guardPassed = !guard || evaluateGuard(guard, resolvedContext, event, snapshot);
+			} catch (err) {
+				const guardType = typeof guard === "string" ? guard : typeof guard === "object" ? guard.type : void 0;
+				throw new Error(`Unable to evaluate guard ${guardType ? `'${guardType}' ` : ""}in transition for event '${eventType}' in state node '${this.id}':\n${err.message}`);
 			}
-			if (c) {
-				r.push(...o.actions), i = o;
+			if (guardPassed) {
+				actions.push(...candidate.actions);
+				selectedTransition = candidate;
 				break;
 			}
 		}
-		return i ? [i] : void 0;
+		return selectedTransition ? [selectedTransition] : void 0;
 	}
+	/** All the event types accepted by this state node and its descendants. */
 	get events() {
 		return memo$1(this, "events", () => {
-			let { states: e } = this, t = new Set(this.ownEvents);
-			if (e) for (let n of Object.keys(e)) {
-				let r = e[n];
-				if (r.states) for (let e of r.events) t.add(`${e}`);
+			const { states } = this;
+			const events = new Set(this.ownEvents);
+			if (states) for (const stateId of Object.keys(states)) {
+				const state = states[stateId];
+				if (state.states) for (const event of state.events) events.add(`${event}`);
 			}
-			return Array.from(t);
+			return Array.from(events);
 		});
 	}
+	/**
+	* All the events that have transitions directly from this state node.
+	*
+	* Excludes any inert events.
+	*/
 	get ownEvents() {
-		let e = Object.keys(Object.fromEntries(this.transitions)), t = new Set(e.filter((e) => this.transitions.get(e).some((e) => !(!e.target && !e.actions.length && !e.reenter))));
-		return Array.from(t);
-	}
-}, k = class StateMachine {
-	constructor(e, t) {
-		this.config = e, this.version = void 0, this.schemas = void 0, this.implementations = void 0, this.options = void 0, this.__xstatenode = !0, this.idMap = /* @__PURE__ */ new Map(), this.root = void 0, this.id = void 0, this.states = void 0, this.events = void 0, this.id = e.id || "(machine)", this.implementations = {
-			actors: t?.actors ?? {},
-			actions: t?.actions ?? {},
-			delays: t?.delays ?? {},
-			guards: t?.guards ?? {}
-		}, this.version = this.config.version, this.schemas = this.config.schemas, this.options = {
+		const keys = Object.keys(Object.fromEntries(this.transitions));
+		const events = new Set(keys.filter((descriptor) => {
+			return this.transitions.get(descriptor).some((transition) => !(!transition.target && !transition.actions.length && !transition.reenter));
+		}));
+		return Array.from(events);
+	}
+};
+var StateMachine = class StateMachine {
+	constructor(config, implementations) {
+		this.config = config;
+		/** The machine's own version. */
+		this.version = void 0;
+		this.schemas = void 0;
+		this.implementations = void 0;
+		/** Runtime options for machine execution. */
+		this.options = void 0;
+		/** @internal */
+		this.__xstatenode = true;
+		/** @internal */
+		this.idMap = /* @__PURE__ */ new Map();
+		this.root = void 0;
+		this.id = void 0;
+		this.states = void 0;
+		this.events = void 0;
+		this.id = config.id || "(machine)";
+		this.implementations = {
+			actors: implementations?.actors ?? {},
+			actions: implementations?.actions ?? {},
+			delays: implementations?.delays ?? {},
+			guards: implementations?.guards ?? {}
+		};
+		this.version = this.config.version;
+		this.schemas = this.config.schemas;
+		this.options = {
 			maxIterations: Infinity,
 			...this.config.options
-		}, this.transition = this.transition.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 O(e, {
+		};
+		this.transition = this.transition.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.states = this.root.states, this.events = this.root.events;
-	}
-	provide(e) {
-		let { actions: t, guards: n, actors: r, delays: i } = this.implementations;
+		});
+		this.root._initialize();
+		formatRouteTransitions(this.root);
+		this.states = this.root.states;
+		this.events = this.root.events;
+	}
+	/**
+	* Clones this state machine with the provided implementations.
+	*
+	* @param implementations Options (`actions`, `guards`, `actors`, `delays`) to
+	*   recursively merge with the existing options.
+	* @returns A new `StateMachine` instance with the provided implementations.
+	*/
+	provide(implementations) {
+		const { actions, guards, actors, delays } = this.implementations;
 		return new StateMachine(this.config, {
 			actions: {
-				...t,
-				...e.actions
+				...actions,
+				...implementations.actions
 			},
 			guards: {
-				...n,
-				...e.guards
+				...guards,
+				...implementations.guards
 			},
 			actors: {
-				...r,
-				...e.actors
+				...actors,
+				...implementations.actors
 			},
 			delays: {
-				...i,
-				...e.delays
+				...delays,
+				...implementations.delays
 			}
 		});
 	}
-	resolveState(e) {
-		let t = resolveStateValue(this.root, e.value), n = getAllStateNodes(getStateNodes(this.root, t));
+	resolveState(config) {
+		const resolvedStateValue = resolveStateValue(this.root, config.value);
+		const nodeSet = getAllStateNodes(getStateNodes(this.root, resolvedStateValue));
 		return createMachineSnapshot({
-			_nodes: [...n],
-			context: e.context || {},
+			_nodes: [...nodeSet],
+			context: config.context || {},
 			children: {},
-			status: isInFinalState(n, this.root) ? "done" : e.status || "active",
-			output: e.output,
-			error: e.error,
-			historyValue: e.historyValue
+			status: isInFinalState(nodeSet, this.root) ? "done" : config.status || "active",
+			output: config.output,
+			error: config.error,
+			historyValue: config.historyValue
 		}, this);
 	}
-	transition(e, t, n) {
-		return macrostep(e, t, n, []).snapshot;
-	}
-	microstep(e, t, n) {
-		return macrostep(e, t, n, []).microsteps.map(([e]) => e);
-	}
-	getTransitionData(e, t) {
-		return transitionNode(this.root, e.value, e, t) || [];
-	}
-	_getPreInitialState(e, t, n) {
-		let { context: r } = this.config, i = createMachineSnapshot({
-			context: typeof r != "function" && r ? r : {},
+	/**
+	* 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) {
+		return macrostep(snapshot, event, actorScope, []).snapshot;
+	}
+	/**
+	* 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) {
+		return macrostep(snapshot, event, actorScope, []).microsteps.map(([s]) => s);
+	}
+	getTransitionData(snapshot, event) {
+		return transitionNode(this.root, snapshot.value, snapshot, event) || [];
+	}
+	/**
+	* 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, internalQueue) {
+		const { context } = this.config;
+		const preInitial = createMachineSnapshot({
+			context: typeof context !== "function" && context ? context : {},
 			_nodes: [this.root],
 			children: {},
 			status: "active"
 		}, this);
-		if (typeof r == "function") {
-			let assignment = ({ spawn: e, event: t, self: n }) => r({
-				spawn: e,
-				input: t.input,
-				self: n
+		if (typeof context === "function") {
+			const assignment = ({ spawn, event, self }) => context({
+				spawn,
+				input: event.input,
+				self
 			});
-			return resolveActionsAndContext(i, t, e, [assign(assignment)], n, void 0);
+			return resolveActionsAndContext(preInitial, initEvent, actorScope, [assign(assignment)], internalQueue, void 0);
 		}
-		return i;
-	}
-	getInitialSnapshot(e, t) {
-		let n = createInitEvent(t), r = [], i = createMachineSnapshot({
-			context: typeof this.config.context != "function" && this.config.context ? this.config.context : {},
+		return preInitial;
+	}
+	/**
+	* Returns the initial `State` instance, with reference to `self` as an
+	* `ActorRef`.
+	*/
+	getInitialSnapshot(actorScope, input) {
+		const initEvent = createInitEvent(input);
+		const internalQueue = [];
+		let snapshot = createMachineSnapshot({
+			context: typeof this.config.context !== "function" && this.config.context ? this.config.context : {},
 			_nodes: [this.root],
 			children: {},
 			status: "active"
 		}, this);
 		try {
-			i = this._getPreInitialState(e, n, r);
-			let [t] = initialMicrostep(this.root, i, e, n, r), { snapshot: a } = macrostep(t, n, e, r);
-			return a;
-		} catch (e) {
-			return cloneMachineSnapshot(i, {
+			snapshot = this._getPreInitialState(actorScope, initEvent, internalQueue);
+			const [nextState] = initialMicrostep(this.root, snapshot, actorScope, initEvent, internalQueue);
+			const { snapshot: macroState } = macrostep(nextState, initEvent, actorScope, internalQueue);
+			return macroState;
+		} catch (error) {
+			return cloneMachineSnapshot(snapshot, {
 				status: "error",
-				error: e
+				error
 			});
 		}
 	}
-	start(e) {
-		Object.values(e.children).forEach((e) => {
-			e.getSnapshot().status === "active" && e.start();
+	start(snapshot) {
+		Object.values(snapshot.children).forEach((child) => {
+			if (child.getSnapshot().status === "active") child.start();
 		});
 	}
-	getStateNodeById(e) {
-		let t = toStatePath(e), n = t.slice(1), r = isStateId(t[0]) ? t[0].slice(1) : t[0], i = this.idMap.get(r);
-		if (!i) throw Error(`Child state node '#${r}' does not exist on machine '${this.id}'`);
-		return getStateNodeByPath(i, n);
+	getStateNodeById(stateId) {
+		const fullPath = toStatePath(stateId);
+		const relativePath = fullPath.slice(1);
+		const resolvedStateId = isStateId(fullPath[0]) ? fullPath[0].slice(1) : fullPath[0];
+		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);
 	}
 	get definition() {
 		return this.root.definition;
@@ -1714,199 +2905,452 @@ var D = {}, toSerializableAction = (e) => typeof e == "string" ? { type: e } : t
 	toJSON() {
 		return this.definition;
 	}
-	getPersistedSnapshot(e, t) {
-		return getPersistedSnapshot(e, t);
-	}
-	restoreSnapshot(e, t) {
-		let n = {}, r = e.children;
-		Object.keys(r).forEach((e) => {
-			let i = r[e], a = i.snapshot, o = i.src, s = typeof o == "string" ? resolveReferencedActor(this, o) : o;
-			if (!s) return;
-			let c = createActor(s, {
-				id: e,
-				parent: t.self,
-				syncSnapshot: i.syncSnapshot,
-				snapshot: a,
-				src: o,
-				systemId: i.systemId
+	getPersistedSnapshot(snapshot, options) {
+		return getPersistedSnapshot(snapshot, options);
+	}
+	restoreSnapshot(snapshot, _actorScope) {
+		const children = {};
+		const snapshotChildren = snapshot.children;
+		Object.keys(snapshotChildren).forEach((actorId) => {
+			const actorData = snapshotChildren[actorId];
+			const childState = actorData.snapshot;
+			const src = actorData.src;
+			const logic = typeof src === "string" ? resolveReferencedActor(this, src) : src;
+			if (!logic) return;
+			const actorRef = createActor(logic, {
+				id: actorId,
+				parent: _actorScope.self,
+				syncSnapshot: actorData.syncSnapshot,
+				snapshot: childState,
+				src,
+				systemId: actorData.systemId
 			});
-			n[e] = c;
+			children[actorId] = actorRef;
 		});
-		function resolveHistoryReferencedState(e, t) {
-			if (t instanceof O) return t;
+		function resolveHistoryReferencedState(root, referenced) {
+			if (referenced instanceof StateNode) return referenced;
 			try {
-				return e.machine.getStateNodeById(t.id);
+				return root.machine.getStateNodeById(referenced.id);
 			} catch {}
 		}
-		function reviveHistoryValue(e, t) {
-			if (!t || typeof t != "object") return {};
-			let n = {};
-			for (let r in t) {
-				let i = t[r];
-				for (let t of i) {
-					let i = resolveHistoryReferencedState(e, t);
-					i && (n[r] ??= [], n[r].push(i));
+		function reviveHistoryValue(root, historyValue) {
+			if (!historyValue || typeof historyValue !== "object") return {};
+			const revived = {};
+			for (const key in historyValue) {
+				const arr = historyValue[key];
+				for (const item of arr) {
+					const resolved = resolveHistoryReferencedState(root, item);
+					if (!resolved) continue;
+					revived[key] ??= [];
+					revived[key].push(resolved);
 				}
 			}
-			return n;
+			return revived;
 		}
-		let i = reviveHistoryValue(this.root, e.historyValue), a = createMachineSnapshot({
-			...e,
-			children: n,
-			_nodes: Array.from(getAllStateNodes(getStateNodes(this.root, e.value))),
-			historyValue: i
-		}, this), o = /* @__PURE__ */ new Set();
-		function reviveContext(e, t) {
-			if (!o.has(e)) {
-				o.add(e);
-				for (let n in e) {
-					let r = e[n];
-					if (r && typeof r == "object") {
-						if ("xstate$$type" in r && r.xstate$$type === 1) {
-							e[n] = t[r.id];
-							continue;
-						}
-						reviveContext(r, t);
+		const revivedHistoryValue = reviveHistoryValue(this.root, snapshot.historyValue);
+		const restoredSnapshot = createMachineSnapshot({
+			...snapshot,
+			children,
+			_nodes: Array.from(getAllStateNodes(getStateNodes(this.root, snapshot.value))),
+			historyValue: revivedHistoryValue
+		}, this);
+		const seen = /* @__PURE__ */ new Set();
+		function reviveContext(contextPart, children) {
+			if (seen.has(contextPart)) return;
+			seen.add(contextPart);
+			for (const key in contextPart) {
+				const value = contextPart[key];
+				if (value && typeof value === "object") {
+					if ("xstate$$type" in value && value.xstate$$type === 1) {
+						contextPart[key] = children[value.id];
+						continue;
 					}
+					reviveContext(value, children);
 				}
 			}
 		}
-		return reviveContext(a.context, n), a;
+		reviveContext(restoredSnapshot.context, children);
+		return restoredSnapshot;
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.6/node_modules/xstate/dist/log-66075555.esm.js
-function resolveEmit(e, t, n, r, { event: i }) {
+//#region ../../node_modules/.pnpm/xstate@5.33.2/node_modules/xstate/dist/log-ddf17a4a.esm.js
+function resolveEmit(_, snapshot, args, actionParams, { event: eventOrExpr }) {
 	return [
-		t,
-		{ event: typeof i == "function" ? i(n, r) : i },
+		snapshot,
+		{ event: typeof eventOrExpr === "function" ? eventOrExpr(args, actionParams) : eventOrExpr },
 		void 0
 	];
 }
-function executeEmit(e, { event: t }) {
-	e.defer(() => e.emit(t));
-}
-function emit(e) {
-	function emit(e, t) {}
-	return emit.type = "xstate.emit", emit.event = e, emit.resolve = resolveEmit, emit.execute = executeEmit, emit;
-}
-var A = /*#__PURE__*/ function(e) {
-	return e.Parent = "#_parent", e.Internal = "#_internal", e;
+function executeEmit(actorScope, { event }) {
+	actorScope.defer(() => actorScope.emit(event));
+}
+/**
+* Emits an event to event handlers registered on the actor via `actor.on(event,
+* handler)`.
+*
+* @example
+*
+* ```ts
+* import { emit } from 'xstate';
+*
+* const machine = createMachine({
+*   // ...
+*   on: {
+*     something: {
+*       actions: emit({
+*         type: 'emitted',
+*         some: 'data'
+*       })
+*     }
+*   }
+*   // ...
+* });
+*
+* const actor = createActor(machine).start();
+*
+* actor.on('emitted', (event) => {
+*   console.log(event);
+* });
+*
+* actor.send({ type: 'something' });
+* // logs:
+* // {
+* //   type: 'emitted',
+* //   some: 'data'
+* // }
+* ```
+*/
+function emit(eventOrExpr) {
+	function emit(_args, _params) {}
+	emit.type = "xstate.emit";
+	emit.event = eventOrExpr;
+	emit.resolve = resolveEmit;
+	emit.execute = executeEmit;
+	return emit;
+}
+/**
+* @remarks
+* `T | unknown` reduces to `unknown` and that can be problematic when it comes
+* to contextual typing. It especially is a problem when the union has a
+* function member, like here:
+*
+* ```ts
+* declare function test(
+*   cbOrVal: ((arg: number) => unknown) | unknown
+* ): void;
+* test((arg) => {}); // oops, implicit any
+* ```
+*
+* This type can be used to avoid this problem. This union represents the same
+* value space as `unknown`.
+*/
+/** @deprecated Use the built-in `NoInfer` type instead */
+/** The full definition of an event, with a string `type`. */
+/**
+* The string or object representing the state value relative to the parent
+* state node.
+*
+* @remarks
+* - For a child atomic state node, this is a string, e.g., `"pending"`.
+* - For complex state nodes, this is an object, e.g., `{ success:
+*   "someChildState" }`.
+*/
+/** @deprecated Use `AnyMachineSnapshot` instead */
+/** @ignore */
+/**
+* Runtime options for state machine execution.
+*
+* @example
+*
+* ```ts
+* const machine = createMachine({
+*   // ... machine config
+*   options: {
+*     maxIterations: 5000
+*     // other runtime options can be added here
+*   }
+* });
+* ```
+*/
+/** Maps history state IDs to recalled nodes, preserving TContext and TEvent with arbitrary metadata. */
+/** Transitions with known context and event types and arbitrary metadata. */
+var SpecialTargets = /*#__PURE__*/ function(SpecialTargets) {
+	SpecialTargets["Parent"] = "#_parent";
+	SpecialTargets["Internal"] = "#_internal";
+	return SpecialTargets;
 }({});
-function resolveSendTo(e, t, n, r, { to: i, event: a, id: o, delay: s }, c) {
-	let l = t.machine.implementations.delays;
-	if (typeof a == "string") throw Error(`Only event objects may be used with sendTo; use sendTo({ type: "${a}" }) instead`);
-	let u = typeof a == "function" ? a(n, r) : a, d;
-	if (typeof s == "string") {
-		let e = l && l[s];
-		d = typeof e == "function" ? e(n, r) : e;
-	} else d = typeof s == "function" ? s(n, r) : s;
-	let f = typeof i == "function" ? i(n, r) : i, p;
-	if (typeof f == "string") {
-		if (p = f === A.Parent ? e.self._parent : f === A.Internal ? e.self : f.startsWith("#_") ? t.children[f.slice(2)] : c.deferredActorIds?.includes(f) ? f : t.children[f], !p) throw Error(`Unable to send event to actor '${f}' from machine '${t.machine.id}'.`);
-	} else p = f || e.self;
+/** @deprecated Use `AnyActor` instead. */
+/** @deprecated Use `Actor<T>` instead. */
+/**
+* Represents logic which can be used by an actor.
+*
+* @template TSnapshot - The type of the snapshot.
+* @template TEvent - The type of the event object.
+* @template TInput - The type of the input.
+* @template TSystem - The type of the actor system.
+*/
+/** @deprecated */
+function resolveSendTo(actorScope, snapshot, args, actionParams, { to, event: eventOrExpr, id, delay }, extra) {
+	const delaysMap = snapshot.machine.implementations.delays;
+	if (typeof eventOrExpr === "string") throw new Error(`Only event objects may be used with sendTo; use sendTo({ type: "${eventOrExpr}" }) instead`);
+	const resolvedEvent = typeof eventOrExpr === "function" ? eventOrExpr(args, actionParams) : eventOrExpr;
+	let resolvedDelay;
+	if (typeof delay === "string") {
+		const configDelay = delaysMap && delaysMap[delay];
+		resolvedDelay = typeof configDelay === "function" ? configDelay(args, actionParams) : configDelay;
+	} else resolvedDelay = typeof delay === "function" ? delay(args, actionParams) : delay;
+	const resolvedTarget = typeof to === "function" ? to(args, actionParams) : to;
+	let targetActorRef;
+	if (typeof resolvedTarget === "string") {
+		if (resolvedTarget === SpecialTargets.Parent) targetActorRef = actorScope.self._parent;
+		else if (resolvedTarget === SpecialTargets.Internal) targetActorRef = actorScope.self;
+		else if (resolvedTarget.startsWith("#_")) targetActorRef = snapshot.children[resolvedTarget.slice(2)];
+		else targetActorRef = extra.deferredActorIds?.includes(resolvedTarget) ? resolvedTarget : snapshot.children[resolvedTarget];
+		if (!targetActorRef) throw new Error(`Unable to send event to actor '${resolvedTarget}' from machine '${snapshot.machine.id}'.`);
+	} else targetActorRef = resolvedTarget || actorScope.self;
 	return [
-		t,
+		snapshot,
 		{
-			to: p,
-			targetId: typeof f == "string" ? f : void 0,
-			event: u,
-			id: o,
-			delay: d
+			to: targetActorRef,
+			targetId: typeof resolvedTarget === "string" ? resolvedTarget : void 0,
+			event: resolvedEvent,
+			id,
+			delay: resolvedDelay
 		},
 		void 0
 	];
 }
-function retryResolveSendTo(e, t, n) {
-	typeof n.to == "string" && (n.to = t.children[n.to]);
+function retryResolveSendTo(_, snapshot, params) {
+	if (typeof params.to === "string") params.to = snapshot.children[params.to];
 }
-function executeSendTo(e, t) {
-	e.defer(() => {
-		let { to: n, event: r, delay: i, id: a } = t;
-		if (typeof i == "number") {
-			e.system.scheduler.schedule(e.self, n, r, i, a);
+function executeSendTo(actorScope, params) {
+	actorScope.defer(() => {
+		const { to, event, delay, id } = params;
+		if (typeof delay === "number") {
+			actorScope.system.scheduler.schedule(actorScope.self, to, event, delay, id);
 			return;
 		}
-		e.system._relay(e.self, n, r.type === "xstate.error" ? createErrorActorEvent(e.self.id, r.data) : r);
+		actorScope.system._relay(actorScope.self, to, event.type === "xstate.error" ? createErrorActorEvent(actorScope.self.id, event.data) : event);
 	});
 }
-function sendTo(e, t, n) {
-	function sendTo(e, t) {}
-	return sendTo.type = "xstate.sendTo", sendTo.to = e, sendTo.event = t, sendTo.id = n?.id, sendTo.delay = n?.delay, sendTo.resolve = resolveSendTo, sendTo.retryResolve = retryResolveSendTo, sendTo.execute = executeSendTo, sendTo;
-}
-function sendParent(e, t) {
-	return sendTo(A.Parent, e, t);
-}
-function resolveEnqueueActions(e, t, n, r, { collect: i }) {
-	let a = [], o = function enqueue(e) {
-		a.push(e);
+/**
+* Sends an event to an actor.
+*
+* @param actor The `ActorRef` to send the event to.
+* @param event The event to send, or an expression that evaluates to the event
+*   to send
+* @param options Send action options
+*
+*   - `id` - The unique send event identifier (used with `cancel()`).
+*   - `delay` - The number of milliseconds to delay the sending of the event.
+*/
+function sendTo(to, eventOrExpr, options) {
+	function sendTo(_args, _params) {}
+	sendTo.type = "xstate.sendTo";
+	sendTo.to = to;
+	sendTo.event = eventOrExpr;
+	sendTo.id = options?.id;
+	sendTo.delay = options?.delay;
+	sendTo.resolve = resolveSendTo;
+	sendTo.retryResolve = retryResolveSendTo;
+	sendTo.execute = executeSendTo;
+	return sendTo;
+}
+/**
+* Sends an event to this machine's parent.
+*
+* @param event The event to send to the parent machine.
+* @param options Options to pass into the send event.
+*/
+function sendParent(event, options) {
+	return sendTo(SpecialTargets.Parent, event, options);
+}
+function resolveEnqueueActions(actorScope, snapshot, args, actionParams, { collect }) {
+	const actions = [];
+	const enqueue = function enqueue(action) {
+		actions.push(action);
+	};
+	enqueue.assign = (...args) => {
+		actions.push(assign(...args));
+	};
+	enqueue.cancel = (...args) => {
+		actions.push(cancel(...args));
+	};
+	enqueue.raise = (...args) => {
+		actions.push(raise(...args));
+	};
+	enqueue.sendTo = (...args) => {
+		actions.push(sendTo(...args));
+	};
+	enqueue.sendParent = (...args) => {
+		actions.push(sendParent(...args));
 	};
-	return o.assign = (...e) => {
-		a.push(assign(...e));
-	}, o.cancel = (...e) => {
-		a.push(cancel(...e));
-	}, o.raise = (...e) => {
-		a.push(raise(...e));
-	}, o.sendTo = (...e) => {
-		a.push(sendTo(...e));
-	}, o.sendParent = (...e) => {
-		a.push(sendParent(...e));
-	}, o.spawnChild = (...e) => {
-		a.push(spawnChild(...e));
-	}, o.stopChild = (...e) => {
-		a.push(stopChild(...e));
-	}, o.emit = (...e) => {
-		a.push(emit(...e));
-	}, i({
-		context: n.context,
-		event: n.event,
-		enqueue: o,
-		check: (e) => evaluateGuard(e, t.context, n.event, t),
-		self: e.self,
-		system: e.system
-	}, r), [
-		t,
+	enqueue.spawnChild = (...args) => {
+		actions.push(spawnChild(...args));
+	};
+	enqueue.stopChild = (...args) => {
+		actions.push(stopChild(...args));
+	};
+	enqueue.emit = (...args) => {
+		actions.push(emit(...args));
+	};
+	collect({
+		context: args.context,
+		event: args.event,
+		enqueue,
+		check: (guard) => evaluateGuard(guard, snapshot.context, args.event, snapshot),
+		self: actorScope.self,
+		system: actorScope.system
+	}, actionParams);
+	return [
+		snapshot,
 		void 0,
-		a
+		actions
 	];
 }
-function enqueueActions(e) {
-	function enqueueActions(e, t) {}
-	return enqueueActions.type = "xstate.enqueueActions", enqueueActions.collect = e, enqueueActions.resolve = resolveEnqueueActions, enqueueActions;
-}
-function resolveLog(e, t, n, r, { value: i, label: a }) {
+/**
+* Creates an action object that will execute actions that are queued by the
+* `enqueue(action)` function.
+*
+* @example
+*
+* ```ts
+* import { createMachine, enqueueActions } from 'xstate';
+*
+* const machine = createMachine({
+*   entry: enqueueActions(({ enqueue, check }) => {
+*     enqueue.assign({ count: 0 });
+*
+*     if (check('someGuard')) {
+*       enqueue.assign({ count: 1 });
+*     }
+*
+*     enqueue('someAction');
+*   })
+* });
+* ```
+*/
+function enqueueActions(collect) {
+	function enqueueActions(_args, _params) {}
+	enqueueActions.type = "xstate.enqueueActions";
+	enqueueActions.collect = collect;
+	enqueueActions.resolve = resolveEnqueueActions;
+	return enqueueActions;
+}
+function resolveLog(_, snapshot, actionArgs, actionParams, { value, label }) {
 	return [
-		t,
+		snapshot,
 		{
-			value: typeof i == "function" ? i(n, r) : i,
-			label: a
+			value: typeof value === "function" ? value(actionArgs, actionParams) : value,
+			label
 		},
 		void 0
 	];
 }
-function executeLog({ logger: e }, { value: t, label: n }) {
-	n ? e(n, t) : e(t);
-}
-function log(e = ({ context: e, event: t }) => ({
-	context: e,
-	event: t
-}), t) {
-	function log(e, t) {}
-	return log.type = "xstate.log", log.value = e, log.label = t, log.resolve = resolveLog, log.execute = executeLog, log;
+function executeLog({ logger }, { value, label }) {
+	if (label) logger(label, value);
+	else logger(value);
+}
+/**
+* @param expr The expression function to evaluate which will be logged. Takes
+*   in 2 arguments:
+*
+*   - `ctx` - the current state context
+*   - `event` - the event that caused this action to be executed.
+*
+* @param label The label to give to the logged expression.
+*/
+function log(value = ({ context, event }) => ({
+	context,
+	event
+}), label) {
+	function log(_args, _params) {}
+	log.type = "xstate.log";
+	log.value = value;
+	log.label = label;
+	log.resolve = resolveLog;
+	log.execute = executeLog;
+	return log;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/xstate@5.32.6/node_modules/xstate/dist/xstate.esm.js
-function assertEvent(e, t) {
-	let n = toArray(t);
-	if (!n.some((t) => matchesEventDescriptor(e.type, t))) {
-		let t = n.length === 1 ? `type matching "${n[0]}"` : `one of types matching "${n.join("\", \"")}"`;
-		throw Error(`Expected event ${JSON.stringify(e)} to have ${t}`);
-	}
-}
-function createMachine(e, t) {
-	return new k(e, t);
-}
-function setup({ schemas: e, actors: t, actions: n, guards: r, delays: i }) {
+//#region ../../node_modules/.pnpm/xstate@5.33.2/node_modules/xstate/dist/xstate.esm.js
+/**
+* Asserts that the given event object is of the specified type or types. Throws
+* an error if the event object is not of the specified types.
+*
+* @example
+*
+* ```ts
+* // ...
+* entry: ({ event }) => {
+*   assertEvent(event, 'doNothing');
+*   // event is { type: 'doNothing' }
+* },
+* // ...
+* exit: ({ event }) => {
+*   assertEvent(event, 'greet');
+*   // event is { type: 'greet'; message: string }
+*
+*   assertEvent(event, ['greet', 'notify']);
+*   // event is { type: 'greet'; message: string }
+*   // or { type: 'notify'; message: string; level: 'info' | 'error' }
+* },
+* ```
+*/
+function assertEvent(event, type) {
+	const types = toArray(type);
+	if (!types.some((descriptor) => matchesEventDescriptor(event.type, descriptor))) {
+		const typesText = types.length === 1 ? `type matching "${types[0]}"` : `one of types matching "${types.join("\", \"")}"`;
+		throw new Error(`Expected event ${JSON.stringify(event)} to have ${typesText}`);
+	}
+}
+/**
+* Creates a state machine (statechart) with the given configuration.
+*
+* The state machine represents the pure logic of a state machine actor.
+*
+* @example
+*
+* ```ts
+* import { createMachine } from 'xstate';
+*
+* const lightMachine = createMachine({
+*   id: 'light',
+*   initial: 'green',
+*   states: {
+*     green: {
+*       on: {
+*         TIMER: { target: 'yellow' }
+*       }
+*     },
+*     yellow: {
+*       on: {
+*         TIMER: { target: 'red' }
+*       }
+*     },
+*     red: {
+*       on: {
+*         TIMER: { target: 'green' }
+*       }
+*     }
+*   }
+* });
+*
+* const lightActor = createActor(lightMachine);
+* lightActor.start();
+*
+* lightActor.send({ type: 'TIMER' });
+* ```
+*
+* @param config The state machine configuration.
+* @param options DEPRECATED: use `setup({ ... })` or `machine.provide({ ... })`
+*   to provide machine implementations instead.
+*/
+function createMachine(config, implementations) {
+	return new StateMachine(config, implementations);
+}
+function setup({ schemas, actors, actions, guards, delays }) {
 	return {
 		assign,
 		sendTo,
@@ -1917,99 +3361,111 @@ function setup({ schemas: e, actors: t, actions: n, guards: r, delays: i }) {
 		enqueueActions,
 		emit,
 		spawnChild,
-		createStateConfig: (e) => e,
-		createAction: (e) => e,
-		createMachine: (a) => createMachine({
-			...a,
-			schemas: e
+		createStateConfig: (config) => config,
+		createAction: (fn) => fn,
+		createMachine: (config) => createMachine({
+			...config,
+			schemas
 		}, {
-			actors: t,
-			actions: n,
-			guards: r,
-			delays: i
+			actors,
+			actions,
+			guards,
+			delays
 		}),
-		extend: (a) => setup({
-			schemas: e,
-			actors: t,
+		extend: (extended) => setup({
+			schemas,
+			actors,
 			actions: {
-				...n,
-				...a.actions
+				...actions,
+				...extended.actions
 			},
 			guards: {
-				...r,
-				...a.guards
+				...guards,
+				...extended.guards
 			},
 			delays: {
-				...i,
-				...a.delays
+				...delays,
+				...extended.delays
 			}
 		})
 	};
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@xstate+react@6.1.0_@types+react@19.2.18_react@19.2.8_xstate@5.32.6/node_modules/@xstate/react/dist/xstate-react.esm.js
-var forEachActor = (e, t) => {
-	t(e);
-	let n = e.getSnapshot().children;
-	n && Object.values(n).forEach((e) => {
-		forEachActor(e, t);
+//#region ../../node_modules/.pnpm/@xstate+react@6.1.0_@types+react@19.3.0_react@19.3.0_xstate@5.33.2/node_modules/@xstate/react/dist/xstate-react.esm.js
+var forEachActor = (actorRef, callback) => {
+	callback(actorRef);
+	const children = actorRef.getSnapshot().children;
+	if (children) Object.values(children).forEach((child) => {
+		forEachActor(child, callback);
 	});
 };
-function stopRootWithRehydration(e) {
-	let t = [];
-	forEachActor(e, (e) => {
-		t.push([e, e.getSnapshot()]), e.observers = /* @__PURE__ */ new Set();
+function stopRootWithRehydration(actorRef) {
+	const persistedSnapshots = [];
+	forEachActor(actorRef, (ref) => {
+		persistedSnapshots.push([ref, ref.getSnapshot()]);
+		ref.observers = /* @__PURE__ */ new Set();
 	});
-	let n = e.system.getSnapshot?.();
-	e.stop(), e.system._snapshot = n, t.forEach(([e, t]) => {
-		e._processingStatus = 0, e._snapshot = t;
+	const systemSnapshot = actorRef.system.getSnapshot?.();
+	actorRef.stop();
+	actorRef.system._snapshot = systemSnapshot;
+	persistedSnapshots.forEach(([ref, snapshot]) => {
+		ref._processingStatus = 0;
+		ref._snapshot = snapshot;
 	});
 }
-function useIdleActorRef(e, ...[t]) {
-	let [[n, r], a] = i(() => {
-		let n = createActor(e, t);
-		return [e.config, n];
+function useIdleActorRef(logic, ...[options]) {
+	let [[currentConfig, actorRef], setCurrent] = useState(() => {
+		const actorRef = createActor(logic, options);
+		return [logic.config, actorRef];
 	});
-	if (e.config !== n) {
-		let n = createActor(e, {
-			...t,
-			snapshot: r.getPersistedSnapshot({ __unsafeAllowInlineActors: !0 })
+	if (logic.config !== currentConfig) {
+		const newActorRef = createActor(logic, {
+			...options,
+			snapshot: actorRef.getPersistedSnapshot({ __unsafeAllowInlineActors: true })
 		});
-		a([e.config, n]), r = n;
+		setCurrent([logic.config, newActorRef]);
+		actorRef = newActorRef;
 	}
-	return o(() => {
-		r.logic.implementations = e.implementations;
-	}), r;
+	index(() => {
+		actorRef.logic.implementations = logic.implementations;
+	});
+	return actorRef;
 }
-function useActorRef(e, ...[t, r]) {
-	let i = useIdleActorRef(e, t);
-	return n(() => {
-		if (!r) return;
-		let e = i.subscribe(toObserver(r));
+function useActorRef(machine, ...[options, observerOrListener]) {
+	const actorRef = useIdleActorRef(machine, options);
+	useEffect(() => {
+		if (!observerOrListener) return;
+		const sub = actorRef.subscribe(toObserver(observerOrListener));
+		return () => {
+			sub.unsubscribe();
+		};
+	}, [observerOrListener]);
+	useEffect(() => {
+		actorRef.start();
 		return () => {
-			e.unsubscribe();
+			stopRootWithRehydration(actorRef);
 		};
-	}, [r]), n(() => (i.start(), () => {
-		stopRootWithRehydration(i);
-	}), [i]), i;
-}
-function defaultCompare(e, t) {
-	return e === t;
-}
-function useSelector(e, n, r = defaultCompare) {
-	let i = t((t) => {
-		if (!e) return () => {};
-		let { unsubscribe: n } = e.subscribe({
-			next: t,
-			error: t
+	}, [actorRef]);
+	return actorRef;
+}
+function defaultCompare(a, b) {
+	return a === b;
+}
+function useSelector(actor, selector, compare = defaultCompare) {
+	const subscribe = useCallback((handleStoreChange) => {
+		if (!actor) return () => {};
+		const { unsubscribe } = actor.subscribe({
+			next: handleStoreChange,
+			error: handleStoreChange
 		});
-		return n;
-	}, [e]), o = t(() => {
-		let t = e?.getSnapshot();
-		if (t && "status" in t && t.status === "error") throw t.error;
-		return t;
-	}, [e]);
-	return a(i, o, o, n, r);
+		return unsubscribe;
+	}, [actor]);
+	const boundGetSnapshot = useCallback(() => {
+		const snapshot = actor?.getSnapshot();
+		if (snapshot && "status" in snapshot && snapshot.status === "error") throw snapshot.error;
+		return snapshot;
+	}, [actor]);
+	return useSyncExternalStoreWithSelector(subscribe, boundGetSnapshot, boundGetSnapshot, selector, compare);
 }
 //#endregion
 export { spawnChild as _, emit as a, sendTo as c, fromPromise as d, and as f, raise as g, or as h, setup as i, assign as l, not as m, useSelector as n, enqueueActions as o, cancel as p, assertEvent as r, log as s, useActorRef as t, fromCallback as u, stopChild as v };