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

package/dist/createActor-BGHd7i8Q.mjs

@@ -0,0 +1,4851 @@
+import { C as XSTATE_TERMINATE, S as XSTATE_STOP, _ as XSTATE_LOGIC_EFFECT_REJECT, a as isActorRefLike, b as XSTATE_SPAWN, c as matchesEventDescriptor, d as resolveReferencedActor, f as toArray, g as XSTATE_INIT, h as defaultWarn, i as getEventOutput, l as normalizeTarget, m as toTransitionConfigArray, o as isErrorEvent, p as toObserver, s as mapValues, t as createInvokeId, u as resolveOutput, v as XSTATE_LOGIC_EFFECT_RESOLVE, w as XSTATE_TIMER, x as XSTATE_START, y as XSTATE_LOGIC_EFFECT_START } from "./utils-CXBxxp3Z.mjs";
+// src/eventUtils.ts
+/**
+* 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",
+		delay: delayRef,
+		stateId: id
+	};
+}
+function createAfterEventId(delayRef, id) {
+	return `xstate.after.${delayRef}.${id}`;
+}
+/**
+* Returns an event that represents an implicit state-level timeout. Fired when
+* a state's `timeout` duration elapses without the state being exited.
+*
+* @param id The state node ID where this timeout is configured
+*/
+function createTimeoutEvent(id) {
+	return {
+		type: "xstate.timeout",
+		stateId: id
+	};
+}
+function createTimeoutEventId(id) {
+	return `xstate.timeout.${id}`;
+}
+/**
+* Returns an event that represents an implicit invoke-level timeout. Fired when
+* an invoked actor has not completed within its `timeout` duration.
+*
+* @param invokeId The invoked actor's ID
+*/
+function createInvokeTimeoutEvent(invokeId, sessionId) {
+	return {
+		type: "xstate.timeout.actor",
+		actorId: invokeId,
+		sessionId
+	};
+}
+function createInvokeTimeoutEventId(invokeId) {
+	return `xstate.timeout.actor.${invokeId}`;
+}
+/**
+* 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",
+		stateId: id,
+		output
+	};
+}
+/**
+* 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
+* @param sessionId The unique session ID of the completed actor
+*/
+function createDoneActorEvent(invokeId, output, sessionId) {
+	return {
+		type: "xstate.done.actor",
+		output,
+		actorId: invokeId,
+		sessionId
+	};
+}
+function createErrorActorEvent(id, error, sessionId) {
+	return {
+		type: "xstate.error.actor",
+		error,
+		actorId: id,
+		sessionId
+	};
+}
+function createErrorPlatformEvent(kind, error) {
+	return {
+		type: `xstate.error.${kind}`,
+		error
+	};
+}
+function createInitEvent(input) {
+	return {
+		type: XSTATE_INIT,
+		input
+	};
+}
+// src/Mailbox.ts
+var Mailbox = class {
+	_process;
+	_active = false;
+	_current = null;
+	_last = null;
+	constructor(_process) {
+		this._process = _process;
+	}
+	start() {
+		this._active = true;
+		this.flush();
+	}
+	clear() {
+		if (this._current) {
+			this._current.next = null;
+			this._last = this._current;
+		}
+	}
+	enqueue(event) {
+		const enqueued = {
+			value: event,
+			next: null
+		};
+		if (this._current) {
+			this._last.next = enqueued;
+			this._last = enqueued;
+			return;
+		}
+		this._current = enqueued;
+		this._last = enqueued;
+		if (this._active) this.flush();
+	}
+	flush() {
+		while (this._current) {
+			const consumed = this._current;
+			this._process(consumed.value);
+			this._current = consumed.next;
+		}
+		this._last = null;
+	}
+};
+// src/symbolObservable.ts
+const symbolObservable = (() => typeof Symbol === "function" && Symbol.observable || "@@observable")();
+// src/inspectionAmbient.ts
+/**
+* The ambiently installed system inspector. Set for the duration of a durable
+* execution's transitions (`createDurable(..., { inspect })`), it makes the
+* pure-transition machinery observable: freshly constructed runtime systems
+* attach it, and snapshot systems created while it is set forward inspection
+* to their base system instead of stubbing it out.
+*/
+let ambientInspector;
+/** @internal */
+function hasAmbientInspector() {
+	return ambientInspector !== void 0;
+}
+/** @internal */
+function getAmbientInspector() {
+	return ambientInspector;
+}
+/**
+* Runs `fn` with systems it creates wired to `inspect` from construction, so
+* creation-time inspection events (the root actor's own registration, actors
+* spawned during the first transition) are observed too.
+*
+* @internal
+*/
+function withSystemInspector(inspect, fn) {
+	if (!inspect) return fn();
+	const previous = ambientInspector;
+	ambientInspector = inspect;
+	try {
+		return fn();
+	} finally {
+		ambientInspector = previous;
+	}
+}
+// src/reportUnhandledError.ts
+/**
+* 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 err;
+	});
+}
+// src/runtimeHelpers.ts
+function getStepEffect(actor, key) {
+	const effects = actor.getSnapshot().effects;
+	return effects && Object.prototype.hasOwnProperty.call(effects, key) ? effects[key] : void 0;
+}
+const pendingSteps = /* @__PURE__ */ new WeakMap();
+/**
+* Runs one keyed step of an async actor with the built-in journal: the
+* result is memoized in the actor's own snapshot (`effects[key]`), so a
+* restored actor skips completed steps when its logic function re-runs.
+* Custom runtimes that implement `runStep` use this for the default local
+* behavior, the same way `deliverEvent` exposes local delivery.
+*
+* @experimental
+*/
+async function runStep(actor, key, exec, sendSelf = (event) => void actor.system.sendEvent(actor, actor, event)) {
+	const effect = getStepEffect(actor, key);
+	if (effect?.status === "done") return effect.output;
+	if (effect?.status === "error") throw effect.error;
+	const running = pendingSteps.get(actor)?.get(key);
+	if (running) return running;
+	if (actor.getSnapshot().status !== "active") throw new Error(`Actor terminated before step "${key}" completed`);
+	let resolve;
+	let reject;
+	const promise = new Promise((resolvePromise, rejectPromise) => {
+		resolve = resolvePromise;
+		reject = rejectPromise;
+	});
+	let steps = pendingSteps.get(actor);
+	if (!steps) {
+		steps = /* @__PURE__ */ new Map();
+		pendingSteps.set(actor, steps);
+	}
+	steps.set(key, promise);
+	let subscription;
+	const cleanup = () => {
+		subscription?.unsubscribe();
+		steps.delete(key);
+		if (!steps.size) pendingSteps.delete(actor);
+	};
+	promise.then(cleanup, cleanup);
+	subscription = actor.subscribe({
+		error: reject,
+		complete: () => reject(/* @__PURE__ */ new Error(`Actor terminated before step "${key}" completed`))
+	});
+	(async () => {
+		try {
+			sendSelf({
+				type: XSTATE_LOGIC_EFFECT_START,
+				key
+			});
+			const output = await exec();
+			if (actor.getSnapshot().status === "active") {
+				sendSelf({
+					type: XSTATE_LOGIC_EFFECT_RESOLVE,
+					key,
+					output
+				});
+				resolve(output);
+			}
+		} catch (error) {
+			if (actor.getSnapshot().status === "active") sendSelf({
+				type: XSTATE_LOGIC_EFFECT_REJECT,
+				key,
+				error
+			});
+			reject(error);
+		}
+	})().catch(reject);
+	return promise;
+}
+/**
+* Delivers an event directly to a target actor, bypassing any installed host
+* runtime. Custom runtimes use this for the default local delivery behavior
+* inside their own `sendEvent` implementations.
+*
+* @experimental
+*/
+function deliverEvent(source, target, event) {
+	if (rejectUndeliverableEvent(source, target, event)) return;
+	const runtimeTarget = target;
+	runtimeTarget._lastSourceRef = source;
+	runtimeTarget._send(event);
+}
+/**
+* Returns the boundary error preventing this delivery, if any: an internal
+* event type cannot cross an actor boundary from an external sender.
+*/
+function getEventBoundaryError(source, target, event) {
+	if (source !== target && target.logic?.isInternalEventType?.(event.type)) return /* @__PURE__ */ new Error(`Internal event "${event.type}" cannot be sent to actor "${target.id}" from outside.`);
+}
+/**
+* Rejects an event that must not cross the delivery boundary — an internal
+* event type sent from outside its owning actor — by reporting it as a dead
+* letter. Returns `true` when the event was rejected and must not be
+* delivered. Host runtimes must call this before taking ownership of
+* delivery.
+*/
+function rejectUndeliverableEvent(source, target, event) {
+	const error = getEventBoundaryError(source, target, event);
+	if (error) {
+		target.system.deadLetter(source, target, event, "internalEvent", { error });
+		return true;
+	}
+	return false;
+}
+/**
+* Publishes an actor's terminal result, notifying its parent and observers.
+* Custom runtimes use this for the default local behavior inside their own
+* `terminateActor` implementations.
+*
+* @experimental
+*/
+function terminateActor(actor, termination) {
+	actor._terminate(termination);
+}
+/**
+* Stops an actor without producing a completion result. Custom runtimes use
+* this for the default local behavior inside their own `stopActor`
+* implementations.
+*
+* @experimental
+*/
+function stopActor(actor) {
+	actor._stop();
+}
+// src/snapshotActorRef.ts
+const snapshotActorRefs = /* @__PURE__ */ new WeakMap();
+const lazySnapshotActorRefs = /* @__PURE__ */ new WeakMap();
+const emptyKeyedActors = /* @__PURE__ */ new Map();
+function copyRegisteredActors(system, state) {
+	if (state) {
+		const children = new Map(state.children);
+		if (state.root?.sessionId) children.set(state.root.sessionId, state.root);
+		return children;
+	}
+	return new Map(system.children);
+}
+function captureRegisteredActors(system) {
+	const root = system._getRootActor?.();
+	const peekedChildren = system._peekChildren?.();
+	if (!root && !peekedChildren) {
+		if (system._getRootActor && system._peekChildren) return {};
+		const children = new Map(system.children);
+		return children.size ? { children } : {};
+	}
+	if (!peekedChildren?.size) return root ? { root } : {};
+	return { children: new Map(system.children) };
+}
+function getKeyedActors(system) {
+	const peek = system._peekKeyedActors;
+	if (peek) return peek.call(system) ?? emptyKeyedActors;
+	return system.keyedActors;
+}
+/** Marks topology or persisted runtime state as changed. @internal */
+function markSystemSnapshotDirty(system) {
+	system._snapshotVersion++;
+}
+function getSystemSnapshotVersion(system) {
+	return system._snapshotVersion;
+}
+function getSnapshotChildren(snapshot) {
+	return "children" in snapshot && snapshot.children ? snapshot.children : {};
+}
+/**
+* Creates the isolated receptionist/id view used by a pure branch. Scheduling,
+* relaying and clocks remain delegated to the snapshot's execution system.
+*
+* @internal
+*/
+function createSnapshotSystem(baseSystem, children, baseState) {
+	const forwardInspection = hasAmbientInspector();
+	const registeredActors = copyRegisteredActors(baseSystem, baseState);
+	const keyedActors = new Map(baseState?.keyedActors ?? getKeyedActors(baseSystem));
+	const reverseKeyedActors = /* @__PURE__ */ new WeakMap();
+	const system = Object.assign(Object.create(baseSystem), {
+		children: registeredActors,
+		keyedActors,
+		reverseKeyedActors,
+		_snapshot: { ...baseState?.snapshot ?? baseSystem._snapshot },
+		_snapshotVersion: baseState?.sourceVersion ?? baseSystem._snapshotVersion,
+		_register: (sessionId, actor) => {
+			registeredActors.set(sessionId, actor);
+			markSystemSnapshotDirty(system);
+			return sessionId;
+		},
+		_unregister: (actor) => {
+			if (actor.sessionId) registeredActors.delete(actor.sessionId);
+			const registryKey = reverseKeyedActors.get(actor);
+			if (registryKey !== void 0 && keyedActors.get(registryKey) === actor) keyedActors.delete(registryKey);
+			reverseKeyedActors.delete(actor);
+			markSystemSnapshotDirty(system);
+		},
+		_set: (registryKey, actor) => {
+			const existing = keyedActors.get(registryKey);
+			if (existing && existing !== actor) throw new Error(`Actor with registry key '${String(registryKey)}' already exists.`);
+			keyedActors.set(registryKey, actor);
+			reverseKeyedActors.set(actor, registryKey);
+			markSystemSnapshotDirty(system);
+		},
+		get: (registryKey) => keyedActors.get(registryKey),
+		getAll: () => Object.fromEntries(keyedActors),
+		_hasInspectionObservers: forwardInspection ? () => baseSystem._hasInspectionObservers?.() ?? false : () => false,
+		_sendInspectionEvent: forwardInspection ? (event) => baseSystem._sendInspectionEvent(event) : () => {}
+	});
+	for (const [registryKey, actor] of keyedActors) {
+		if (!actor) continue;
+		reverseKeyedActors.set(actor, registryKey);
+	}
+	for (const actor of Object.values(children)) {
+		if (!actor) continue;
+		if (actor.sessionId) registeredActors.set(actor.sessionId, actor);
+		const registryKey = actor.registryKey;
+		if (registryKey) {
+			keyedActors.set(registryKey, actor);
+			reverseKeyedActors.set(actor, registryKey);
+		}
+	}
+	return system;
+}
+/** Returns the actor identity associated with a transition snapshot. @internal */
+function getSnapshotActorRef(snapshot) {
+	const existing = snapshotActorRefs.get(snapshot);
+	if (existing) return existing;
+	const create = lazySnapshotActorRefs.get(snapshot);
+	if (!create) return;
+	const created = create();
+	snapshotActorRefs.set(snapshot, created);
+	lazySnapshotActorRefs.delete(snapshot);
+	return created;
+}
+/** Reads an already materialized snapshot association without creating one. @internal */
+function peekSnapshotActorRef(snapshot) {
+	return snapshotActorRefs.get(snapshot);
+}
+/** Returns the existing identity provider without resolving it. @internal */
+function getSnapshotActorRefProvider(snapshot) {
+	const existing = snapshotActorRefs.get(snapshot);
+	return existing ? () => existing : lazySnapshotActorRefs.get(snapshot);
+}
+/** Defers actor/system identity allocation until a snapshot capability is used. @internal */
+function setLazySnapshotActorRef(snapshot, create) {
+	snapshotActorRefs.delete(snapshot);
+	lazySnapshotActorRefs.set(snapshot, create);
+}
+/**
+* Copies an internal actor association without rebuilding its system view.
+*
+* @internal
+*/
+function copySnapshotActorRef(source, target) {
+	const ref = snapshotActorRefs.get(source);
+	if (ref) {
+		snapshotActorRefs.set(target, ref);
+		return true;
+	}
+	const create = lazySnapshotActorRefs.get(source);
+	if (create) {
+		lazySnapshotActorRefs.set(target, create);
+		return true;
+	}
+	return false;
+}
+/** Refreshes the only topology change made by an otherwise idle root start. */
+function refreshSnapshotActorRefRoot(snapshot, actor, system) {
+	const ref = snapshotActorRefs.get(snapshot);
+	const sourceVersion = getSystemSnapshotVersion(system);
+	if (ref?.actor !== actor || ref.systemState.sourceSystem !== system || ref.systemState.sourceVersion + 1 !== sourceVersion || system._getRootActor?.() !== actor || system._peekChildren?.()) return false;
+	ref.systemState.root = actor;
+	ref.systemState.sourceVersion = sourceVersion;
+	return true;
+}
+/**
+* Associates a transition snapshot with an actor and an immutable system view.
+* The internal association is excluded from enumeration and persistence.
+*
+* @internal
+*/
+function setSnapshotActorRef(snapshot, actor, baseSystem = actor.system, previousSnapshot) {
+	lazySnapshotActorRefs.delete(snapshot);
+	const sourceVersion = getSystemSnapshotVersion(baseSystem);
+	const previousRef = previousSnapshot ? getSnapshotActorRef(previousSnapshot) : void 0;
+	const reusableRef = previousRef?.actor === actor ? previousRef : getSnapshotActorRef(snapshot);
+	if (reusableRef?.actor === actor && reusableRef.systemState.sourceSystem === baseSystem && reusableRef.systemState.sourceVersion === sourceVersion) {
+		snapshotActorRefs.set(snapshot, reusableRef);
+		return;
+	}
+	const capturedActors = captureRegisteredActors(baseSystem);
+	let children = capturedActors.children;
+	const baseKeyedActors = getKeyedActors(baseSystem);
+	let keyedActors = baseKeyedActors.size ? new Map(baseKeyedActors) : emptyKeyedActors;
+	for (const child of Object.values(getSnapshotChildren(snapshot))) {
+		if (!child) continue;
+		if (child.sessionId) (children ??= /* @__PURE__ */ new Map()).set(child.sessionId, child);
+		const registryKey = child.registryKey;
+		if (registryKey) {
+			if (keyedActors === emptyKeyedActors) keyedActors = /* @__PURE__ */ new Map();
+			keyedActors.set(registryKey, child);
+		}
+	}
+	snapshotActorRefs.set(snapshot, {
+		actor,
+		systemState: {
+			...capturedActors,
+			children,
+			keyedActors,
+			snapshot: { ...baseSystem._snapshot },
+			sourceSystem: baseSystem,
+			sourceVersion
+		}
+	});
+}
+// src/system.ts
+const defaultWallClock = { now: () => Date.now() };
+let systemIdPrefix;
+let nextSystemId = 0;
+/** @internal */
+const transitionEffectSignal = /* @__PURE__ */ new Error("Transition effect");
+/** @internal */
+const transitionEffectTargets = [];
+function readGlobalCrypto() {
+	try {
+		return globalThis.crypto;
+	} catch {
+		return;
+	}
+}
+function createSystemIdPrefix(crypto) {
+	if (crypto?.getRandomValues) try {
+		const values = crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(4));
+		return Array.from(values, (value) => value.toString(36).padStart(7, "0")).join("");
+	} catch {}
+	if (crypto?.randomUUID) try {
+		return crypto.randomUUID().replaceAll("-", "");
+	} catch {}
+	return `xstate-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function createSystemId(crypto) {
+	return `${crypto === void 0 ? systemIdPrefix ??= createSystemIdPrefix(readGlobalCrypto()) : createSystemIdPrefix(crypto)}:${(nextSystemId++).toString(36)}`;
+}
+let ambientExecutionIdentity;
+/** @internal Runs `fn` with systems it creates pinned to `identity`. */
+function withExecutionIdentity(identity, fn) {
+	if (!identity) return fn();
+	const previous = ambientExecutionIdentity;
+	ambientExecutionIdentity = identity;
+	try {
+		return fn();
+	} finally {
+		ambientExecutionIdentity = previous;
+	}
+}
+/**
+* Derives the deterministic id prefix for a generated actor id from its actor
+* source: the registered source key when the source is a string, the logic's
+* own `id` otherwise, with `x` as the last-resort prefix.
+*
+* @internal
+*/
+function getActorIdPrefix(src) {
+	if (typeof src === "string") return src;
+	const logicId = src?.id;
+	return typeof logicId === "string" && logicId.length && logicId !== "(machine)" ? logicId : "x";
+}
+/**
+* Encodes one actor id as an address segment. `/` separates segments, so it
+* is percent-encoded, and the escape character `%` is escaped first so the
+* encoding stays injective: the ids 'a/b' and 'a%2Fb' must not produce the
+* same address.
+*
+* @internal
+*/
+function encodeAddressSegment(id) {
+	return id.includes("/") || id.includes("%") ? id.replaceAll("%", "%25").replaceAll("/", "%2F") : id;
+}
+/**
+* Parses a generated-shaped actor id (`prefix:<n>`). This single definition is
+* the determinism contract for id reservation: live allocation, replay, and
+* restore must all agree on what counts as generated-shaped. Deliberately
+* broader than ids a generated allocation could produce — over-reserving
+* skips numbers, which is harmless, while under-reserving could collide.
+*
+* @internal
+*/
+function parseGeneratedActorId(id) {
+	const separator = id.lastIndexOf(":");
+	if (separator <= 0 || separator === id.length - 1) return;
+	const index = Number(id.slice(separator + 1));
+	return Number.isSafeInteger(index) && index >= 0 ? {
+		prefix: id.slice(0, separator),
+		index
+	} : void 0;
+}
+/**
+* The id (and address root segment) of the first parentless actor of a logic:
+* the logic's own name, or `x:0` for anonymous logic.
+*
+* @internal
+*/
+function getRootActorId(src) {
+	const prefix = getActorIdPrefix(src);
+	return prefix === "x" ? "x:0" : prefix;
+}
+function getActorIdCounterKey(parent, prefix) {
+	return `${parent ? parent.address : ""}|${prefix}`;
+}
+function bumpActorIdCounter(system, counterKey, next) {
+	const counters = system._snapshot._nextActorIds;
+	if ((counters[counterKey] ?? 0) >= next) return;
+	system._snapshot._nextActorIds = {
+		...counters,
+		[counterKey]: next
+	};
+	markSystemSnapshotDirty(system);
+}
+/** @internal */
+function resolveActorId(system, requestedId, options) {
+	if (requestedId !== void 0) {
+		const generated = parseGeneratedActorId(requestedId);
+		if (generated) bumpActorIdCounter(system, getActorIdCounterKey(options?.parent, generated.prefix), generated.index + 1);
+		else if (!options?.parent) bumpActorIdCounter(system, getActorIdCounterKey(void 0, requestedId), 1);
+		return requestedId;
+	}
+	const prefix = getActorIdPrefix(options?.src);
+	const counterKey = getActorIdCounterKey(options?.parent, prefix);
+	const counter = system._snapshot._nextActorIds[counterKey] ?? 0;
+	bumpActorIdCounter(system, counterKey, counter + 1);
+	return !options?.parent && prefix !== "x" && counter === 0 ? prefix : `${prefix}:${counter}`;
+}
+/** @internal */
+function bookSessionId(system) {
+	return `${system._identity.systemId}:${system._identity.nextSessionId++}`;
+}
+/** @internal Every operation of `ActorSystemRuntime`, for runtime wrappers. */
+const RUNTIME_OPERATIONS = [
+	"spawnActor",
+	"startActor",
+	"stopActor",
+	"terminateActor",
+	"emitEvent",
+	"scheduleTimer",
+	"cancelTimer",
+	"cancelAllTimers",
+	"deadLetter"
+];
+const emptyScheduledTimers = Object.freeze({});
+function createScheduledTimerId(actor, id) {
+	return `${actor.sessionId}.${id}`;
+}
+var RuntimeSystem = class {
+	_rootActor;
+	_identity;
+	_snapshot;
+	_snapshotVersion = 0;
+	scheduler = this;
+	_clock;
+	_wallClock;
+	_logger;
+	_reportUnhandledError;
+	_warn;
+	createActorRef;
+	get children() {
+		const children = this._children ??= /* @__PURE__ */ new Map();
+		const rootActor = this._getRootActor();
+		if (rootActor?.sessionId !== void 0) children.set(rootActor.sessionId, rootActor);
+		return children;
+	}
+	set children(children) {
+		this._children = children;
+	}
+	_getRootActor() {
+		return this._rootActor._isRunning() ? this._rootActor : void 0;
+	}
+	_peekChildren() {
+		return this._children;
+	}
+	get keyedActors() {
+		return this._keyedActors ??= /* @__PURE__ */ new Map();
+	}
+	set keyedActors(actors) {
+		this._keyedActors = actors;
+	}
+	get reverseKeyedActors() {
+		return this._reverseKeyedActors ??= /* @__PURE__ */ new WeakMap();
+	}
+	set reverseKeyedActors(actors) {
+		this._reverseKeyedActors = actors;
+	}
+	/** @internal Avoids materializing the receptionist for empty systems. */
+	_peekKeyedActors() {
+		return this._keyedActors;
+	}
+	constructor(_rootActor, options) {
+		this._rootActor = _rootActor;
+		this._identity = ambientExecutionIdentity ?? {
+			systemId: createSystemId(options.crypto),
+			nextSessionId: 0
+		};
+		const restoredSnapshot = typeof options.snapshot === "object" && options.snapshot !== null ? options.snapshot : void 0;
+		this._clock = options.clock;
+		this._wallClock = options.wallClock ?? defaultWallClock;
+		this._logger = options.logger;
+		this._reportUnhandledError = options.reportUnhandledError ?? reportUnhandledError;
+		this._warn = options.warn;
+		this.createActorRef = options.createActorRef;
+		const ambientInspector = getAmbientInspector();
+		if (ambientInspector) this.inspect(ambientInspector);
+		this._snapshot = {
+			_scheduledTimers: restoredSnapshot?.scheduler ?? emptyScheduledTimers,
+			_nextActorIds: {}
+		};
+	}
+	_recordSent(source, target, event, delay, id) {
+		if (!this._inspectionObservers?.size || !source) return;
+		const inspectionSource = source;
+		(inspectionSource._collectedSent ??= []).push({
+			targetRef: target,
+			targetId: target.id,
+			event,
+			delay,
+			id
+		});
+	}
+	schedule(source, id, delay) {
+		const existingId = createScheduledTimerId(source, id);
+		if (this._timerMap?.[existingId] !== void 0) this.cancel(source, id);
+		const timer = source.getSnapshot()?.timers?.[id];
+		if (timer) {
+			const target = timer.target === "self" ? source : timer.target;
+			this._recordSent(source, target, timer.event, delay, id);
+		}
+		const scheduledAt = this._clock.now?.() ?? this._wallClock.now();
+		const scheduledTimer = {
+			source,
+			delay,
+			id,
+			scheduledAt,
+			dueAt: scheduledAt + delay
+		};
+		const scheduledTimerId = createScheduledTimerId(source, id);
+		if (this._snapshot._scheduledTimers === emptyScheduledTimers) this._snapshot._scheduledTimers = {};
+		this._snapshot._scheduledTimers[scheduledTimerId] = scheduledTimer;
+		markSystemSnapshotDirty(this);
+		const timeout = this._clock.setTimeout(() => {
+			if (this._timerMap) delete this._timerMap[scheduledTimerId];
+			delete this._snapshot._scheduledTimers[scheduledTimerId];
+			markSystemSnapshotDirty(this);
+			this._deliver(source, source, {
+				type: XSTATE_TIMER,
+				id
+			});
+		}, delay);
+		(this._timerMap ??= {})[scheduledTimerId] = timeout;
+	}
+	cancel(source, id) {
+		const scheduledTimerId = createScheduledTimerId(source, id);
+		const timeout = this._timerMap?.[scheduledTimerId];
+		if (this._timerMap) delete this._timerMap[scheduledTimerId];
+		if (this._snapshot._scheduledTimers !== emptyScheduledTimers) delete this._snapshot._scheduledTimers[scheduledTimerId];
+		markSystemSnapshotDirty(this);
+		if (timeout !== void 0) this._clock.clearTimeout(timeout);
+	}
+	cancelAll(actor) {
+		for (const scheduledTimerId in this._snapshot._scheduledTimers) {
+			const scheduledTimer = this._snapshot._scheduledTimers[scheduledTimerId];
+			if (!scheduledTimer) continue;
+			if (scheduledTimer.source === actor) this.cancel(actor, scheduledTimer.id);
+		}
+	}
+	_deliver(source, target, event) {
+		deliverEvent(source, target, event);
+	}
+	_register(sessionId, actor) {
+		if (actor === this._rootActor) this._children?.set(sessionId, actor);
+		else (this._children ??= /* @__PURE__ */ new Map()).set(sessionId, actor);
+		markSystemSnapshotDirty(this);
+		return sessionId;
+	}
+	_unregister(actor) {
+		let changed;
+		if (actor === this._rootActor) {
+			changed = this._getRootActor() !== void 0;
+			changed = actor.sessionId !== void 0 && (this._children?.delete(actor.sessionId) ?? false) || changed;
+		} else changed = actor.sessionId !== void 0 && (this._children?.delete(actor.sessionId) ?? false);
+		const registryKey = this._reverseKeyedActors?.get(actor);
+		if (registryKey !== void 0) {
+			if (this._keyedActors?.get(registryKey) === actor) {
+				this._keyedActors.delete(registryKey);
+				changed = true;
+			}
+			this._reverseKeyedActors?.delete(actor);
+		}
+		if (changed) markSystemSnapshotDirty(this);
+	}
+	get(registryKey) {
+		return this._keyedActors?.get(registryKey);
+	}
+	getAll() {
+		return Object.fromEntries(this._keyedActors?.entries() ?? []);
+	}
+	_set(registryKey, actor) {
+		const existing = this._keyedActors?.get(registryKey);
+		if (existing && existing !== actor) throw new Error(`Actor with registry key '${registryKey}' already exists.`);
+		(this._keyedActors ??= /* @__PURE__ */ new Map()).set(registryKey, actor);
+		(this._reverseKeyedActors ??= /* @__PURE__ */ new WeakMap()).set(actor, registryKey);
+		if (existing !== actor) markSystemSnapshotDirty(this);
+	}
+	inspect(observerOrFn) {
+		const observer = toObserver(observerOrFn);
+		(this._inspectionObservers ??= /* @__PURE__ */ new Set()).add(observer);
+		return { unsubscribe: () => {
+			this._inspectionObservers?.delete(observer);
+		} };
+	}
+	onRejectedEvent(listener) {
+		const entry = (rejection) => listener(rejection);
+		(this._rejectionListeners ??= /* @__PURE__ */ new Set()).add(entry);
+		return { unsubscribe: () => {
+			this._rejectionListeners?.delete(entry);
+		} };
+	}
+	_hasInspectionObservers() {
+		return !!this._inspectionObservers?.size;
+	}
+	_sendInspectionEvent(event) {
+		if (!this._inspectionObservers?.size) return;
+		const resolvedInspectionEvent = {
+			...event,
+			rootId: this._rootActor.sessionId
+		};
+		this._inspectionObservers.forEach((observer) => observer.next?.(resolvedInspectionEvent));
+	}
+	spawnActor(source, actor) {
+		return this.runtime?.spawnActor?.(source, actor);
+	}
+	startActor(actor) {
+		const override = this.runtime?.startActor;
+		if (override) return override(actor);
+		actor.start();
+	}
+	stopActor(actor) {
+		const override = this.runtime?.stopActor;
+		if (override) return override(actor);
+		stopActor(actor);
+	}
+	terminateActor(actor, termination) {
+		const override = this.runtime?.terminateActor;
+		if (override) return override(actor, termination);
+		terminateActor(actor, termination);
+	}
+	sendEvent(source, target, event) {
+		if (rejectUndeliverableEvent(source, target, event)) return;
+		this._recordSent(source, target, event);
+		const override = this.runtime?.sendEvent;
+		if (override) return override(source, target, event);
+		this._deliver(source, target, event);
+	}
+	emitEvent(source, event) {
+		const override = this.runtime?.emitEvent;
+		if (override) return override(source, event);
+		source._emit(event);
+	}
+	deadLetter(source, target, event, reason, detail) {
+		const listeners = this._rejectionListeners;
+		if (listeners?.size) {
+			const rejection = {
+				event,
+				targetRef: target,
+				targetId: target?.id ?? detail?.targetId,
+				sourceRef: source,
+				eventOrigin: source ? "actor" : "external",
+				reason,
+				issues: detail?.issues,
+				error: detail?.error
+			};
+			for (const listener of [...listeners]) try {
+				listener(rejection);
+			} catch (err) {
+				this._reportUnhandledError(err);
+			}
+		}
+		const override = this.runtime?.deadLetter;
+		if (override) return override(source, target, event, reason, detail);
+	}
+	runStep(actor, key, exec) {
+		const override = this.runtime?.runStep;
+		if (override) return override(actor, key, exec);
+		return runStep(actor, key, exec);
+	}
+	runLogic(actor, exec) {
+		const override = this.runtime?.runLogic;
+		if (override) return override(actor, exec);
+		return exec();
+	}
+	scheduleTimer(source, id, delay) {
+		const override = this.runtime?.scheduleTimer;
+		if (override) {
+			const timer = source.getSnapshot()?.timers?.[id];
+			if (timer) {
+				const target = timer.target === "self" ? source : timer.target;
+				this._recordSent(source, target, timer.event, delay, id);
+			}
+			return override(source, id, delay);
+		}
+		this.schedule(source, id, delay);
+	}
+	cancelTimer(source, id) {
+		const override = this.runtime?.cancelTimer;
+		if (override) return override(source, id);
+		this.cancel(source, id);
+	}
+	cancelAllTimers(source) {
+		const override = this.runtime?.cancelAllTimers;
+		if (override) return override(source);
+		this.cancelAll(source);
+	}
+	_relay(source, target, event) {
+		if (transitionEffectTargets.length && transitionEffectTargets.includes(target)) throw transitionEffectSignal;
+		return this.sendEvent(source, target, event);
+	}
+	getSnapshot() {
+		return { _scheduledTimers: { ...this._snapshot._scheduledTimers } };
+	}
+	start() {
+		const scheduledTimers = this._snapshot._scheduledTimers;
+		let resetScheduledTimers = true;
+		for (const scheduledId in scheduledTimers) {
+			if (resetScheduledTimers) {
+				this._snapshot._scheduledTimers = {};
+				resetScheduledTimers = false;
+			}
+			const scheduledTimer = scheduledTimers[scheduledId];
+			if (!scheduledTimer) continue;
+			const { source, dueAt, id } = scheduledTimer;
+			this.scheduleTimer(source, id, Math.max(0, dueAt - (this._clock.now?.() ?? this._wallClock.now())));
+		}
+	}
+};
+/** @internal */
+function createRuntimeSystem(rootActor, options) {
+	return new RuntimeSystem(rootActor, options);
+}
+// src/memo.ts
+const cache = /* @__PURE__ */ new WeakMap();
+function memo(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];
+}
+// src/actions.ts
+function assertSendToEvent(event) {
+	if (typeof event === "string") throw new Error(`Only event objects may be used with sendTo`);
+}
+const builtInActions = {
+	["@xstate.spawn"]: (actor) => {
+		return actor.system.spawnActor(actor._parent, actor);
+	},
+	["@xstate.start"]: (actor) => {
+		return actor.system.startActor(actor);
+	},
+	["@xstate.raise"]: (actorScope, _event, options) => {
+		return actorScope.system.scheduleTimer(actorScope.self, options.id, options?.delay ?? 0);
+	},
+	["@xstate.sendTo"]: (actorScope, actor, event, options) => {
+		assertSendToEvent(event);
+		if (options?.delay !== void 0) return actorScope.system.scheduleTimer(actorScope.self, options.id, options?.delay ?? 0);
+		else return actorScope.system._relay(actorScope.self, actor, event);
+	},
+	["@xstate.cancel"]: (actorScope, sendId) => {
+		return actorScope.system.cancelTimer(actorScope.self, sendId);
+	},
+	["@xstate.stop"]: (actorScope, actor) => {
+		return actorScope.system.stopActor(actor);
+	},
+	["@xstate.terminate"]: (actor, termination) => {
+		return actor.system.terminateActor(actor, termination);
+	}
+};
+// src/actorScope.ts
+/** Marks the internal lazy scope without imposing structure on custom runtimes. @internal */
+const lazyActorScope = Symbol();
+/** Whether actor capabilities are represented by a lazy pure-transition scope. @internal */
+function isLazyActorScope(actorScope) {
+	return !!actorScope[lazyActorScope];
+}
+/** Reads parent metadata without otherwise touching actor capabilities. @internal */
+function getActorScopeParent(actorScope) {
+	return isLazyActorScope(actorScope) ? actorScope._parent : actorScope.self._parent;
+}
+/** Adds only `self`, preserving callback surfaces that expose no other capabilities. @internal */
+function withActorSelf(args, actorScope) {
+	if (!isLazyActorScope(actorScope)) return Object.assign(args, { self: actorScope.self });
+	Object.defineProperty(args, "self", {
+		enumerable: true,
+		get: () => actorScope.self
+	});
+	return args;
+}
+/** Adds the actor reference and parent without exposing the system. @internal */
+function withActorSelfAndParent(args, actorScope) {
+	if (!isLazyActorScope(actorScope)) {
+		const self = actorScope.self;
+		return Object.assign(args, {
+			self,
+			parent: self._parent
+		});
+	}
+	Object.defineProperties(args, {
+		self: {
+			enumerable: true,
+			get: () => actorScope.self
+		},
+		parent: {
+			enumerable: true,
+			get: () => getActorScopeParent(actorScope)
+		}
+	});
+	return args;
+}
+/** Adds actor capabilities without reading them until the callback does. @internal */
+function withActorScope(args, actorScope) {
+	if (!isLazyActorScope(actorScope)) {
+		const actorArgs = args;
+		const self = actorScope.self;
+		actorArgs.self = self;
+		actorArgs.system = actorScope.system;
+		actorArgs.parent = self._parent;
+		return actorArgs;
+	}
+	Object.defineProperties(args, {
+		self: {
+			enumerable: true,
+			get: () => actorScope.self
+		},
+		system: {
+			enumerable: true,
+			get: () => actorScope.system
+		},
+		parent: {
+			enumerable: true,
+			get: () => getActorScopeParent(actorScope)
+		}
+	});
+	return args;
+}
+// src/delay.ts
+function parseDurationToMilliseconds(duration) {
+	const normalizedDuration = duration.trim();
+	const millisecondsMatch = normalizedDuration.match(/^(\d+)ms$/i);
+	if (millisecondsMatch) return parseInt(millisecondsMatch[1] ?? "", 10);
+	const secondsMatch = normalizedDuration.match(/^(\d*)(\.?)(\d*)s$/i);
+	if (secondsMatch) {
+		const wholePart = secondsMatch[1] ? parseInt(secondsMatch[1], 10) : 0;
+		const hasDecimal = !!secondsMatch[2];
+		const fracPart = secondsMatch[3] ? parseInt(secondsMatch[3].padEnd(3, "0").slice(0, 3), 10) : 0;
+		return wholePart * 1e3 + (hasDecimal ? fracPart : 0);
+	}
+	const iso8601DurationMatch = normalizedDuration.match(/^P(?:(?<weeks>\d+(?:[.,]\d+)?)W)?(?:(?<days>\d+(?:[.,]\d+)?)D)?(?:T(?:(?<hours>\d+(?:[.,]\d+)?)H)?(?:(?<minutes>\d+(?:[.,]\d+)?)M)?(?:(?<seconds>\d+(?:[.,]\d+)?)S)?)?$/i);
+	if (!iso8601DurationMatch?.groups) return;
+	const { weeks, days, hours, minutes, seconds } = iso8601DurationMatch.groups;
+	if (!weeks && !days && !hours && !minutes && !seconds) return;
+	const toNumber = (value) => value ? Number(value.replace(",", ".")) : 0;
+	return toNumber(weeks) * 7 * 24 * 60 * 60 * 1e3 + toNumber(days) * 24 * 60 * 60 * 1e3 + toNumber(hours) * 60 * 60 * 1e3 + toNumber(minutes) * 60 * 1e3 + toNumber(seconds) * 1e3;
+}
+/**
+* Converts a delay (milliseconds or an ISO 8601 duration string) to
+* milliseconds. Exported for `@xstate/scxml`; not part of the stable API.
+*
+* @experimental
+*/
+function parseDelayToMilliseconds(delay) {
+	if (delay === void 0) return;
+	if (typeof delay === "number") return delay;
+	return parseDurationToMilliseconds(delay);
+}
+// src/stateNodePredicates.ts
+const IS_ATOMIC_TYPE = {
+	atomic: true,
+	choice: true,
+	compound: false,
+	final: true,
+	history: false,
+	parallel: false
+};
+function isAtomicStateNode(stateNode) {
+	return IS_ATOMIC_TYPE[stateNode.type];
+}
+const isOrHasAncestor = (stateNode, ancestor) => stateNode === ancestor || hasAncestor(stateNode.parent, ancestor);
+const hasAncestor = (stateNode, ancestor) => stateNode === void 0 ? false : isOrHasAncestor(stateNode, ancestor);
+function isDescendant(args) {
+	return hasAncestor(args.childStateNode.parent, args.parentStateNode);
+}
+// src/historyRecall.ts
+function isHistoryNode(stateNode) {
+	return stateNode.type === "history";
+}
+const defaultHistoryTransition = (source, target) => ({
+	target,
+	source,
+	reenter: false,
+	eventType: ""
+});
+function recallHistory(args) {
+	const recorded = args.historyValue[args.historyNode.id];
+	return recorded === void 0 ? {
+		type: "default",
+		transition: defaultHistoryTransition(args.historyNode, args.defaultTargets())
+	} : {
+		type: "recorded",
+		nodes: recorded
+	};
+}
+function recordHistoryNodes(args) {
+	const { historyNode, exitingNode, currentStateNodes } = args;
+	if (historyNode.history === "deep") return currentStateNodes.filter((stateNode) => isAtomicStateNode(stateNode) && isDescendant({
+		childStateNode: stateNode,
+		parentStateNode: exitingNode
+	}));
+	return currentStateNodes.filter((stateNode) => stateNode.parent === exitingNode);
+}
+function restoresSourceViaHistory(args) {
+	return args.targets.some(isHistoryNode) ? args.effectiveTargetStates.some((stateNode) => stateNode === args.source) : false;
+}
+// src/remoteActorRef.ts
+const emptySubscription = { unsubscribe() {} };
+const restoreHint = "or restore this snapshot with embedded children on the runtime that owns them.";
+/** @internal */
+function isRemoteActorRef(actorRef) {
+	return actorRef._remote === true;
+}
+/**
+* The lifecycle-only snapshot a remote handle exposes. `active` is accurate
+* by construction: a completion removes the child from its parent's
+* `children`, so a handle only exists while the child is presumed active,
+* and the terminal result arrives as a completion event instead of a
+* snapshot. Full snapshots are a co-location capability.
+*/
+const remoteSnapshot = Object.freeze({
+	status: "active",
+	output: void 0,
+	error: void 0
+});
+/**
+* Creates a location-transparent handle to an actor whose state lives with
+* another runtime. The handle is constructed from identity alone — no lookup
+* — and every send routes through the system's runtime; its state is not
+* synchronously readable.
+*
+* The surface is deliberately minimal: it covers every member the runtime
+* reaches for a restored child (send/_send, lifecycle via start/_stop and
+* system.stopActor, persistence, subscribe/on as inert subscriptions).
+* Members that only make sense for a co-located actor (public stop(),
+* select(), trigger) throw a descriptive error rather than being absent, so
+* calling one reports what went wrong instead of a bare TypeError. Observable
+* interop and _processingStatus are omitted entirely.
+*
+* @internal
+*/
+function createRemoteActorRef(system, options) {
+	const handle = {
+		_remote: true,
+		ref: void 0,
+		id: options.id,
+		address: options.address,
+		src: options.src,
+		registryKey: options.registryKey,
+		sessionId: options.incarnation,
+		system,
+		_parent: options.parent,
+		_syncSnapshot: options.syncSnapshot,
+		send(event) {
+			system.sendEvent(void 0, ref, event);
+		},
+		_send(event) {
+			throw new Error(`Remote actor '${options.address}' has no local mailbox to receive "${event.type}". Its state lives with another runtime; install a runtime that can reach it (via \`createDurable\`'s adapter runtime operations, or \`system.runtime\`) before sending, ${restoreHint}`);
+		},
+		getSnapshot() {
+			return remoteSnapshot;
+		},
+		getPersistedSnapshot() {
+			throw new Error(`Cannot persist remote actor '${options.address}' from here: its state lives with the runtime that owns it. Persist it there, ${restoreHint}`);
+		},
+		start() {},
+		_stop() {},
+		stop() {
+			throw new Error(`Cannot stop remote actor '${options.address}' directly: stopping is a co-located operation. Stop it through the system runtime that owns it (\`system.stopActor(ref)\`), ${restoreHint}`);
+		},
+		select() {
+			throw new Error(`Cannot select from remote actor '${options.address}': its snapshot is not synchronously readable because its state lives with another runtime. Read it on the runtime that owns it, ${restoreHint}`);
+		},
+		get trigger() {
+			throw new Error(`Remote actor '${options.address}' has no \`trigger\` shorthand: it requires a co-located actor. Use \`send(...)\`, which routes through the system runtime.`);
+		},
+		subscribe() {
+			return emptySubscription;
+		},
+		on() {
+			return emptySubscription;
+		},
+		_isRunning() {
+			return false;
+		},
+		toJSON() {
+			return {
+				xstate$type: ACTOR_REF_TYPE,
+				id: options.id,
+				address: options.address,
+				src: options.src
+			};
+		}
+	};
+	const ref = handle;
+	handle.ref = ref;
+	return ref;
+}
+// src/stateMatching.ts
+const dotAndSegment = /\.(?:\\[\s\S]|[^.\\])*\\?/g;
+const escapedCharacter = /\\([\s\S])/g;
+const toStatePath = (stateId) => typeof stateId === "string" ? Array.from(`.${stateId}`.matchAll(dotAndSegment), ([dotted]) => dotted.slice(1).replace(escapedCharacter, "$1")) : [...stateId];
+/** @public */
+const pathToStateValue = (statePath) => {
+	const leaf = statePath.at(-1);
+	return leaf === void 0 ? {} : statePath.slice(0, -1).reduceRight((value, key) => ({ [key]: value }), leaf);
+};
+const toStateValue = (stateValue) => typeof stateValue === "string" ? pathToStateValue(toStatePath(stateValue)) : stateValue;
+const presentRegionMatches = (parentRegion, childRegion) => parentRegion !== void 0 && regionsMatch(parentRegion, childRegion);
+const regionMatches = (parentRegion, childRegion) => childRegion !== void 0 && presentRegionMatches(parentRegion, childRegion);
+const matchesRegions = (parent, child) => typeof parent === "string" ? parent in child : Object.keys(parent).every((key) => regionMatches(parent[key], child[key]));
+function regionsMatch(parent, child) {
+	return typeof child === "string" ? parent === child : matchesRegions(parent, child);
+}
+const valueMatches = (parentStateValue, childStateValue) => regionsMatch(toStateValue(parentStateValue), toStateValue(childStateValue));
+function matchesState(...args) {
+	if (args.length === 1) {
+		const [childStateValue] = args;
+		return (parentStateValue) => valueMatches(parentStateValue, childStateValue);
+	}
+	return valueMatches(args[0], args[1]);
+}
+// src/timerClock.ts
+const starts = /* @__PURE__ */ new WeakMap();
+/** @internal */
+function getTimerStart(timer) {
+	return starts.get(timer) ?? timer.startedAt;
+}
+/** @internal */
+function recordTimerStart(timer, startedAt) {
+	starts.set(timer, startedAt);
+}
+// src/State.ts
+const emptySnapshotRecord = Object.freeze({});
+function compactSnapshotRecord(value) {
+	if (value === emptySnapshotRecord) return value;
+	return value && Object.keys(value).length ? value : emptySnapshotRecord;
+}
+/** @public */
+function isMachineSnapshot(value) {
+	return !!value && typeof value === "object" && "machine" in value && "value" in value;
+}
+const machineSnapshotMatches = function matches(testValue) {
+	return matchesState(testValue, this.value);
+};
+const machineSnapshotHasTag = function hasTag(tag) {
+	return this.tags.has(tag);
+};
+const machineSnapshotCan = function can(event) {
+	return this.machine?._canTransition(this, event) ?? false;
+};
+const machineSnapshotToJSON = function toJSON() {
+	const { nodes, _stateInputs, tags, machine, getMeta, getInputs, toJSON, can, hasTag, matches, ...jsonValues } = this;
+	return {
+		...jsonValues,
+		tags: Array.from(tags)
+	};
+};
+const machineSnapshotGetMeta = function getMeta() {
+	const meta = {};
+	for (const stateNode of this.nodes) if (stateNode.meta !== void 0) meta[stateNode.id] = stateNode.meta;
+	return meta;
+};
+const machineSnapshotGetInputs = function getInputs() {
+	return this._stateInputs;
+};
+function collectTags(stateNodes) {
+	const tags = /* @__PURE__ */ new Set();
+	for (const stateNode of stateNodes) for (const tag of stateNode.tags) tags.add(tag);
+	return tags;
+}
+function createMachineSnapshot(config, machine, actorRef) {
+	const snapshot = {
+		status: config.status,
+		output: config.output,
+		error: config.error,
+		machine,
+		context: config.context,
+		nodes: config._nodes,
+		value: config.value ?? getStateValue(machine.root, config._nodes),
+		tags: collectTags(config._nodes),
+		children: compactSnapshotRecord(config.children),
+		timers: compactSnapshotRecord(config.timers),
+		historyValue: compactSnapshotRecord(config.historyValue),
+		_stateInputs: compactSnapshotRecord(config._stateInputs),
+		_nextTimerId: config._nextTimerId ?? 0,
+		_nextActorIds: config._nextActorIds,
+		matches: machineSnapshotMatches,
+		hasTag: machineSnapshotHasTag,
+		can: machineSnapshotCan,
+		getMeta: machineSnapshotGetMeta,
+		getInputs: machineSnapshotGetInputs,
+		toJSON: machineSnapshotToJSON
+	};
+	if (actorRef) setSnapshotActorRef(snapshot, actorRef);
+	return snapshot;
+}
+function cloneMachineSnapshot(snapshot, config = {}) {
+	const configWithSnapshot = {
+		...snapshot,
+		...config
+	};
+	if ((config._nodes ?? snapshot.nodes) === snapshot.nodes) {
+		const clonedSnapshot = {
+			status: configWithSnapshot.status,
+			output: configWithSnapshot.output,
+			error: configWithSnapshot.error,
+			machine: snapshot.machine,
+			context: configWithSnapshot.context,
+			nodes: snapshot.nodes,
+			value: snapshot.value,
+			tags: snapshot.tags,
+			children: compactSnapshotRecord(configWithSnapshot.children),
+			timers: compactSnapshotRecord(configWithSnapshot.timers),
+			historyValue: compactSnapshotRecord(configWithSnapshot.historyValue),
+			_stateInputs: compactSnapshotRecord(configWithSnapshot._stateInputs),
+			_nextTimerId: configWithSnapshot._nextTimerId ?? 0,
+			_nextActorIds: configWithSnapshot._nextActorIds,
+			matches: machineSnapshotMatches,
+			hasTag: machineSnapshotHasTag,
+			can: machineSnapshotCan,
+			getMeta: machineSnapshotGetMeta,
+			getInputs: machineSnapshotGetInputs,
+			toJSON: machineSnapshotToJSON
+		};
+		copySnapshotActorRef(snapshot, clonedSnapshot);
+		return clonedSnapshot;
+	}
+	const clonedSnapshot = createMachineSnapshot({
+		...configWithSnapshot,
+		value: void 0
+	}, snapshot.machine);
+	copySnapshotActorRef(snapshot, clonedSnapshot);
+	return clonedSnapshot;
+}
+function serializeHistoryValue(historyValue) {
+	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, warn = defaultWarn) {
+	const { nodes, _stateInputs, tags, machine, children, timers, context, can, hasTag, matches, getMeta, getInputs, toJSON, ...jsonValues } = snapshot;
+	const childrenJson = {};
+	const timersJson = {};
+	const embedChildren = options?.embedChildren !== false;
+	for (const id in children) {
+		const child = children[id];
+		if (typeof child.src !== "string" && (!options || !("__unsafeAllowInlineActors" in options))) throw new Error("An inline child actor cannot be persisted.");
+		const embed = embedChildren && !isRemoteActorRef(child);
+		if (!embed && typeof child.src !== "string") throw new Error(`Unable to persist child '${id}' by address: it requires a registered source key.`);
+		childrenJson[id] = {
+			address: child.address,
+			...embed ? { snapshot: child.getPersistedSnapshot(options) } : {
+				remote: true,
+				incarnation: isRemoteActorRef(child) ? child.sessionId : void 0
+			},
+			src: child.src,
+			registryKey: child.registryKey,
+			syncSnapshot: child._syncSnapshot
+		};
+	}
+	const snapshotActor = getSnapshotActorRef(snapshot)?.actor;
+	const scheduledTimers = snapshotActor?.system?._clock?.now ? void 0 : snapshotActor?.system?._snapshot?._scheduledTimers;
+	for (const [id, timer] of Object.entries(timers)) {
+		let event = timer.event;
+		if (event.type === "xstate.timeout.actor") {
+			event = { ...event };
+			delete event.sessionId;
+		}
+		let target;
+		if (timer.target === "self") target = "self";
+		else {
+			const childId = Object.entries(children).find(([, child]) => child === timer.target)?.[0];
+			if (childId) target = childId;
+			else if (timer.target === getSnapshotActorRef(snapshot)?.actor._parent) target = { type: "parent" };
+			else throw new Error(`Unable to persist timer '${id}': target actor '${timer.target.id}' is no longer addressable from this snapshot.`);
+		}
+		const scheduled = scheduledTimers?.[`${snapshotActor.sessionId}.${id}`];
+		const startedAt = scheduled ? scheduled.dueAt - timer.delay : getTimerStart(timer);
+		timersJson[id] = {
+			id: timer.id,
+			delay: timer.delay,
+			type: timer.type,
+			event,
+			target,
+			...startedAt !== void 0 && { startedAt }
+		};
+	}
+	const persisted = {
+		...jsonValues,
+		context: persistContext(context, () => getSnapshotActorRef(snapshot)?.actor.id ?? machine.id),
+		children: childrenJson,
+		timers: timersJson,
+		historyValue: serializeHistoryValue(jsonValues.historyValue)
+	};
+	if (_stateInputs && Object.keys(_stateInputs).length > 0) persisted["stateInputs"] = _stateInputs;
+	if (machine.version !== void 0) {
+		persisted["machine"] = {
+			id: machine.id,
+			version: machine.version
+		};
+		persisted["version"] = machine.version;
+	}
+	return persisted;
+}
+function persistContext(contextPart, getActorId, path = "context", ancestors = []) {
+	ancestors.push(contextPart);
+	let copy;
+	for (const key in contextPart) {
+		const value = contextPart[key];
+		if (value && typeof value === "object") {
+			if (isActorRefLike(value)) {
+				copy ??= Array.isArray(contextPart) ? contextPart.slice() : { ...contextPart };
+				copy[key] = {
+					xstate$type: ACTOR_REF_TYPE,
+					id: value.id
+				};
+			} else {
+				const valuePath = Array.isArray(contextPart) ? `${path}[${key}]` : `${path}.${key}`;
+				if (ancestors.includes(value)) throw new Error(`Cannot persist actor "${getActorId()}": circular reference at ${valuePath}`);
+				const result = persistContext(value, getActorId, valuePath, ancestors);
+				if (result !== value) {
+					copy ??= Array.isArray(contextPart) ? contextPart.slice() : { ...contextPart };
+					copy[key] = result;
+				}
+			}
+		}
+	}
+	ancestors.pop();
+	return copy ?? contextPart;
+}
+// src/inertActorScope.ts
+/** @internal */
+function setInertActorScopeSnapshot(actorScope, snapshot, attachActorRef = true) {
+	const lazyState = getLazyInertActorState(actorScope);
+	if (lazyState) {
+		lazyState.snapshot = snapshot;
+		if (lazyState.materialized) lazyState.materialized.self._snapshot = snapshot;
+	} else actorScope.self._snapshot = snapshot;
+	if (attachActorRef && snapshot && typeof snapshot === "object") setSnapshotActorRef(snapshot, actorScope.self);
+	return snapshot;
+}
+/** @internal */
+function isInertActorScope(actorScope) {
+	return !!getLazyInertActorState(actorScope) || !!actorScope.self.options?._inert;
+}
+/** @internal */
+function attachSnapshotActorRef(actorScope, snapshot) {
+	setInertActorScopeSnapshot(actorScope, snapshot, false);
+	const lazyState = getLazyInertActorState(actorScope);
+	snapshotActorScopes.set(snapshot, actorScope);
+	const create = () => {
+		setSnapshotActorRef(snapshot, actorScope.self, actorScope.system);
+		return getSnapshotActorRef(snapshot);
+	};
+	if (lazyState) {
+		if (lazyState.materialized) lazyState.identityProvider = create;
+		else lazyState.identityProvider ??= create;
+	}
+	setLazySnapshotActorRef(snapshot, create);
+	return snapshot;
+}
+const lazyInertActorState = Symbol();
+const snapshotActorScopes = /* @__PURE__ */ new WeakMap();
+function getLazyInertActorState(actorScope) {
+	return actorScope[lazyInertActorState];
+}
+function materializeInertActorScope(actorScope) {
+	return getLazyInertActorState(actorScope).materialize();
+}
+const lazyInertActorScopePrototype = {
+	[lazyActorScope]: true,
+	get _parent() {
+		const actorScope = this;
+		const state = getLazyInertActorState(actorScope);
+		return state.parentKnown ? state.parent : materializeInertActorScope(actorScope).self._parent;
+	},
+	get self() {
+		return materializeInertActorScope(this).self;
+	},
+	get defer() {
+		return materializeInertActorScope(this).defer;
+	},
+	get id() {
+		return materializeInertActorScope(this).id;
+	},
+	get logger() {
+		return materializeInertActorScope(this).logger;
+	},
+	get warn() {
+		return materializeInertActorScope(this).warn;
+	},
+	get sessionId() {
+		return materializeInertActorScope(this).sessionId;
+	},
+	get stopChild() {
+		return materializeInertActorScope(this).stopChild;
+	},
+	get system() {
+		return materializeInertActorScope(this).system;
+	},
+	get emit() {
+		return materializeInertActorScope(this).emit;
+	},
+	get actionExecutor() {
+		return materializeInertActorScope(this).actionExecutor;
+	}
+};
+function createMaterializedInertActorScope(actorLogic, sourceRef, sourceChildren, currentSnapshot, sourceSelf) {
+	const snapshotRef = sourceRef?.();
+	const previousSelf = sourceSelf ?? snapshotRef?.actor;
+	const baseSystem = previousSelf?.system;
+	const system = previousSelf && baseSystem ? createSnapshotSystem(baseSystem, sourceChildren, sourceSelf ? void 0 : snapshotRef?.systemState) : void 0;
+	const self = createActor(actorLogic, {
+		_inert: true,
+		...previousSelf ? {
+			id: previousSelf.id,
+			_sessionId: previousSelf.sessionId
+		} : {},
+		...system ? { _systemRef: { current: system } } : {}
+	});
+	if (previousSelf?._parent) {
+		self._parent = previousSelf._parent;
+		self._address = void 0;
+	}
+	if (currentSnapshot) self._snapshot = currentSnapshot;
+	return Object.create(self._actorScope, {
+		defer: { value: () => {} },
+		stopChild: { value: (child) => child._stop() },
+		actionExecutor: { value: () => {} }
+	});
+}
+/** @internal */
+function createInertActorScope(actorLogic, snapshot, sourceSelf, sourceActorScope) {
+	const sourceScope = sourceActorScope ?? (snapshot && typeof snapshot === "object" ? snapshotActorScopes.get(snapshot) : void 0);
+	const sourceState = sourceScope ? getLazyInertActorState(sourceScope) : void 0;
+	const eagerSourceRef = snapshot && typeof snapshot === "object" ? peekSnapshotActorRef(snapshot) : void 0;
+	const sourceRef = sourceState?.identityProvider ?? (snapshot && typeof snapshot === "object" ? getSnapshotActorRefProvider(snapshot) : void 0);
+	const state = {
+		snapshot,
+		sourceRef,
+		sourceChildren: isMachineSnapshot(snapshot) ? snapshot.children : {},
+		identityProvider: sourceState?.identityProvider ?? sourceRef,
+		parent: sourceSelf?._parent ?? sourceState?.parent ?? eagerSourceRef?.actor._parent,
+		parentKnown: !!sourceSelf || !!sourceState?.parentKnown || !!eagerSourceRef || !snapshot
+	};
+	state.materialize = () => state.materialized ??= createMaterializedInertActorScope(actorLogic, state.sourceRef, state.sourceChildren, state.snapshot, sourceSelf);
+	if (!state.identityProvider && !snapshot) {
+		const identitySnapshot = {};
+		const identitySourceRef = state.sourceRef;
+		const identitySourceChildren = state.sourceChildren;
+		let identityScope;
+		let identityRef;
+		const getIdentityScope = () => identityScope ??= createMaterializedInertActorScope(actorLogic, identitySourceRef, identitySourceChildren, void 0, sourceSelf);
+		state.materialize = () => {
+			const scope = getIdentityScope();
+			if (state.snapshot !== void 0) scope.self._snapshot = state.snapshot;
+			return state.materialized = scope;
+		};
+		state.identityProvider = () => {
+			if (identityRef) return identityRef;
+			const scope = getIdentityScope();
+			setSnapshotActorRef(identitySnapshot, scope.self, scope.system);
+			return identityRef = getSnapshotActorRef(identitySnapshot);
+		};
+	}
+	const actorScope = Object.create(lazyInertActorScopePrototype);
+	actorScope[lazyInertActorState] = state;
+	return actorScope;
+}
+// src/systemLogicMetadata.ts
+/** Static scheduling metadata on actor definitions, never on live actors. @internal */
+const systemLogicMetadata = Symbol("xstate.systemLogicMetadata");
+// src/actors/attached.ts
+const subscriptions = /* #__PURE__ */ new WeakMap();
+/**
+* Internal factory for actor logic that attaches to another actor on start
+* (`enq.listen()` / `enq.subscribeTo()`) and detaches when stopped.
+*/
+function createAttachedLogic(attach, id) {
+	const initialTransition = (input, _) => [{
+		status: "active",
+		output: void 0,
+		error: void 0,
+		input
+	}, []];
+	const logic = {
+		id,
+		start: (state, { self, system }) => {
+			const target = state.input.actor;
+			if (!target || target.getSnapshot().status === "stopped") return;
+			const subscription = attach(state.input, {
+				self,
+				system
+			});
+			if (!subscription) return;
+			let parentSubscription;
+			let torndown = false;
+			const teardown = () => {
+				if (torndown) return;
+				torndown = true;
+				subscription.unsubscribe();
+				parentSubscription?.unsubscribe();
+			};
+			const parent = self._parent;
+			if (parent) parentSubscription = parent.subscribe({
+				complete: teardown,
+				error: teardown
+			});
+			subscriptions.set(self, { unsubscribe: teardown });
+		},
+		transition: (state, event, { self }) => {
+			if (event.type === "@xstate.stop") {
+				subscriptions.get(self)?.unsubscribe();
+				subscriptions.delete(self);
+				return [{
+					...state,
+					status: "stopped",
+					error: void 0
+				}, []];
+			}
+			return [state, []];
+		},
+		initialTransition,
+		getInitialSnapshot: (actorScope, input) => initialTransition(input, actorScope)[0],
+		getPersistedSnapshot: (snapshot) => snapshot,
+		restoreSnapshot: (snapshot) => snapshot
+	};
+	Object.defineProperty(logic, systemLogicMetadata, { value: { kind: id } });
+	return logic;
+}
+/**
+* Relays a mapped event to the attached actor's parent, unless the attached
+* actor has been stopped (the mapper is not called in that case).
+*/
+function relayMappedToParent(self, system, getEvent) {
+	if (self.getSnapshot().status === "stopped" || !self._parent) return;
+	system._relay(self, self._parent, getEvent());
+}
+// src/actors/listener.ts
+/**
+* Creates actor logic for listening to emitted events from another actor. Used
+* internally by `enq.listen()`.
+*
+* @public
+*/
+function createListenerLogic() {
+	return createAttachedLogic(({ actor, eventType, mapper }, { self, system }) => {
+		const isPartialWildcard = eventType !== "*" && eventType.endsWith(".*");
+		return actor.on(isPartialWildcard ? "*" : eventType, (emittedEvent) => {
+			if (isPartialWildcard && !matchesEventDescriptor(emittedEvent.type, eventType, system._warn)) return;
+			relayMappedToParent(self, system, () => mapper(emittedEvent));
+		});
+	}, "xstate.listener");
+}
+/** @public */
+const listenerLogic = /* #__PURE__ */ createListenerLogic();
+// src/actors/subscription.ts
+/**
+* Creates actor logic for subscribing to lifecycle events (done/error/snapshot)
+* from another actor. Used internally by `enq.subscribeTo()`.
+*
+* @public
+*/
+function createSubscriptionLogic() {
+	return createAttachedLogic(({ actor, mappers }, { self, system }) => {
+		const { done, error, snapshot: onSnapshot } = mappers;
+		return actor.subscribe({
+			next: (snapshot) => {
+				if (snapshot.status === "done" && done) relayMappedToParent(self, system, () => done(snapshot.output));
+				else if (snapshot.status === "error" && error) relayMappedToParent(self, system, () => error(snapshot.error));
+				else if (snapshot.status === "active" && onSnapshot) relayMappedToParent(self, system, () => onSnapshot(snapshot));
+			},
+			error: (err) => {
+				if (error) relayMappedToParent(self, system, () => error(err));
+			},
+			complete: () => {}
+		});
+	}, "xstate.subscription");
+}
+/** @public */
+const subscriptionLogic = /* #__PURE__ */ createSubscriptionLogic();
+// src/actorSource.ts
+const sourceKeyCaches = /* @__PURE__ */ new WeakMap();
+/** @internal */
+function resolveRegisteredActorSource(actors, logic) {
+	let cache = sourceKeyCaches.get(actors);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		for (const [key, registeredLogic] of Object.entries(actors)) if (!cache.has(registeredLogic)) cache.set(registeredLogic, key);
+		sourceKeyCaches.set(actors, cache);
+	}
+	return cache.get(logic);
+}
+// src/transitionActions.ts
+function execCustomEffect() {
+	return this.action?.(...this.args);
+}
+function execEmitEffect(runtime = this.source.system) {
+	return runtime.emitEvent(this.source, this.event);
+}
+/** @internal Creates an emitted-event effect. */
+function createEmitEffect(actorScope, event) {
+	return {
+		kind: "emit",
+		exec: execEmitEffect,
+		type: event.type,
+		source: actorScope.self,
+		event,
+		params: void 0,
+		args: []
+	};
+}
+function execDeadLetterEffect(runtime = (this.target ?? this.source).system) {
+	return runtime.deadLetter(this.source, this.target, this.event, this.reason, this.detail);
+}
+/** @internal Creates a dead-letter effect for a boundary-rejected event. */
+function createDeadLetterEffect(actorScope, source, event, reason, detail) {
+	return {
+		kind: "builtin",
+		type: "@xstate.deadLetter",
+		exec: execDeadLetterEffect,
+		source,
+		target: actorScope.self,
+		event,
+		reason,
+		detail,
+		params: void 0,
+		args: []
+	};
+}
+/**
+* @internal Creates a dead-letter effect for an `enq.sendTo` whose target is
+* an undefined ref, an unknown child id, or the parent of a root actor.
+*/
+function createMissingTargetEffect(actorScope, event, targetId) {
+	return {
+		kind: "builtin",
+		type: "@xstate.deadLetter",
+		exec: execDeadLetterEffect,
+		source: actorScope.self,
+		target: void 0,
+		event,
+		reason: "missingTarget",
+		detail: {
+			targetId,
+			error: /* @__PURE__ */ new Error(targetId !== void 0 ? `Unable to send event to unknown child '${targetId}'` : "Unable to send event to an undefined actor")
+		},
+		params: void 0,
+		args: []
+	};
+}
+/** @internal Creates a directly executable user effect. */
+function createCustomEffect(type, action, params) {
+	return {
+		kind: "action",
+		exec: action,
+		type,
+		action,
+		params,
+		args: []
+	};
+}
+function execSpawnEffect(runtime = this.actor.system) {
+	return runtime.spawnActor(this.source, this.actor);
+}
+function execStartEffect(runtime = this.actor.system) {
+	if (this.actor._processingStatus === 2) return;
+	return runtime.startActor(this.actor);
+}
+function execStopEffect(runtime = this.source.system) {
+	return runtime.stopActor(this.actor);
+}
+function execTerminateEffect(runtime = this.actor.system) {
+	const termination = this.status === "done" ? {
+		status: "done",
+		output: this.output,
+		error: void 0
+	} : {
+		status: "error",
+		output: void 0,
+		error: this.error
+	};
+	return runtime.terminateActor(this.actor, termination);
+}
+function execRaiseEffect(runtime = this.source.system) {
+	return runtime.scheduleTimer(this.source, this.id, this.delay ?? 0);
+}
+function execSendToEffect(runtime = this.source.system) {
+	assertSendToEvent(this.event);
+	if (this.delay !== void 0) return runtime.scheduleTimer(this.source, this.id, this.delay);
+	return runtime.sendEvent(this.source, this.target, this.event);
+}
+function execCancelEffect(runtime = this.source.system) {
+	return runtime.cancelTimer(this.source, this.id);
+}
+function updateLogicalTimers(snapshot, effect, actorScope) {
+	if (!isBuiltInExecutableAction(effect)) return snapshot;
+	if (effect.type === "@xstate.cancel") {
+		if (!snapshot.timers?.[effect.id]) return snapshot;
+		const timers = { ...snapshot.timers };
+		delete timers[effect.id];
+		return {
+			...snapshot,
+			timers
+		};
+	}
+	if (effect.type !== "@xstate.raise" && effect.type !== "@xstate.sendTo" || effect.delay === void 0) return snapshot;
+	let nextTimerId = snapshot._nextTimerId ?? 0;
+	const id = effect.id ?? `xstate.timer.auto.${nextTimerId++}`;
+	effect.id = id;
+	const target = effect.type === "@xstate.raise" || effect.target === actorScope.self ? "self" : effect.target;
+	return {
+		...snapshot,
+		timers: {
+			...snapshot.timers,
+			[id]: {
+				id,
+				delay: effect.delay,
+				type: effect.type,
+				event: effect.event,
+				target
+			}
+		},
+		_nextTimerId: nextTimerId
+	};
+}
+function mergeContextPatch(context, patch) {
+	return {
+		...context,
+		...patch
+	};
+}
+function pushBuiltInAction(actions, action, ...args) {
+	const actionRecord = {
+		action,
+		args
+	};
+	actions.push(actionRecord);
+	return actionRecord;
+}
+/** @internal Max-merges generated-id counter records, copy-on-write. */
+function mergeActorIdCounters(current, update) {
+	const merged = { ...current };
+	for (const key of Object.keys(update)) {
+		const next = update[key];
+		if (next === void 0) continue;
+		merged[key] = Math.max(merged[key] ?? 0, next);
+	}
+	return merged;
+}
+function applyChildUpdate(snapshot, update, actorScope) {
+	if (update.type === "add") return {
+		...snapshot,
+		children: {
+			...snapshot.children,
+			[update.id]: update.actor
+		},
+		...update.counters && { _nextActorIds: mergeActorIdCounters(snapshot._nextActorIds, update.counters) }
+	};
+	const children = { ...snapshot.children };
+	let owned = update.actor._parent === actorScope.self;
+	for (const key of Object.keys(children)) if (children[key] === update.actor) {
+		owned = true;
+		delete children[key];
+	}
+	if (!owned) throw new Error(`Cannot stop non-child actor ${update.actor.id}`);
+	actorScope.system._unregister(update.actor);
+	return {
+		...snapshot,
+		children
+	};
+}
+function getTransitionActionRecord(action) {
+	if (typeof action === "object" && action !== null && "action" in action && typeof action.action === "function") return action;
+}
+function pushSpawnedChild(actions, actor, id, counters) {
+	const action = pushBuiltInAction(actions, builtInActions["@xstate.spawn"], actor);
+	action.childUpdate = {
+		type: "add",
+		actor,
+		id,
+		counters
+	};
+}
+const spawnAllocations = /* @__PURE__ */ new WeakMap();
+const createSpawnAllocation = () => ({
+	counters: /* @__PURE__ */ new Map(),
+	explicitIds: /* @__PURE__ */ new Set(),
+	stoppedIds: /* @__PURE__ */ new Set()
+});
+/**
+* Starts a fresh spawn-allocation transaction for one logical transition.
+* Called at every transition boundary so pure replays from the same snapshot
+* allocate identical ids.
+*
+* @internal
+*/
+function beginSpawnAllocation(actorScope) {
+	spawnAllocations.set(actorScope, createSpawnAllocation());
+}
+function getWorkingSnapshotOf(actorScope) {
+	return actorScope.self._snapshot;
+}
+function getRegisteredActors(actorScope) {
+	return actorScope.self.logic?.sources?.actors;
+}
+function resolveTransitionSpawnSource(actorScope, source) {
+	const registeredActors = getRegisteredActors(actorScope);
+	if (typeof source === "string") {
+		const logic = registeredActors?.[source];
+		if (!logic) throw new Error(`Actor source '${source}' is not provided`);
+		return {
+			logic,
+			src: source
+		};
+	}
+	if (!registeredActors) return {
+		logic: source,
+		src: void 0
+	};
+	return {
+		logic: source,
+		src: resolveRegisteredActorSource(registeredActors, source)
+	};
+}
+/**
+* The next free index for a prefix. The parent snapshot's persisted counter
+* is always a floor, so a freed id is never handed out again — not even when
+* an explicit id reserved a lower one earlier in the transition.
+*/
+function nextChildIndex(actorScope, allocation, prefix) {
+	return Math.max(allocation.counters.get(prefix) ?? 0, getWorkingSnapshotOf(actorScope)?._nextActorIds?.[prefix] ?? 0);
+}
+/**
+* Allocates the next generated child id for the transition's allocation
+* transaction, seeded from the parent snapshot's own persisted counters. This
+* is the single allocator for snapshot-owned children (`enq.spawn` and
+* context-factory spawns); a correct allocation cannot collide.
+*
+* @internal
+*/
+function allocateChildId(actorScope, src, localAllocation) {
+	const allocation = spawnAllocations.get(actorScope) ?? localAllocation ?? createSpawnAllocation();
+	const prefix = getActorIdPrefix(src);
+	const next = nextChildIndex(actorScope, allocation, prefix);
+	allocation.counters.set(prefix, next + 1);
+	return {
+		id: `${prefix}:${next}`,
+		counters: { [prefix]: next + 1 }
+	};
+}
+/**
+* Requires an explicit child id to be unoccupied before a spawn or invoke
+* claims it: an address must name at most one live actor. An id is occupied
+* when a child of this parent already holds it and this transition has not
+* stopped that child, or when an earlier spawn of this transition claimed it.
+*
+* @internal
+*/
+function assertChildIdFree(actorScope, id, localAllocation) {
+	const allocation = spawnAllocations.get(actorScope) ?? localAllocation ?? createSpawnAllocation();
+	const existing = getWorkingSnapshotOf(actorScope)?.children?.[id];
+	const occupied = existing !== void 0 && !allocation.stoppedIds.has(id) && existing.getSnapshot().status === "active";
+	if (allocation.explicitIds.has(id) || occupied) throw new Error(`Child actor id '${id}' is already in use`);
+	allocation.explicitIds.add(id);
+}
+/**
+* Records that this transition stopped a child, freeing its id for a later
+* spawn or invoke of the same transition (the invoke restart pattern).
+*
+* @internal
+*/
+function recordStoppedChild(actorScope, actor) {
+	const allocation = spawnAllocations.get(actorScope);
+	if (allocation) {
+		allocation.stoppedIds.add(actor.id);
+		allocation.explicitIds.delete(actor.id);
+	}
+}
+/**
+* Reserves an explicit generated-shaped id (`worker:5`) in the transaction
+* and the parent snapshot, so live runs and pure replays allocate the same
+* later ids even after this child is removed.
+*
+* @internal
+*/
+function reserveChildId(actorScope, id, localAllocation) {
+	const generated = parseGeneratedActorId(id);
+	if (!generated) return;
+	generated.prefix;
+	const allocation = spawnAllocations.get(actorScope) ?? localAllocation ?? createSpawnAllocation();
+	const next = Math.max(nextChildIndex(actorScope, allocation, generated.prefix), generated.index + 1);
+	allocation.counters.set(generated.prefix, next);
+	return { [generated.prefix]: next };
+}
+/**
+* The counters allocated so far in the transition's transaction, for
+* committing into a snapshot built outside `applyChildUpdate` (the
+* pre-initial snapshot with context-factory spawns).
+*
+* @internal
+*/
+function takeSpawnAllocationCounters(actorScope) {
+	const counters = spawnAllocations.get(actorScope)?.counters;
+	if (!counters?.size) return;
+	return Object.fromEntries(counters);
+}
+function createTransitionEnqueue(actorScope, actions, internalEvents, actorSubscriptions = false, createActors = true) {
+	const localAllocation = spawnAllocations.get(actorScope) ?? createSpawnAllocation();
+	const props = {
+		cancel: (id) => {
+			pushBuiltInAction(actions, builtInActions["@xstate.cancel"], actorScope, id);
+		},
+		emit: (emittedEvent) => {
+			actions.push(emittedEvent);
+		},
+		log: (...args) => {
+			pushBuiltInAction(actions, actorScope.logger, ...args);
+		},
+		raise: (raisedEvent, options) => {
+			if (typeof raisedEvent === "string") throw new Error(`Only event objects may be used with raise`);
+			if (options?.delay !== void 0) pushBuiltInAction(actions, builtInActions["@xstate.raise"], actorScope, raisedEvent, options);
+			else internalEvents.push(raisedEvent);
+		},
+		spawn: (source, options) => {
+			const { logic, src } = resolveTransitionSpawnSource(actorScope, source);
+			if (!createActors) return { id: options?.id ?? options?.registryKey ?? src ?? logic.id };
+			let id = options?.id;
+			let counters;
+			if (id === void 0) ({id, counters} = allocateChildId(actorScope, src ?? logic, localAllocation));
+			else {
+				assertChildIdFree(actorScope, id, localAllocation);
+				counters = reserveChildId(actorScope, id, localAllocation);
+			}
+			const actor = actorScope.system.createActorRef(logic, {
+				...options,
+				...src !== void 0 && { src },
+				id,
+				parent: actorScope.self
+			});
+			pushSpawnedChild(actions, actor, id, counters);
+			return actor;
+		},
+		sendTo: (actor, event, options) => {
+			pushBuiltInAction(actions, builtInActions["@xstate.sendTo"], actorScope, actor, event, options);
+		},
+		stop: (actor) => {
+			if (actor) {
+				const actorInstance = actor;
+				const action = pushBuiltInAction(actions, builtInActions["@xstate.stop"], actorScope, actorInstance);
+				action.childUpdate = {
+					type: "remove",
+					actor: actorInstance
+				};
+				recordStoppedChild(actorScope, actorInstance);
+			}
+		}
+	};
+	if (actorSubscriptions) Object.assign(props, {
+		listen: (actor, eventType, mapper) => {
+			if (!createActors) return { id: void 0 };
+			const input = {
+				actor,
+				eventType,
+				mapper
+			};
+			const listenerActor = actorScope.system.createActorRef(listenerLogic, {
+				input,
+				parent: actorScope.self
+			});
+			pushBuiltInAction(actions, builtInActions["@xstate.spawn"], listenerActor);
+			return listenerActor;
+		},
+		subscribeTo: (actor, mappers) => {
+			if (!createActors) return { id: void 0 };
+			const input = {
+				actor,
+				mappers: typeof mappers === "function" ? { snapshot: mappers } : mappers
+			};
+			const subscriptionActor = actorScope.system.createActorRef(subscriptionLogic, {
+				input,
+				parent: actorScope.self
+			});
+			pushBuiltInAction(actions, builtInActions["@xstate.spawn"], subscriptionActor);
+			return subscriptionActor;
+		}
+	});
+	let closed = false;
+	const guard = (fn) => (...args) => closed ? void 0 : fn(...args);
+	for (const key of Object.keys(props)) props[key] = guard(props[key]);
+	const enqueue = createEnqueueObject(props, guard((action, ...args) => {
+		pushBuiltInAction(actions, action, ...args);
+	}));
+	enqueueClosers.set(enqueue, () => {
+		closed = true;
+	});
+	return enqueue;
+}
+const enqueueClosers = /* @__PURE__ */ new WeakMap();
+/**
+* @internal Invalidates an enqueue handle after the function it was passed
+* to returned. Later `enq.*` calls throw in development and no-op in
+* production.
+*/
+function closeTransitionEnqueue(enqueue) {
+	enqueueClosers.get(enqueue)?.();
+}
+function getBuiltInActionFields(action, args) {
+	switch (action) {
+		case builtInActions["@xstate.spawn"]: {
+			const [actor] = args;
+			return {
+				type: "@xstate.spawn",
+				kind: "builtin",
+				exec: execSpawnEffect,
+				source: actor._parent,
+				actor,
+				id: actor.id,
+				logic: actor.logic,
+				src: actor.src,
+				input: actor.options?.input
+			};
+		}
+		case builtInActions["@xstate.raise"]: {
+			const [, event, options] = args;
+			return {
+				type: "@xstate.raise",
+				kind: "builtin",
+				exec: execRaiseEffect,
+				source: args[0].self,
+				event,
+				id: options?.id,
+				delay: options?.delay
+			};
+		}
+		case builtInActions["@xstate.sendTo"]: {
+			const [, target, event, options] = args;
+			return {
+				type: "@xstate.sendTo",
+				kind: "builtin",
+				exec: execSendToEffect,
+				source: args[0].self,
+				target,
+				event,
+				id: options?.id,
+				delay: options?.delay
+			};
+		}
+		case builtInActions["@xstate.cancel"]: {
+			const [, id] = args;
+			return {
+				type: "@xstate.cancel",
+				kind: "builtin",
+				exec: execCancelEffect,
+				source: args[0].self,
+				id
+			};
+		}
+		case builtInActions["@xstate.stop"]: {
+			const [, actor] = args;
+			return {
+				type: "@xstate.stop",
+				kind: "builtin",
+				exec: execStopEffect,
+				source: args[0].self,
+				actor,
+				id: actor.id
+			};
+		}
+		default: return;
+	}
+}
+/** @internal Creates an actor-start effect, including for restored children. */
+function createStartEffect(actor) {
+	const args = [actor];
+	return {
+		kind: "builtin",
+		exec: execStartEffect,
+		type: XSTATE_START,
+		source: actor._parent,
+		params: void 0,
+		args,
+		actor,
+		id: actor.id
+	};
+}
+/** @internal Recreates a pending logical timer without re-entering its state. */
+function createTimerEffect(actorScope, timer, delay) {
+	const source = actorScope.self;
+	const options = {
+		id: timer.id,
+		delay
+	};
+	if (timer.type === "@xstate.raise") return {
+		kind: "builtin",
+		type: timer.type,
+		source,
+		event: timer.event,
+		id: timer.id,
+		delay,
+		params: void 0,
+		args: [
+			actorScope,
+			timer.event,
+			options
+		],
+		exec: execRaiseEffect
+	};
+	const target = timer.target === "self" ? source : timer.target;
+	return {
+		kind: "builtin",
+		type: timer.type,
+		source,
+		target,
+		event: timer.event,
+		id: timer.id,
+		delay,
+		params: void 0,
+		args: [
+			actorScope,
+			target,
+			timer.event,
+			options
+		],
+		exec: execSendToEffect
+	};
+}
+function createSpawnEffect(actor) {
+	const args = [actor];
+	return {
+		kind: "builtin",
+		exec: execSpawnEffect,
+		type: XSTATE_SPAWN,
+		source: actor._parent,
+		params: void 0,
+		args,
+		actor,
+		id: actor.id,
+		logic: actor.logic,
+		src: actor.src,
+		input: actor.options?.input
+	};
+}
+/** @internal Creates an immediate actor-to-actor delivery effect. */
+function createSendToEffect(actorScope, target, event) {
+	const args = [
+		actorScope,
+		target,
+		event,
+		{}
+	];
+	return {
+		kind: "builtin",
+		exec: execSendToEffect,
+		type: "@xstate.sendTo",
+		source: actorScope.self,
+		target,
+		event,
+		id: void 0,
+		delay: void 0,
+		params: void 0,
+		args
+	};
+}
+/** @internal Creates the terminal lifecycle effect for an actor. */
+function createTerminationEffect(actorScope, snapshot) {
+	if (snapshot.status !== "done" && snapshot.status !== "error") throw new Error("Cannot terminate an active or stopped actor");
+	const termination = snapshot.status === "done" ? {
+		status: "done",
+		output: snapshot.output,
+		error: void 0
+	} : {
+		status: "error",
+		output: void 0,
+		error: snapshot.error
+	};
+	const args = [actorScope.self, termination];
+	return {
+		kind: "builtin",
+		exec: execTerminateEffect,
+		type: XSTATE_TERMINATE,
+		source: actorScope.self,
+		actor: actorScope.self,
+		id: actorScope.self.id,
+		...termination,
+		params: void 0,
+		args
+	};
+}
+/**
+* Ensures that a newly terminal snapshot has exactly one ordered actor
+* termination effect.
+*
+* @internal
+*/
+function finalizeTransitionResult(actorScope, previousSnapshot, [nextSnapshot, effects]) {
+	const becameTerminal = nextSnapshot.status === "done" || nextSnapshot.status === "error";
+	const wasTerminal = previousSnapshot?.status === "done" || previousSnapshot?.status === "error";
+	const hasTerminationEffect = effects.some((effect) => typeof effect === "object" && effect !== null && "type" in effect && effect.type === "@xstate.terminate");
+	return becameTerminal && !wasTerminal && !hasTerminationEffect ? [nextSnapshot, [...effects, createTerminationEffect(actorScope, nextSnapshot)]] : [nextSnapshot, effects];
+}
+/**
+* Attached (listener/subscription) starts are ordered before child starts so
+* that a listener/subscription captures events emitted synchronously as its
+* target actor starts.
+*/
+function deriveDeferredStarts(effects) {
+	const attachedStarts = [];
+	const childStarts = [];
+	for (const effect of effects) {
+		if (!isBuiltInExecutableAction(effect) || effect.type !== "@xstate.spawn") continue;
+		const { actor, logic } = effect;
+		const start = createStartEffect(actor);
+		if (logic === listenerLogic || logic === subscriptionLogic) attachedStarts.push(start);
+		else childStarts.push(start);
+	}
+	return [...attachedStarts, ...childStarts];
+}
+/** @public */
+function isBuiltInExecutableAction(action) {
+	return action.kind === "builtin";
+}
+/**
+* Executes transition effects sequentially, awaiting each runtime operation.
+*
+* @public
+*/
+async function executeEffects(effects, runtime) {
+	for (const effect of effects) await effect.exec(runtime);
+}
+function resolveActionsWithContext(currentSnapshot, event, actorScope, actions) {
+	let intermediateSnapshot = currentSnapshot;
+	const executableActions = [];
+	for (const action of actions) {
+		const actionArgs = isLazyActorScope(actorScope) ? withActorScope({
+			context: intermediateSnapshot.context,
+			event,
+			output: getEventOutput(event),
+			children: intermediateSnapshot.children,
+			actions: currentSnapshot.machine.sources.actions,
+			actors: currentSnapshot.machine.sources.actors
+		}, actorScope) : {
+			context: intermediateSnapshot.context,
+			event,
+			output: getEventOutput(event),
+			self: actorScope.self,
+			system: actorScope.system,
+			parent: actorScope.self._parent,
+			children: intermediateSnapshot.children,
+			actions: currentSnapshot.machine.sources.actions,
+			actors: currentSnapshot.machine.sources.actors
+		};
+		const isInline = typeof action === "function";
+		const actionRecord = getTransitionActionRecord(action);
+		let resolvedActionArgs = actionRecord?.args;
+		if (actionRecord?.action === builtInActions["@xstate.sendTo"] && (actionRecord.args[1] === void 0 || typeof actionRecord.args[1] === "string")) {
+			const childId = actionRecord.args[1];
+			const target = childId !== void 0 && Object.hasOwn(intermediateSnapshot.children, childId) ? intermediateSnapshot.children[childId] : void 0;
+			if (!target) {
+				executableActions.push(createMissingTargetEffect(actorScope, actionRecord.args[2], childId));
+				continue;
+			}
+			resolvedActionArgs = [
+				actionRecord.args[0],
+				target,
+				...actionRecord.args.slice(2)
+			];
+		}
+		const resolvedAction = isInline ? action : actionRecord ? actionRecord.action.bind(null, ...resolvedActionArgs) : false;
+		let actionParams = void 0;
+		if (typeof action === "object" && action !== null) {
+			const { type: _, childUpdate: _childUpdate, ...emittedEventParams } = action;
+			actionParams = emittedEventParams;
+		}
+		if (actionRecord?.childUpdate) intermediateSnapshot = applyChildUpdate(intermediateSnapshot, actionRecord.childUpdate, actorScope);
+		if (resolvedAction && "_special" in resolvedAction) {
+			executableActions.push({
+				kind: "action",
+				exec: execCustomEffect,
+				type: typeof action === "object" ? "action" in action && typeof action.action === "function" ? action.action.name ?? "(anonymous)" : action.type ?? "(anonymous)" : action.name || "(anonymous)",
+				params: actionParams,
+				args: [],
+				action: void 0
+			});
+			const res = resolvedAction(actionArgs, emptyEnqueueObject);
+			if (res && ("context" in res || "children" in res)) intermediateSnapshot = {
+				...intermediateSnapshot,
+				...res.context !== void 0 ? { context: mergeContextPatch(intermediateSnapshot.context, res.context) } : {},
+				..."children" in res ? { children: res.children } : {}
+			};
+			continue;
+		}
+		if (!resolvedAction || !("resolve" in resolvedAction)) {
+			const builtInFields = typeof action === "object" && action !== null && "action" in action && typeof action.action === "function" ? getBuiltInActionFields(action.action, resolvedActionArgs) : void 0;
+			const isEmittedEvent = typeof action === "object" && action !== null && !actionRecord;
+			const typedExecutableAction = {
+				kind: builtInFields ? "builtin" : isEmittedEvent ? "emit" : "action",
+				type: typeof action === "object" ? "action" in action && typeof action.action === "function" ? action.action.name ?? "(anonymous)" : action.type : action.name || "(anonymous)",
+				params: builtInFields ? void 0 : actionParams,
+				args: typeof action === "object" && "action" in action ? resolvedActionArgs : [],
+				...builtInFields ? {} : isEmittedEvent ? {
+					source: actorScope.self,
+					event: action
+				} : { action: actionRecord?.action ?? (isInline ? action : void 0) },
+				...!builtInFields ? { exec: isEmittedEvent ? execEmitEffect : execCustomEffect } : {},
+				...builtInFields
+			};
+			intermediateSnapshot = updateLogicalTimers(intermediateSnapshot, typedExecutableAction, actorScope);
+			executableActions.push(typedExecutableAction);
+			continue;
+		}
+	}
+	return [intermediateSnapshot, executableActions];
+}
+function createEnqueueObject(props, action) {
+	const enqueueFn = (fn, ...args) => {
+		action(fn, ...args);
+	};
+	Object.assign(enqueueFn, {
+		cancel: noop,
+		emit: noop,
+		log: noop,
+		raise: noop,
+		spawn: emptyActor,
+		sendTo: noop,
+		stop: noop,
+		listen: emptyActor,
+		subscribeTo: emptyActor,
+		...props
+	});
+	return enqueueFn;
+}
+const noop = () => {};
+const emptyActor = () => ({});
+const emptyEnqueueObject = createEnqueueObject({}, noop);
+// src/transitionGuards.ts
+const isStateId = (str) => str.startsWith("#");
+const isStateIdValue = (stateValue) => typeof stateValue === "string" && isStateId(stateValue);
+const stateInSnapshot = (snapshot, stateValue) => {
+	if (isStateIdValue(stateValue)) {
+		const target = snapshot.machine.getStateNodeById(stateValue);
+		return snapshot.nodes.some((node) => node === target);
+	}
+	return snapshot.matches(stateValue);
+};
+function checkStateIn(...args) {
+	if (args.length === 1) {
+		const [stateValue] = args;
+		return (snapshot) => stateInSnapshot(snapshot, stateValue);
+	}
+	return stateInSnapshot(args[0], args[1]);
+}
+const matchesEvent = (event, pattern) => Object.entries(pattern).every(([key, value]) => Object.is(Reflect.get(event, key), value));
+const selectTransition = (outcome) => outcome.type === "returned" ? selectionOfReturned(outcome.value) : { type: "effect" };
+const selectionOfReturned = (value) => value === void 0 ? { type: "absent" } : {
+	type: "value",
+	result: value
+};
+const admitsByDecisionType = {
+	rejected: false,
+	admitted: true,
+	enabled: true,
+	disabled: false
+};
+const isAdmitted = (decision) => admitsByDecisionType[decision.type];
+const rejectedDecision = { type: "rejected" };
+const admittedDecision = { type: "admitted" };
+const patternAccepts = (input) => input.matches === void 0 || matchesEvent(input.event, input.matches);
+const sessionAccepts = (input) => input.eventMatcher === void 0 || input.eventMatcher(input.event, input.snapshot);
+const guardAccepts = (input) => input.runGuard === void 0 || input.runGuard();
+const sessionAndGuardAccept = (input) => sessionAccepts(input) && guardAccepts(input);
+const checksAccept = (input) => patternAccepts(input) && sessionAndGuardAccept(input);
+const selectionDecision = (selection) => selection.type === "absent" ? {
+	type: "disabled",
+	selection
+} : {
+	type: "enabled",
+	selection
+};
+const transitionDecision = (input) => input.runTransitionFunction === void 0 ? admittedDecision : selectionDecision(selectTransition(input.runTransitionFunction()));
+const admitCandidate = (input) => checksAccept(input) ? transitionDecision(input) : rejectedDecision;
+const admittedOf = (admit, candidate) => {
+	const decision = admit(candidate);
+	return isAdmitted(decision) ? {
+		candidate,
+		decision
+	} : void 0;
+};
+const firstAdmittedCandidate = (input) => input.candidates.reduce((admitted, candidate) => admitted ?? admittedOf(input.admit, candidate), void 0);
+// src/stateUtils.ts
+function getConfiguredDelayValue(delay, delaySource) {
+	if (typeof delay !== "string") return delay;
+	const referencedDelay = delaySource[delay];
+	if (referencedDelay !== void 0) return referencedDelay;
+	const parsedDelay = parseDurationToMilliseconds(delay);
+	if (parsedDelay === void 0) throw new Error(`Invalid delay "${delay}": not a configured delay name or a valid duration string (e.g. "500ms", "1.5s", "PT1M30S").`);
+	return parsedDelay;
+}
+function resolveDelay(delay, delaySource, args) {
+	if (typeof delay === "function") return delay(args);
+	const configuredDelay = getConfiguredDelayValue(delay, delaySource);
+	if (typeof configuredDelay === "function") return configuredDelay(args);
+	return configuredDelay;
+}
+function getStateInput(snapshot, stateNodeId) {
+	return snapshot._stateInputs?.[stateNodeId];
+}
+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 activeParentSet = /* @__PURE__ */ new Set();
+	for (const stateNode of nodeSet) if (stateNode.parent) activeParentSet.add(stateNode.parent);
+	for (const s of nodeSet) {
+		if (s.type === "compound" && !activeParentSet.has(s)) {
+			for (const sn of getInitialStateNodes(s)) nodeSet.add(sn);
+			continue;
+		}
+		if (s.type === "parallel") {
+			for (const child of getChildren(s)) if (!nodeSet.has(child)) {
+				const initialStates = getInitialStateNodes(child);
+				for (const initialStateNode of initialStates) nodeSet.add(initialStateNode);
+			}
+		}
+	}
+	for (const s of nodeSet) {
+		let m = s.parent;
+		while (m && !nodeSet.has(m)) {
+			nodeSet.add(m);
+			m = m.parent;
+		}
+	}
+	return nodeSet;
+}
+function getStateValue(rootNode, stateNodes) {
+	const config = getAllStateNodes(stateNodes);
+	const adjList = /* @__PURE__ */ new Map();
+	for (const s of config) {
+		if (!adjList.has(s)) adjList.set(s, []);
+		if (!s.parent) continue;
+		if (!adjList.has(s.parent)) adjList.set(s.parent, []);
+		adjList.get(s.parent).push(s);
+	}
+	const getValueFromAdj = (baseNode) => {
+		const childStateNodes = adjList.get(baseNode);
+		if (!childStateNodes) return {};
+		if (baseNode.type === "compound") {
+			const childStateNode = childStateNodes[0];
+			if (!childStateNode) return {};
+			if (isAtomicStateNode(childStateNode)) return childStateNode.key;
+		}
+		const stateValue = {};
+		for (const childStateNode of childStateNodes) stateValue[childStateNode.key] = getValueFromAdj(childStateNode);
+		return stateValue;
+	};
+	return getValueFromAdj(rootNode);
+}
+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";
+}
+function getLegacyEventType(event) {
+	switch (event.type) {
+		case "xstate.done.actor":
+		case "xstate.error.actor": return `${event.type}.${event.actorId}`;
+		case "xstate.snapshot.actor": return `xstate.snapshot.${event.actorId}`;
+		case "xstate.done.state": return `xstate.done.state.${event.stateId}`;
+		case "xstate.after": return `xstate.after.${event.delay}.${event.stateId}`;
+		case "xstate.timeout": return `xstate.timeout.${event.stateId}`;
+		case "xstate.timeout.actor": return `xstate.timeout.actor.${event.actorId}`;
+		default: return;
+	}
+}
+function getEventTypeAliases(event) {
+	const legacyType = getLegacyEventType(event);
+	return legacyType ? [event.type, legacyType] : [event.type];
+}
+function getEventDescriptorKey(event) {
+	const legacyType = getLegacyEventType(event);
+	return legacyType ? `${event.type}|${legacyType}` : event.type;
+}
+function matchesActorSession(event, snapshot, actorId) {
+	const child = snapshot.children[actorId];
+	if (!child || !("sessionId" in event)) return true;
+	return child.sessionId === void 0 || child.sessionId === event.sessionId;
+}
+function normalizeLegacyInternalEvent(event, machine) {
+	if (event.type === "xstate.done.actor" || event.type === "xstate.error.actor" || event.type === "xstate.snapshot.actor" || event.type === "xstate.done.state" || event.type === "xstate.after" || event.type === "xstate.timeout" || event.type === "xstate.timeout.actor") return event;
+	const normalizeWithId = (prefix, type, idKey) => event.type.startsWith(prefix) ? {
+		...event,
+		type,
+		[idKey]: event[idKey] ?? event.type.slice(prefix.length)
+	} : void 0;
+	const normalized = normalizeWithId("xstate.done.actor.", "xstate.done.actor", "actorId") ?? normalizeWithId("xstate.error.actor.", "xstate.error.actor", "actorId") ?? normalizeWithId("xstate.snapshot.", "xstate.snapshot.actor", "actorId") ?? normalizeWithId("xstate.done.state.", "xstate.done.state", "stateId") ?? normalizeWithId("xstate.timeout.actor.", "xstate.timeout.actor", "actorId") ?? normalizeWithId("xstate.timeout.", "xstate.timeout", "stateId");
+	if (normalized) return normalized;
+	if (!event.type.startsWith("xstate.after.")) return event;
+	const stateId = [...machine.idMap.keys()].sort((a, b) => b.length - a.length).find((id) => event.type.endsWith(`.${id}`));
+	if (!stateId) return event;
+	const delayText = event.type.slice(13, -stateId.length - 1);
+	return {
+		...event,
+		type: "xstate.after",
+		delay: Number.isNaN(+delayText) ? delayText : +delayText,
+		stateId
+	};
+}
+function getCandidates(stateNode, event, warn) {
+	const eventTypes = getEventTypeAliases(event);
+	const exactMatches = eventTypes.flatMap((eventType) => stateNode.transitions.get(eventType) ?? []);
+	const wildcardCandidates = [...stateNode.transitions.keys()].filter((eventDescriptor) => !eventTypes.includes(eventDescriptor) && eventTypes.some((eventType) => matchesEventDescriptor(eventType, eventDescriptor, warn))).sort((a, b) => b.length - a.length).flatMap((key) => stateNode.transitions.get(key));
+	return exactMatches.length ? [...exactMatches, ...wildcardCandidates] : wildcardCandidates;
+}
+function scheduleDelayedEvent(stateNode, timerId, resolveEvent, resolveScheduledDelay) {
+	const oldEntry = stateNode.entry;
+	stateNode.entry = (x, enq) => {
+		const result = typeof oldEntry === "function" ? oldEntry(x, enq) : void 0;
+		const context = result?.context !== void 0 ? mergeContextPatch(x.context, result.context) : x.context;
+		enq.raise(resolveEvent(x), {
+			id: timerId,
+			delay: resolveScheduledDelay({
+				context,
+				event: x.event,
+				delays: x.delays,
+				input: x.input
+			})
+		});
+		return result;
+	};
+	const oldExit = stateNode.exit;
+	stateNode.exit = (_, enq) => {
+		enq.cancel(timerId);
+		return typeof oldExit === "function" ? oldExit(_, enq) : void 0;
+	};
+}
+/** All delayed transitions from the config. */
+function getDelayedTransitions(stateNode) {
+	const afterConfig = stateNode.config.after;
+	const timeoutConfig = stateNode.config.timeout;
+	const onTimeoutConfig = stateNode.config.onTimeout;
+	const invokeDefs = stateNode.invoke.filter((invokeDef) => invokeDef.timeout !== void 0);
+	if (!afterConfig && timeoutConfig === void 0 && invokeDefs.length === 0) return [];
+	const sources = [];
+	if (afterConfig) for (const key of Object.keys(afterConfig)) {
+		const delay = Number.isNaN(+key) ? key : +key;
+		sources.push({
+			event: createAfterEvent(delay, stateNode.id),
+			timerId: createAfterEventId(delay, stateNode.id),
+			delay,
+			transitions: afterConfig[key],
+			fromDelaysMap: true
+		});
+	}
+	if (timeoutConfig !== void 0 && onTimeoutConfig) sources.push({
+		event: createTimeoutEvent(stateNode.id),
+		timerId: createTimeoutEventId(stateNode.id),
+		delay: timeoutConfig,
+		transitions: onTimeoutConfig,
+		fromDelaysMap: true
+	});
+	for (const invokeDef of invokeDefs) sources.push({
+		event: createInvokeTimeoutEvent(invokeDef.id),
+		timerId: createInvokeTimeoutEventId(invokeDef.id),
+		resolveEvent: ({ children }) => createInvokeTimeoutEvent(invokeDef.id, children[invokeDef.id]?.sessionId),
+		eventMatcher: (event, snapshot) => matchesActorSession(event, snapshot, invokeDef.id),
+		delay: invokeDef.timeout,
+		transitions: invokeDef.onTimeout,
+		fromDelaysMap: false
+	});
+	const delayedTransitions = [];
+	for (const { event, timerId, resolveEvent, eventMatcher, delay, transitions, fromDelaysMap } of sources) {
+		scheduleDelayedEvent(stateNode, timerId, resolveEvent ?? (() => event), (x) => resolveDelay(delay, fromDelaysMap ? x.delays : {}, {
+			context: x.context,
+			event: x.event,
+			stateNode,
+			input: x.input
+		}));
+		const { type: eventType, ...eventPattern } = event;
+		for (const transition of toTransitionConfigArray(transitions)) delayedTransitions.push({
+			...transition,
+			matches: {
+				...transition.matches,
+				...Object.fromEntries(Object.entries(eventPattern).filter(([, value]) => value !== void 0))
+			},
+			event: eventType,
+			delay,
+			_eventMatcher: eventMatcher
+		});
+	}
+	return delayedTransitions.map((delayedTransition) => ({
+		...formatTransition(stateNode, delayedTransition.event, delayedTransition),
+		delay: delayedTransition.delay
+	}));
+}
+function formatTransition(stateNode, descriptor, transitionConfig) {
+	const normalizedTarget = normalizeTarget(transitionConfig.target);
+	const reenter = transitionConfig.reenter ?? false;
+	const target = resolveTarget(stateNode, normalizedTarget);
+	assertLegalTargetSet(stateNode, target);
+	const transition = {
+		...transitionConfig,
+		target,
+		source: stateNode,
+		reenter,
+		eventType: descriptor,
+		toJSON: () => ({
+			...transition,
+			source: `#${stateNode.id}`,
+			target: target ? target.map((t) => `#${t.id}`) : void 0
+		})
+	};
+	return transition;
+}
+function isStateNodeDescendantOf(stateNode, ancestor) {
+	for (let current = stateNode.parent; current; current = current.parent) if (current === ancestor) return true;
+	return false;
+}
+function getLeastCommonStateNodeAncestor(left, right) {
+	const leftAncestors = /* @__PURE__ */ new Set();
+	for (let current = left; current; current = current.parent) leftAncestors.add(current);
+	for (let current = right; current; current = current.parent) if (leftAncestors.has(current)) return current;
+}
+function assertLegalTargetSet(source, targets) {
+	if (!targets || targets.length < 2) return;
+	for (let leftIndex = 0; leftIndex < targets.length; leftIndex++) for (let rightIndex = leftIndex + 1; rightIndex < targets.length; rightIndex++) {
+		const left = targets[leftIndex];
+		const right = targets[rightIndex];
+		if (!left || !right) continue;
+		const commonAncestor = getLeastCommonStateNodeAncestor(left, right);
+		if (left === right || isStateNodeDescendantOf(left, right) || isStateNodeDescendantOf(right, left) || commonAncestor?.type !== "parallel") throw new Error(`Invalid target set for '${source.id}'`);
+	}
+}
+/**
+* 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 routeConfig = sn.config.route;
+				const routeMatches = ({ event }) => event.to === `#${routeId}`;
+				if (typeof routeConfig === "function") {
+					routeTransitions.push(formatTransition(rootStateNode, "xstate.route", {
+						guard: routeMatches,
+						to: (args) => {
+							const result = routeConfig(args);
+							if (!result) return;
+							return {
+								...result === true ? {} : result,
+								target: `#${routeId}`
+							};
+						}
+					}));
+					if (sn.states) collectRoutes(sn.states);
+					return;
+				}
+				const { guard: _guard, ...routeOptions } = routeConfig;
+				const transition = {
+					...routeOptions,
+					guard: routeMatches,
+					target: `#${routeId}`
+				};
+				routeTransitions.push(formatTransition(rootStateNode, "xstate.route", transition));
+			}
+			if (sn.states) collectRoutes(sn.states);
+		});
+	};
+	collectRoutes(rootStateNode.states);
+	if (routeTransitions.length > 0) rootStateNode.transitions.set("xstate.route", routeTransitions);
+}
+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 for '${stateNode.id}': ${err.message}`);
+		}
+		else throw new Error(`Invalid target: "${target}"`);
+	});
+}
+function resolveHistoryDefaultTargets(stateNode) {
+	const target = normalizeTarget(stateNode.config.target).map((t) => typeof t === "string" ? getStateNodeByPath(stateNode.parent, t) : t);
+	assertLegalTargetSet(stateNode, target);
+	return target;
+}
+function getInitialStateNodes(stateNode) {
+	const set = /* @__PURE__ */ new Set();
+	function iter(descStateNode) {
+		if (set.has(descStateNode)) return;
+		set.add(descStateNode);
+		if (descStateNode.type === "compound") for (const target of descStateNode.initial.target ?? []) iter(target);
+		else if (descStateNode.type === "parallel") for (const child of getChildren(descStateNode)) iter(child);
+	}
+	iter(stateNode);
+	for (const initialState of set) for (const ancestor of getProperAncestors(initialState, stateNode)) set.add(ancestor);
+	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);
+	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 {}
+	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
+* @public
+*/
+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 = new Array(childStateKeys.length);
+	const allStateNodes = [stateNode.machine.root, stateNode];
+	for (let i = 0; i < childStateKeys.length; i++) {
+		const childKey = childStateKeys[i];
+		if (childKey === void 0) continue;
+		const subStateNode = getStateNode(stateNode, childKey);
+		childStateNodes[i] = subStateNode;
+		allStateNodes.push(subStateNode);
+	}
+	for (let i = 0; i < childStateKeys.length; i++) {
+		const childKey = childStateKeys[i];
+		const childStateNode = childStateNodes[i];
+		const childValue = childKey === void 0 ? void 0 : stateValue[childKey];
+		if (childKey === void 0 || childStateNode === void 0 || childValue === void 0) continue;
+		allStateNodes.push(...getStateNodes(childStateNode, childValue));
+	}
+	return allStateNodes;
+}
+const selectionResultOf = (selection) => selection.type === "value" ? {
+	enabled: true,
+	result: selection.result,
+	reusable: true
+} : selection.type === "effect" ? {
+	enabled: true,
+	result: void 0,
+	reusable: false
+} : {
+	enabled: false,
+	result: void 0,
+	reusable: true
+};
+function transitionNode(stateNode, stateValue, snapshot, event, actorScope, selectionResults) {
+	if (typeof stateValue === "string") {
+		const next = getStateNode(stateNode, stateValue).next(snapshot, event, actorScope, selectionResults);
+		if (!next || !next.length) return stateNode.next(snapshot, event, actorScope, selectionResults);
+		return next;
+	}
+	const subStateKeys = Object.keys(stateValue);
+	const subStateKey = subStateKeys[0];
+	if (subStateKeys.length === 1 && subStateKey !== void 0) {
+		const next = transitionNode(getStateNode(stateNode, subStateKey), stateValue[subStateKey], snapshot, event, actorScope, selectionResults);
+		if (!next || !next.length) return stateNode.next(snapshot, event, actorScope, selectionResults);
+		return next;
+	}
+	const allInnerTransitions = [];
+	for (const subStateKey of subStateKeys) {
+		const subStateValue = stateValue[subStateKey];
+		if (!subStateValue) continue;
+		const innerTransitions = transitionNode(getStateNode(stateNode, subStateKey), subStateValue, snapshot, event, actorScope, selectionResults);
+		if (innerTransitions) allInnerTransitions.push(...innerTransitions);
+	}
+	if (!allInnerTransitions.length) return stateNode.next(snapshot, event, actorScope, selectionResults);
+	return allInnerTransitions;
+}
+function hasDescendantState(stateNodes, parentStateNode) {
+	for (const stateNode of stateNodes) if (isDescendant({
+		childStateNode: stateNode,
+		parentStateNode
+	})) return true;
+	return false;
+}
+function hasIntersection(s1, s2) {
+	const s1Size = s1 instanceof Set ? s1.size : Array.isArray(s1) ? s1.length : void 0;
+	const s2Size = s2 instanceof Set ? s2.size : Array.isArray(s2) ? s2.length : void 0;
+	if (s1Size !== void 0 && s2Size !== void 0 && s2Size < s1Size) [s1, s2] = [s2, s1];
+	const set1 = s1 instanceof Set ? s1 : new Set(s1);
+	for (const item of s2) if (set1.has(item)) return true;
+	return false;
+}
+function removeConflictingTransitions(enabledTransitions, stateNodeSet, snapshot, resolveTransition) {
+	const filteredTransitions = /* @__PURE__ */ new Set();
+	const exitSets = /* @__PURE__ */ new Map();
+	const getExitSet = (transition) => {
+		let exitSet = exitSets.get(transition);
+		if (!exitSet) {
+			exitSet = computeExitSet([transition], stateNodeSet, snapshot, resolveTransition);
+			exitSets.set(transition, exitSet);
+		}
+		return exitSet;
+	};
+	for (const t1 of enabledTransitions) {
+		let t1Preempted = false;
+		const transitionsToRemove = /* @__PURE__ */ new Set();
+		for (const t2 of filteredTransitions) if (hasIntersection(getExitSet(t1), getExitSet(t2))) {
+			if (isDescendant({
+				childStateNode: t1.source,
+				parentStateNode: t2.source
+			})) transitionsToRemove.add(t2);
+			else {
+				t1Preempted = true;
+				break;
+			}
+		}
+		if (!t1Preempted) {
+			for (const t3 of transitionsToRemove) filteredTransitions.delete(t3);
+			filteredTransitions.add(t1);
+		}
+	}
+	return Array.from(filteredTransitions);
+}
+function createTransitionResultResolver(snapshot, event, actorScope, resolveActions, selectionResults) {
+	let cache;
+	return (transition) => {
+		if (!transition.to) return getTransitionResult(transition, snapshot, event, actorScope, {
+			resolveActions,
+			selectionResult: selectionResults?.get(transition)
+		});
+		let result = cache?.get(transition);
+		if (!result) {
+			result = getTransitionResult(transition, snapshot, event, actorScope, {
+				resolveActions,
+				selectionResult: selectionResults?.get(transition)
+			});
+			(cache ??= /* @__PURE__ */ new Map()).set(transition, result);
+		}
+		return result;
+	};
+}
+function getEffectiveTargetStates(transition, historyValue, resolveTransition) {
+	const { targets } = resolveTransition(transition);
+	if (!targets) return [];
+	const targetSet = /* @__PURE__ */ new Set();
+	for (const targetNode of targets) if (isHistoryNode(targetNode)) {
+		const recall = recallHistory({
+			historyNode: targetNode,
+			historyValue,
+			defaultTargets: () => resolveHistoryDefaultTargets(targetNode)
+		});
+		if (recall.type === "recorded") for (const node of recall.nodes) targetSet.add(node);
+		else for (const node of getEffectiveTargetStates(recall.transition, historyValue, resolveTransition)) targetSet.add(node);
+	} else targetSet.add(targetNode);
+	return [...targetSet];
+}
+/**
+* Narrows a parallel domain to the single child region that contains every
+* effective target, so that a transition confined to one region does not exit
+* (and reset) its sibling regions.
+*/
+function narrowParallelDomain(domain, targetStates) {
+	let narrowed = domain;
+	while (narrowed.type === "parallel") {
+		const region = getChildren(narrowed).find((child) => targetStates.every((target) => target === child || isDescendant({
+			childStateNode: target,
+			parentStateNode: child
+		})));
+		if (!region) break;
+		narrowed = region;
+	}
+	return narrowed;
+}
+function getTransitionDomain(transition, snapshot, resolveTransition) {
+	const targetStates = getEffectiveTargetStates(transition, snapshot.historyValue, resolveTransition);
+	const { targets, reenter } = resolveTransition(transition);
+	if (transition._transitionDomain) {
+		if (transition._transitionDomain === "internal" && transition.source.type === "compound" && targetStates.every((target) => isDescendant({
+			childStateNode: target,
+			parentStateNode: transition.source
+		}))) return transition.source;
+		const [head, ...tail] = targetStates.concat(transition.source);
+		if (head === void 0) return;
+		for (const ancestor of getProperAncestors(head, void 0)) if (ancestor.type === "compound" && tail.every((stateNode) => isDescendant({
+			childStateNode: stateNode,
+			parentStateNode: ancestor
+		}))) return ancestor;
+		return;
+	}
+	if (!restoresSourceViaHistory({
+		targets: targets ?? [],
+		effectiveTargetStates: targetStates,
+		source: transition.source
+	}) && targetStates.every((target) => target === transition.source || isDescendant({
+		childStateNode: target,
+		parentStateNode: transition.source
+	}))) return reenter ? transition.source : narrowParallelDomain(transition.source, targetStates);
+	const [head, ...tail] = targetStates.concat(transition.source);
+	if (head === void 0) return;
+	for (const ancestor of getProperAncestors(head, void 0)) if (tail.every((sn) => isDescendant({
+		childStateNode: sn,
+		parentStateNode: ancestor
+	}))) return reenter ? ancestor : narrowParallelDomain(ancestor, targetStates);
+	if (reenter) return;
+	return narrowParallelDomain(transition.source.machine.root, targetStates);
+}
+function computeExitSet(transitions, stateNodeSet, snapshot, resolveTransition) {
+	const statesToExit = /* @__PURE__ */ new Set();
+	for (const transition of transitions) {
+		const { targets, reenter } = resolveTransition(transition);
+		if (targets?.length) {
+			const domain = getTransitionDomain(transition, snapshot, resolveTransition);
+			if (reenter && transition.source === domain) statesToExit.add(domain);
+			for (const stateNode of stateNodeSet) if (isDescendant({
+				childStateNode: stateNode,
+				parentStateNode: domain
+			})) statesToExit.add(stateNode);
+		}
+	}
+	return [...statesToExit];
+}
+function initialMicrostep(root, preInitialState, actorScope, initEvent, internalQueue) {
+	root.machine._microstepHooks?.begin(actorScope.self);
+	const initialStateNodes = [...getInitialStateNodes(root)];
+	const statesForDefaultEntry = /* @__PURE__ */ new Set();
+	const collectDefaultEntryStates = (stateNode) => {
+		if (stateNode.type === "compound") {
+			statesForDefaultEntry.add(stateNode);
+			for (const target of stateNode.initial.target ?? []) collectDefaultEntryStates(target);
+		} else if (stateNode.type === "parallel") for (const child of getChildren(stateNode)) collectDefaultEntryStates(child);
+	};
+	collectDefaultEntryStates(root);
+	return microstep([{
+		target: initialStateNodes.filter((stateNode) => !initialStateNodes.some((other) => other !== stateNode && isDescendant({
+			childStateNode: other,
+			parentStateNode: stateNode
+		}))),
+		source: root,
+		reenter: true,
+		eventType: null,
+		toJSON: null,
+		_statesForDefaultEntry: [...statesForDefaultEntry]
+	}], preInitialState, actorScope, initEvent, true, internalQueue);
+}
+/** https://www.w3.org/TR/scxml/#microstepProcedure */
+function microstep(transitions, currentSnapshot, actorScope, event, isInitial, internalQueue, selectionResults) {
+	const executableActions = [];
+	const internalEvents = currentSnapshot.machine._microstepHooks?.drain(actorScope.self);
+	if (internalEvents?.length) internalQueue.push(...internalEvents);
+	if (!transitions.length) return [currentSnapshot, executableActions];
+	{
+		const mutStateNodeSet = new Set(currentSnapshot.nodes);
+		let historyValue = currentSnapshot.historyValue;
+		const originalContext = currentSnapshot.context;
+		const filteredTransitions = transitions.length === 1 ? transitions : removeConflictingTransitions(transitions, mutStateNodeSet, currentSnapshot, createTransitionResultResolver(currentSnapshot, event, actorScope, false, selectionResults));
+		const getCurrentTransitionResult = createTransitionResultResolver(currentSnapshot, event, actorScope, true, selectionResults);
+		const changesState = filteredTransitions.some((transition) => {
+			const { targets, reenter } = getCurrentTransitionResult(transition);
+			return !!targets?.length || !!reenter;
+		});
+		const getStateActionsAndContext = (transitionFn, context, children, input, kind, stateNode) => {
+			if (transitionFn.length === 2) {
+				const actions = [];
+				const internalEvents = [];
+				let updatedContext;
+				const enqueue = createTransitionEnqueue(actorScope, actions, internalEvents, true);
+				const args = isLazyActorScope(actorScope) ? withActorScope({
+					context,
+					event,
+					children,
+					actions: currentSnapshot.machine.sources.actions,
+					actors: currentSnapshot.machine.sources.actors,
+					guards: currentSnapshot.machine.sources.guards,
+					delays: currentSnapshot.machine.sources.delays,
+					input,
+					stateNode
+				}, actorScope) : {
+					context,
+					event,
+					parent: actorScope.self._parent,
+					self: actorScope.self,
+					children,
+					system: actorScope.system,
+					actions: currentSnapshot.machine.sources.actions,
+					actors: currentSnapshot.machine.sources.actors,
+					guards: currentSnapshot.machine.sources.guards,
+					delays: currentSnapshot.machine.sources.delays,
+					input,
+					stateNode
+				};
+				let res;
+				try {
+					res = transitionFn(args, enqueue);
+				} finally {
+					closeTransitionEnqueue(enqueue);
+				}
+				assertSyncTransitionResult(res, event, stateNode.id, kind);
+				if (res?.context !== void 0) updatedContext = mergeContextPatch(context, res.context);
+				return [
+					actions,
+					updatedContext,
+					internalEvents
+				];
+			}
+			return [
+				[Object.assign((args, enqueue) => transitionFn(isLazyActorScope(actorScope) ? withActorScope({
+					context: args.context,
+					event: args.event,
+					output: args.output,
+					children: args.children,
+					actions: args.actions,
+					actors: args.actors,
+					input,
+					stateNode
+				}, actorScope) : {
+					...args,
+					input,
+					stateNode
+				}, enqueue), "_special" in transitionFn ? { _special: true } : {})],
+				void 0,
+				void 0
+			];
+		};
+		let nextState = currentSnapshot;
+		const getInvokeStopActions = (stateNode, children) => {
+			const actions = [];
+			const enqueue = createTransitionEnqueue(actorScope, actions, []);
+			for (const invokeDef of stateNode.invoke) {
+				const child = children[invokeDef.id];
+				if (child) enqueue.stop(child);
+			}
+			return actions;
+		};
+		const exitStates = () => {
+			const statesToExit = computeExitSet(filteredTransitions, mutStateNodeSet, currentSnapshot, getCurrentTransitionResult);
+			statesToExit.sort((a, b) => b.order - a.order);
+			let changedHistory;
+			const currentStateNodes = [...mutStateNodeSet];
+			for (const exitStateNode of statesToExit) for (const historyNode of Object.values(exitStateNode.states)) {
+				if (!isHistoryNode(historyNode)) continue;
+				changedHistory ??= { ...historyValue };
+				changedHistory[historyNode.id] = recordHistoryNodes({
+					historyNode,
+					exitingNode: exitStateNode,
+					currentStateNodes
+				});
+			}
+			for (const exitStateNode of statesToExit) {
+				const stateInput = getStateInput(currentSnapshot, exitStateNode.id);
+				const [exitActions, nextContext, internalEvents] = exitStateNode.exit ? getStateActionsAndContext(exitStateNode.exit, nextState.context, currentSnapshot.children, stateInput, "exit", exitStateNode) : [
+					[],
+					void 0,
+					void 0
+				];
+				if (internalEvents?.length) internalQueue.push(...internalEvents);
+				if (nextContext) nextState = cloneMachineSnapshot(nextState, { context: nextContext });
+				const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, exitActions);
+				nextState = resolvedState;
+				executableActions.push(...resolvedActions);
+				const invokeStopActions = getInvokeStopActions(exitStateNode, nextState.children);
+				if (invokeStopActions.length) {
+					const [stoppedState, stopEffects] = resolveActionsWithContext(nextState, event, actorScope, invokeStopActions);
+					nextState = stoppedState;
+					executableActions.push(...stopEffects);
+				}
+				mutStateNodeSet.delete(exitStateNode);
+			}
+			historyValue = changedHistory || historyValue;
+		};
+		if (!isInitial && changesState) exitStates();
+		let context = nextState.context;
+		const transitionActions = [];
+		const internalEvents = [];
+		for (const t of filteredTransitions) {
+			if (t.actions) transitionActions.push(...toArray(t.actions));
+			const res = getCurrentTransitionResult(t);
+			if (res.context !== void 0) context = mergeContextPatch(context, res.context);
+			if (res.actions) transitionActions.push(...res.actions);
+			if (res.internalEvents) internalEvents.push(...res.internalEvents);
+		}
+		if (internalEvents.length) internalQueue.push(...internalEvents);
+		const enterStates = () => {
+			const getMachineOutput = (rootCompletionNode) => {
+				const rootNode = nextState.machine.root;
+				let completionOutput;
+				if (rootCompletionNode.output !== void 0 && rootCompletionNode.parent) {
+					const rootDoneEvent = internalQueue.find((e) => e.type === "xstate.done.state" && e.stateId === rootNode.id);
+					completionOutput = rootDoneEvent && rootCompletionNode.parent === rootNode ? rootDoneEvent.output : resolveOutput(rootCompletionNode.output, nextState.context, event, actorScope.self, actorScope.warn, stateInputMap[rootCompletionNode.id]);
+				} else if (rootCompletionNode.type === "parallel") completionOutput = internalQueue.find((e) => e.type === "xstate.done.state" && e.stateId === rootCompletionNode.id)?.output;
+				if (rootNode.output === void 0) return rootCompletionNode.parent === rootNode ? completionOutput : void 0;
+				return resolveOutput(rootNode.output, nextState.context, createDoneStateEvent(rootCompletionNode.id, completionOutput), actorScope.self, actorScope.warn);
+			};
+			const statesToEnter = /* @__PURE__ */ new Set();
+			const statesForDefaultEntry = /* @__PURE__ */ new Set();
+			const addAncestorStatesToEnter = (ancestors, reentrancyDomain) => {
+				for (const anc of ancestors) {
+					if (!reentrancyDomain || isDescendant({
+						childStateNode: anc,
+						parentStateNode: reentrancyDomain
+					})) statesToEnter.add(anc);
+					if (anc.type === "parallel") {
+						for (const child of getChildren(anc)) if (!hasDescendantState(statesToEnter, child)) {
+							statesToEnter.add(child);
+							addDescendantStatesToEnter(child);
+						}
+					}
+				}
+			};
+			const addDescendantStatesToEnter = (stateNode) => {
+				if (isHistoryNode(stateNode)) {
+					const recall = recallHistory({
+						historyNode: stateNode,
+						historyValue,
+						defaultTargets: () => resolveHistoryDefaultTargets(stateNode)
+					});
+					if (recall.type === "recorded") {
+						for (const s of recall.nodes) {
+							statesToEnter.add(s);
+							addDescendantStatesToEnter(s);
+						}
+						for (const s of recall.nodes) addAncestorStatesToEnter(getProperAncestors(s, stateNode.parent), void 0);
+					} else {
+						statesForDefaultEntry.add(stateNode.parent);
+						const { targets } = getCurrentTransitionResult(recall.transition);
+						for (const s of targets ?? []) {
+							statesToEnter.add(s);
+							addDescendantStatesToEnter(s);
+						}
+						for (const s of targets ?? []) addAncestorStatesToEnter(getProperAncestors(s, stateNode.parent), void 0);
+					}
+					return;
+				}
+				if (stateNode.type === "compound") {
+					const initialStates = getCurrentTransitionResult(stateNode.initial).targets ?? [];
+					for (const initialState of initialStates) if (!isHistoryNode(initialState)) statesToEnter.add(initialState);
+					statesForDefaultEntry.add(stateNode);
+					for (const initialState of initialStates) addDescendantStatesToEnter(initialState);
+					for (const initialState of initialStates) addAncestorStatesToEnter(getProperAncestors(initialState, stateNode), void 0);
+					return;
+				}
+				if (stateNode.type === "parallel") {
+					for (const child of getChildren(stateNode)) if (!hasDescendantState(statesToEnter, child)) {
+						statesToEnter.add(child);
+						statesForDefaultEntry.add(child);
+						addDescendantStatesToEnter(child);
+					}
+				}
+			};
+			const enteredTargetsByTransition = /* @__PURE__ */ new Map();
+			for (const transition of filteredTransitions) {
+				const domain = getTransitionDomain(transition, currentSnapshot, getCurrentTransitionResult);
+				const { targets, reenter } = getCurrentTransitionResult(transition);
+				const enteredTargets = /* @__PURE__ */ new Set();
+				enteredTargetsByTransition.set(transition, enteredTargets);
+				for (const targetNode of targets ?? []) {
+					if (!isHistoryNode(targetNode) && (transition.source !== targetNode || transition.source !== domain || reenter)) {
+						enteredTargets.add(targetNode);
+						statesToEnter.add(targetNode);
+						statesForDefaultEntry.add(targetNode);
+					}
+					addDescendantStatesToEnter(targetNode);
+				}
+				const targetStates = getEffectiveTargetStates(transition, historyValue, getCurrentTransitionResult);
+				for (const s of targetStates) {
+					const ancestors = getProperAncestors(s, domain);
+					if (domain?.type === "parallel") ancestors.push(domain);
+					addAncestorStatesToEnter(ancestors, !transition.source.parent && reenter ? void 0 : domain);
+				}
+				if (reenter && domain === transition.source) statesToEnter.add(transition.source);
+			}
+			if (isInitial) for (const stateNode of filteredTransitions[0]._statesForDefaultEntry ?? [currentSnapshot.machine.root]) statesForDefaultEntry.add(stateNode);
+			const stateInputMap = { ...currentSnapshot._stateInputs };
+			let stateInputsChanged = false;
+			for (const transition of filteredTransitions) {
+				const { targets, input } = getCurrentTransitionResult(transition);
+				if (input && targets) for (const targetNode of targets.filter((targetNode) => enteredTargetsByTransition.get(transition)?.has(targetNode))) {
+					stateInputMap[targetNode.id] = input;
+					stateInputsChanged = true;
+				}
+			}
+			const completedNodes = /* @__PURE__ */ new Set();
+			const children = { ...nextState.children };
+			for (const stateNodeToEnter of [...statesToEnter].sort((a, b) => a.order - b.order)) {
+				mutStateNodeSet.add(stateNodeToEnter);
+				const actions = [];
+				let invoked = false;
+				for (const invokeDef of stateNodeToEnter.type === "final" ? [] : stateNodeToEnter.invoke) {
+					invoked = true;
+					let src = invokeDef.logic;
+					if (typeof src === "function") src = src({
+						actors: currentSnapshot.machine.sources.actors,
+						context: nextState.context,
+						event,
+						self: actorScope.self
+					});
+					const logic = typeof src === "string" ? resolveReferencedActor(currentSnapshot.machine, src) : src;
+					if (!logic) throw new Error(`Actor logic '${typeof src === "string" ? src : "inline"}' not implemented`);
+					const input = typeof invokeDef.input === "function" ? invokeDef.input({
+						self: actorScope.self,
+						context: nextState.context,
+						event,
+						...stateInputMap[stateNodeToEnter.id] !== void 0 && { input: stateInputMap[stateNodeToEnter.id] },
+						output: getEventOutput(event)
+					}) : invokeDef.input;
+					assertChildIdFree(actorScope, invokeDef.id);
+					const actor = actorScope.system.createActorRef(logic, {
+						...invokeDef,
+						input,
+						parent: actorScope.self,
+						syncSnapshot: !!invokeDef.onSnapshot
+					});
+					actions.push({
+						action: builtInActions["@xstate.spawn"],
+						args: [actor]
+					});
+					if (invokeDef.id) children[invokeDef.id] = actor;
+				}
+				if (invoked) nextState = cloneMachineSnapshot(nextState, { children });
+				let context = nextState.context;
+				let contextChangedByEntry = false;
+				const stateInput = stateInputMap[stateNodeToEnter.id];
+				if (stateNodeToEnter.entry) {
+					const [resultActions, nextContext, nextInternalEvents] = getStateActionsAndContext(stateNodeToEnter.entry, context, children, stateInput, "entry", stateNodeToEnter);
+					actions.push(...resultActions);
+					if (nextInternalEvents?.length) internalQueue.push(...nextInternalEvents);
+					if (nextContext) {
+						context = nextContext;
+						contextChangedByEntry = true;
+					}
+				}
+				if (contextChangedByEntry) nextState.context = context;
+				const defaultTransition = stateNodeToEnter.initial;
+				if (defaultTransition && statesForDefaultEntry.has(stateNodeToEnter)) {
+					const { actions: initialActions, context: initialContext, input: initialInput, internalEvents: initialInternalEvents } = getTransitionResult(defaultTransition, nextState, event, actorScope);
+					if (initialActions) actions.push(...initialActions);
+					if (initialInternalEvents?.length) internalQueue.push(...initialInternalEvents);
+					if (initialContext !== void 0) nextState.context = mergeContextPatch(nextState.context, initialContext);
+					if (initialInput && defaultTransition.target) for (const targetNode of defaultTransition.target) {
+						stateInputMap[targetNode.id] = initialInput;
+						stateInputsChanged = true;
+					}
+				}
+				const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, actions);
+				nextState = resolvedState;
+				actions.length = 0;
+				executableActions.push(...resolvedActions);
+				if (stateNodeToEnter.type !== "final") continue;
+				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, nextState.context, event, actorScope.self, actorScope.warn, stateInput) : void 0));
+				while (ancestorMarker?.type === "parallel" && !completedNodes.has(ancestorMarker) && isInFinalState(mutStateNodeSet, ancestorMarker)) {
+					completedNodes.add(ancestorMarker);
+					const regionOutput = {};
+					for (const region of getChildren(ancestorMarker)) {
+						if (region.type === "final") {
+							regionOutput[region.key] = region.output !== void 0 ? resolveOutput(region.output, nextState.context, event, actorScope.self, actorScope.warn, stateInputMap[region.id]) : void 0;
+							continue;
+						}
+						if (region.type === "parallel") {
+							const regionDoneEvent = internalQueue.find((e) => e.type === "xstate.done.state" && e.stateId === region.id);
+							regionOutput[region.key] = regionDoneEvent?.output;
+							continue;
+						}
+						const finalChild = getChildren(region).find((s) => s.type === "final" && mutStateNodeSet.has(s));
+						regionOutput[region.key] = finalChild?.output !== void 0 ? resolveOutput(finalChild.output, nextState.context, event, actorScope.self, actorScope.warn, stateInputMap[finalChild.id]) : void 0;
+					}
+					internalQueue.push(createDoneStateEvent(ancestorMarker.id, regionOutput));
+					rootCompletionNode = ancestorMarker;
+					ancestorMarker = ancestorMarker.parent;
+				}
+				if (ancestorMarker) continue;
+				nextState = cloneMachineSnapshot(nextState, {
+					status: "done",
+					output: getMachineOutput(rootCompletionNode)
+				});
+			}
+			if (stateInputsChanged) nextState = cloneMachineSnapshot(nextState, { _stateInputs: stateInputMap });
+		};
+		const [resolvedTransitionState, transitionExecutableActions] = resolveActionsWithContext(nextState, event, actorScope, transitionActions);
+		nextState = resolvedTransitionState;
+		executableActions.push(...transitionExecutableActions);
+		if (context && context !== currentSnapshot.context) nextState = cloneMachineSnapshot(nextState, { context });
+		if (isInitial || changesState) enterStates();
+		const nextStateNodes = [...mutStateNodeSet];
+		if (nextState.status === "done") {
+			const allExitActions = [];
+			nextStateNodes.sort((a, b) => b.order - a.order).forEach((stateNode) => {
+				if (stateNode.exit) {
+					const stateInput = getStateInput(nextState, stateNode.id);
+					const [exitActions, , nextInternalEvents] = getStateActionsAndContext(stateNode.exit, nextState.context, nextState.children, stateInput, "exit", stateNode);
+					allExitActions.push(...exitActions);
+					if (nextInternalEvents?.length) internalQueue.push(...nextInternalEvents);
+				}
+			});
+			const [resolvedState, resolvedActions] = resolveActionsWithContext(nextState, event, actorScope, allExitActions);
+			nextState = resolvedState;
+			executableActions.push(...resolvedActions);
+			const [stoppedState, stopEffects] = stopChildren(nextState, event, actorScope);
+			nextState = stoppedState;
+			executableActions.push(...stopEffects);
+			const [withoutTimers, cancelEffects] = cancelTimers(nextState, event, actorScope);
+			nextState = withoutTimers;
+			executableActions.push(...cancelEffects);
+		}
+		if (historyValue === currentSnapshot.historyValue && currentSnapshot.nodes.length === mutStateNodeSet.size && currentSnapshot.nodes.every((node) => mutStateNodeSet.has(node))) {
+			if (nextState.context !== originalContext) return [nextState === currentSnapshot ? cloneMachineSnapshot(nextState) : nextState, executableActions];
+			return [nextState, executableActions];
+		}
+		return [cloneMachineSnapshot(nextState, {
+			_nodes: nextStateNodes,
+			historyValue
+		}), executableActions];
+	}
+}
+/**
+* Gets the transition result for a given transition without executing the
+* transition.
+*/
+function getTransitionResult(transition, snapshot, event, actorScope, options) {
+	let transitionArgs;
+	const getTransitionArgs = () => transitionArgs ??= isLazyActorScope(actorScope) ? withActorScope({
+		context: snapshot.context,
+		event,
+		output: getEventOutput(event),
+		value: snapshot.value,
+		children: snapshot.children,
+		actions: snapshot.machine.sources.actions,
+		actors: snapshot.machine.sources.actors,
+		guards: snapshot.machine.sources.guards,
+		delays: snapshot.machine.sources.delays,
+		input: getStateInput(snapshot, transition.source.id)
+	}, actorScope) : {
+		context: snapshot.context,
+		event,
+		output: getEventOutput(event),
+		value: snapshot.value,
+		children: snapshot.children,
+		system: actorScope.system,
+		parent: actorScope.self._parent,
+		self: actorScope.self,
+		actions: snapshot.machine.sources.actions,
+		actors: snapshot.machine.sources.actors,
+		guards: snapshot.machine.sources.guards,
+		delays: snapshot.machine.sources.delays,
+		input: getStateInput(snapshot, transition.source.id)
+	};
+	if (transition.to) {
+		const actions = [];
+		const internalEvents = [];
+		let res;
+		if (options?.selectionResult?.reusable) res = options.selectionResult.result;
+		else {
+			const enqueue = createTransitionEnqueue(actorScope, actions, internalEvents, true, options?.resolveActions ?? true);
+			res = transition.to(getTransitionArgs(), enqueue);
+			closeTransitionEnqueue(enqueue);
+			assertSyncTransitionResult(res, event, transition.source.id);
+		}
+		const targets = res?.target ? resolveTarget(transition.source, toArray(res.target)) : void 0;
+		const resolvedInput = res?.input ?? (typeof transition.input === "function" ? transition.input({
+			context: snapshot.context,
+			event,
+			output: getEventOutput(event)
+		}) : transition.input);
+		return {
+			targets,
+			context: res?.context,
+			reenter: res?.reenter,
+			actions,
+			internalEvents,
+			input: resolvedInput
+		};
+	}
+	const resolvedInput = typeof transition.input === "function" ? transition.input({
+		context: snapshot.context,
+		event,
+		output: getEventOutput(event)
+	}) : transition.input;
+	const resolvedContext = typeof transition.context === "function" ? transition.context(getTransitionArgs()) : transition.context;
+	return {
+		targets: transition.target,
+		context: resolvedContext,
+		reenter: transition.reenter,
+		actions: void 0,
+		internalEvents: void 0,
+		input: resolvedInput
+	};
+}
+/** The default microstep bound for one macrostep. */
+const DEFAULT_MAX_ITERATIONS = 1e3;
+/**
+* Thrown when one macrostep takes more microsteps than the machine's
+* `options.maxIterations` (default `1000`) without reaching a stable state,
+* usually because eventless transitions or raised events form a cycle.
+*
+* @public
+*/
+var InfiniteTransitionError = class extends Error {
+	/** The id of the actor that was transitioning, if any. */
+	actorId;
+	/** The event being processed. */
+	event;
+	/** The microstep bound that was exceeded. */
+	maxIterations;
+	/** The last (up to 5) state values visited, oldest first. */
+	states;
+	constructor(actorId, event, maxIterations, states) {
+		super(`Infinite loop detected in actor "${actorId}" processing event "${event.type}": more than ${maxIterations} microsteps without reaching a stable state. Last states: ${states.map((value) => JSON.stringify(value)).join(" -> ")}. Check for a cycle of eventless transitions or raised events, or raise the bound with createMachine({ options: { maxIterations } }).`);
+		this.name = "InfiniteTransitionError";
+		this.actorId = actorId;
+		this.event = event;
+		this.maxIterations = maxIterations;
+		this.states = states.slice();
+	}
+};
+function macrostep(snapshot, event, actorScope, internalQueue, initialMicrosteps = []) {
+	let nextSnapshot = snapshot;
+	const microsteps = initialMicrosteps.slice();
+	let handled = false;
+	function removeTerminatedChild(terminalEvent) {
+		if (terminalEvent.type !== "xstate.done.actor" && terminalEvent.type !== "xstate.error.actor") return;
+		const { actorId, sessionId } = terminalEvent;
+		if (!actorId) return;
+		const child = nextSnapshot.children[actorId];
+		if (!child) return;
+		if (child.sessionId !== void 0 && child.sessionId !== sessionId) return;
+		const children = { ...nextSnapshot.children };
+		delete children[actorId];
+		actorScope.system._unregister(child);
+		nextSnapshot = cloneMachineSnapshot(nextSnapshot, { children });
+		if (microsteps.length) {
+			const [, lastEffects, lastTransitions] = microsteps.at(-1);
+			microsteps[microsteps.length - 1] = [
+				nextSnapshot,
+				lastEffects,
+				lastTransitions
+			];
+		} else microsteps.push([
+			nextSnapshot,
+			[],
+			[]
+		]);
+	}
+	function completeMacrostep() {
+		if (handled && nextSnapshot === snapshot) {
+			nextSnapshot = cloneMachineSnapshot(snapshot, {});
+			if (microsteps.at(-1)?.[0] === snapshot) {
+				const [, lastEffects, lastTransitions] = microsteps.at(-1);
+				microsteps[microsteps.length - 1] = [
+					nextSnapshot,
+					lastEffects,
+					lastTransitions
+				];
+			}
+		}
+		const starts = deriveDeferredStarts(microsteps.flatMap(([, actions]) => actions));
+		const shouldTerminate = (snapshot.status === "active" || initialMicrosteps.length > 0) && (nextSnapshot.status === "done" || nextSnapshot.status === "error");
+		if (starts.length || shouldTerminate) {
+			const terminalEffects = shouldTerminate ? [...starts, createTerminationEffect(actorScope, nextSnapshot)] : starts;
+			if (microsteps.length) {
+				const [lastSnapshot, lastEffects, lastTransitions] = microsteps.at(-1);
+				microsteps[microsteps.length - 1] = [
+					lastSnapshot,
+					[...lastEffects, ...terminalEffects],
+					lastTransitions
+				];
+			} else microsteps.push([
+				nextSnapshot,
+				terminalEffects,
+				[]
+			]);
+		}
+		return {
+			snapshot: nextSnapshot,
+			microsteps
+		};
+	}
+	function addMicrostep(step, transitions) {
+		if (!isInertActorScope(actorScope) && (event.type === "@xstate.init" || (actorScope.system._hasInspectionObservers?.() ?? true))) {
+			const collectedMicrosteps = actorScope.self._collectedMicrosteps || [];
+			collectedMicrosteps.push(...transitions);
+			actorScope.self._collectedMicrosteps = collectedMicrosteps;
+		}
+		microsteps.push([
+			step[0],
+			step[1],
+			transitions
+		]);
+	}
+	if (event.type === "@xstate.stop") {
+		const [stoppedChildrenSnapshot, stopEffects] = stopChildren(nextSnapshot, event, actorScope);
+		const [withoutTimers, cancelEffects] = cancelTimers(stoppedChildrenSnapshot, event, actorScope);
+		nextSnapshot = cloneMachineSnapshot(withoutTimers, { status: "stopped" });
+		addMicrostep([nextSnapshot, [...stopEffects, ...cancelEffects]], []);
+		return completeMacrostep();
+	}
+	let nextEvent = normalizeLegacyInternalEvent(event, snapshot.machine);
+	if (event.type === "xstate.timer") {
+		const timer = nextSnapshot.timers[event.id];
+		if (!timer) return completeMacrostep();
+		const timers = { ...nextSnapshot.timers };
+		delete timers[timer.id];
+		nextSnapshot = cloneMachineSnapshot(nextSnapshot, { timers });
+		if (timer.type === "@xstate.raise") {
+			internalQueue.push(timer.event);
+			addMicrostep([nextSnapshot, []], []);
+		} else {
+			const target = timer.target === "self" ? actorScope.self : timer.target;
+			addMicrostep([nextSnapshot, [createSendToEffect(actorScope, target, timer.event)]], []);
+		}
+	}
+	if (nextEvent.type !== "@xstate.init" && nextEvent.type !== "xstate.timer") {
+		const currentEvent = nextEvent;
+		const isErr = isErrorEvent(currentEvent);
+		const selectionResults = /* @__PURE__ */ new Map();
+		const transitions = nextSnapshot.machine.getTransitionData(nextSnapshot, currentEvent, actorScope, selectionResults);
+		if (isErr && !transitions.length) {
+			if (currentEvent.type === "xstate.error.actor" && !matchesActorSession(currentEvent, nextSnapshot, currentEvent["actorId"])) return completeMacrostep();
+			nextSnapshot = cloneMachineSnapshot(snapshot, {
+				status: "error",
+				error: currentEvent.error
+			});
+			addMicrostep([nextSnapshot, []], []);
+			removeTerminatedChild(currentEvent);
+			return completeMacrostep();
+		}
+		handled = transitions.length > 0;
+		const step = microstep(transitions, snapshot, actorScope, nextEvent, false, internalQueue, selectionResults);
+		nextSnapshot = step[0];
+		addMicrostep(step, transitions);
+		removeTerminatedChild(currentEvent);
+	}
+	if (!internalQueue.length && snapshot.machine._hasEventlessTransitions === false) return completeMacrostep();
+	let shouldSelectEventlessTransitions = true;
+	const maxIterations = snapshot.machine.options?.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+	let iterationCount = 0;
+	const recentStates = [];
+	while (nextSnapshot.status === "active") {
+		iterationCount++;
+		if (iterationCount > maxIterations) throw new InfiniteTransitionError(actorScope.self?.id, event, maxIterations, recentStates);
+		recentStates.push(nextSnapshot.value);
+		if (recentStates.length > 5) recentStates.shift();
+		let selectionResults;
+		let enabledTransitions = shouldSelectEventlessTransitions ? selectEventlessTransitions(nextSnapshot, nextEvent, actorScope) : [];
+		const previousState = enabledTransitions.length ? nextSnapshot : void 0;
+		const raisedEvents = nextSnapshot.machine._microstepHooks?.drain(actorScope.self);
+		if (raisedEvents?.length) internalQueue.push(...raisedEvents);
+		if (!enabledTransitions.length) {
+			if (!internalQueue.length) break;
+			nextEvent = internalQueue.shift();
+			selectionResults = /* @__PURE__ */ new Map();
+			enabledTransitions = nextSnapshot.machine.getTransitionData(nextSnapshot, nextEvent, actorScope, selectionResults);
+		}
+		const step = microstep(enabledTransitions, nextSnapshot, actorScope, nextEvent, false, internalQueue, selectionResults);
+		nextSnapshot = step[0];
+		shouldSelectEventlessTransitions = nextSnapshot !== previousState;
+		addMicrostep(step, enabledTransitions);
+		removeTerminatedChild(nextEvent);
+	}
+	return completeMacrostep();
+}
+/**
+* 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 hasEffect(transition, context, event, snapshot, actorScope) {
+	if (transition.to) return selectTransition(evaluateTransitionOutcome(transition.to, context, event, snapshot, actorScope, snapshot.machine.sources, transition.source.id)).type !== "absent";
+	return false;
+}
+let selectionDepth = 0;
+const triggerTransitionEffect = () => {
+	if (!selectionDepth) return void 0;
+	throw transitionEffectSignal;
+};
+/**
+* Throws when a transition, entry, or exit function returned a promise. The promise's
+* rejection is observed so it is never reported as unhandled.
+*/
+function assertSyncTransitionResult(res, event, sourceId, kind) {
+	if (res && typeof res.then === "function") {
+		Promise.resolve(res).catch(() => {});
+		throw new Error(kind ? `${kind === "entry" ? "Entry" : "Exit"} functions must be synchronous. The ${kind} function of state "${sourceId}" returned a promise (event "${event.type}"). Move async work into an invoked or spawned actor, or enq.effect.` : `Transition functions must be synchronous. Transition for event "${event.type}" in state "${sourceId}" returned a promise. Move async work into an invoked or spawned actor, or enq.effect.`);
+	}
+}
+let transitionEffectEnqueue;
+function getTransitionEffectEnqueue() {
+	return transitionEffectEnqueue ??= createEnqueueObject({
+		emit: triggerTransitionEffect,
+		cancel: triggerTransitionEffect,
+		log: triggerTransitionEffect,
+		raise: triggerTransitionEffect,
+		spawn: triggerTransitionEffect,
+		sendTo: triggerTransitionEffect,
+		stop: triggerTransitionEffect,
+		listen: triggerTransitionEffect,
+		subscribeTo: triggerTransitionEffect
+	}, triggerTransitionEffect);
+}
+function evaluateTransitionOutcome(transitionTo, context, event, snapshot, actorScope, sources, sourceId) {
+	let res;
+	const parent = getActorScopeParent(actorScope);
+	if (parent) transitionEffectTargets.push(parent);
+	selectionDepth++;
+	try {
+		res = transitionTo(withActorScope({
+			context,
+			event,
+			output: getEventOutput(event),
+			value: snapshot.value,
+			children: snapshot.children,
+			actions: sources.actions,
+			actors: sources.actors,
+			guards: sources.guards,
+			delays: sources.delays,
+			input: getStateInput(snapshot, sourceId)
+		}, actorScope), getTransitionEffectEnqueue());
+	} catch (err) {
+		if (err === transitionEffectSignal) return { type: "effectEnqueued" };
+		throw err;
+	} finally {
+		selectionDepth--;
+		if (parent) transitionEffectTargets.pop();
+	}
+	assertSyncTransitionResult(res, event, sourceId);
+	return {
+		type: "returned",
+		value: res
+	};
+}
+function stopChildren(snapshot, event, actorScope) {
+	let children;
+	if (!snapshot.children || (children = Object.values(snapshot.children).filter(Boolean)).length === 0) return [snapshot, []];
+	const actions = [];
+	const enqueue = createTransitionEnqueue(actorScope, actions, []);
+	for (const child of children) enqueue.stop(child);
+	return resolveActionsWithContext(snapshot, event, actorScope, actions);
+}
+function cancelTimers(snapshot, event, actorScope) {
+	const timerIds = Object.keys(snapshot.timers);
+	if (!timerIds.length) return [snapshot, []];
+	const actions = [];
+	const enqueue = createTransitionEnqueue(actorScope, actions, []);
+	for (const id of timerIds) enqueue.cancel(id);
+	return resolveActionsWithContext(snapshot, event, actorScope, actions);
+}
+function selectEventlessTransitions(snapshot, event, actorScope) {
+	snapshot.machine._microstepHooks?.begin(actorScope.self);
+	const enabledTransitionSet = /* @__PURE__ */ new Set();
+	const atomicStates = snapshot.nodes.filter(isAtomicStateNode);
+	for (const atomicStateNode of atomicStates) loop: for (let stateNode = atomicStateNode; stateNode; stateNode = stateNode.parent) {
+		if (!stateNode.always) continue;
+		for (const transition of stateNode.always) if (isAdmitted(admitTransitionCandidate(transition, event, snapshot, stateNode, actorScope))) {
+			enabledTransitionSet.add(transition);
+			break loop;
+		}
+	}
+	return removeConflictingTransitions(Array.from(enabledTransitionSet), new Set(snapshot.nodes), snapshot, createTransitionResultResolver(snapshot, event, actorScope, false));
+}
+function admitTransitionCandidate(candidate, event, snapshot, stateNode, actorScope, selectionResults) {
+	const transitionTo = candidate.to;
+	const decision = admitCandidate({
+		event,
+		snapshot,
+		matches: candidate.matches,
+		eventMatcher: candidate._eventMatcher,
+		runGuard: candidate.guard ? () => {
+			const guardArgs = withActorSelfAndParent({
+				context: snapshot.context,
+				event,
+				output: getEventOutput(event),
+				children: snapshot.children,
+				actions: stateNode.machine.sources.actions,
+				actors: stateNode.machine.sources.actors,
+				guards: stateNode.machine.sources.guards,
+				delays: stateNode.machine.sources.delays,
+				_snapshot: snapshot
+			}, actorScope);
+			return !!candidate.guard(guardArgs);
+		} : void 0,
+		runTransitionFunction: transitionTo === void 0 ? void 0 : () => evaluateTransitionOutcome(transitionTo, snapshot.context, event, snapshot, actorScope, stateNode.machine.sources, candidate.source.id)
+	});
+	if (decision.type === "enabled" || decision.type === "disabled") selectionResults?.set(candidate, selectionResultOf(decision.selection));
+	return decision;
+}
+// src/StateNode.ts
+const EMPTY_OBJECT = {};
+/** @public */
+var StateNode = class StateNode {
+	config;
+	/**
+	* The relative key of the state node, which represents its location in the
+	* overall state value.
+	*/
+	key;
+	/** The unique ID of the state node. */
+	id;
+	/**
+	* 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
+	* - `'choice'` - pure routing decision state node
+	* - `'final'` - final state node
+	*/
+	type;
+	/** The string path from the root machine node to this node. */
+	path;
+	/** The child state nodes. */
+	states;
+	/**
+	* 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
+	*/
+	history;
+	/** The action(s) to be executed upon entering the state node. */
+	entry;
+	/** The action(s) to be executed upon exiting the state node. */
+	exit;
+	/** The parent state node. */
+	parent;
+	/** The root machine node. */
+	machine;
+	/**
+	* The meta data associated with this state node, which will be returned in
+	* State instances.
+	*/
+	meta;
+	/**
+	* The output data sent with the `xstate.done.state` event if this is a final
+	* state node.
+	*/
+	output;
+	/**
+	* The order this state node appears. Corresponds to the implicit document
+	* order.
+	*/
+	order = -1;
+	description;
+	schemas;
+	tags = [];
+	/** @internal */
+	_finalStateWarnings;
+	transitions;
+	always;
+	invoke;
+	on;
+	after;
+	events;
+	ownEvents;
+	_candidateCache;
+	constructor(config, options) {
+		this.config = config;
+		this.parent = options._parent;
+		this.key = options._key;
+		this.machine = options._machine;
+		this._finalStateWarnings = options._parent?._finalStateWarnings ?? [];
+		this.path = this.parent ? this.parent.path.concat(this.key) : [];
+		const firstStateKey = this.config.states ? Object.keys(this.config.states)[0] : void 0;
+		this.id = this.config.id || [this.machine.id, ...this.path].join(".");
+		this.type = this.config.type || (firstStateKey !== void 0 ? "compound" : this.config.history ? "history" : "atomic");
+		this.description = this.config.description;
+		this.schemas = this.config.schemas;
+		validateStateNodeConfig(this);
+		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}".`);
+		this.history = this.config.history === true ? "shallow" : this.config.history || false;
+		this.entry = this.config.entry;
+		this.exit = this.config.exit;
+		if (this.entry) this.entry._special = true;
+		if (this.exit) this.exit._special = true;
+		this.meta = this.config.meta;
+		this.output = this.type === "final" || !this.parent ? this.config.output : void 0;
+		this.tags = toArray(config.tags).slice();
+		this.invoke = toArray(this.config.invoke).map((invokeConfig, i) => {
+			const { src, registryKey } = invokeConfig;
+			const invokeId = createInvokeId(this.id, i);
+			const resolvedId = invokeConfig.id ?? invokeId;
+			const sourceName = typeof src === "string" ? src : `xstate.invoke.${invokeId}`;
+			return {
+				...invokeConfig,
+				src: sourceName,
+				logic: src,
+				id: resolvedId,
+				registryKey
+			};
+		});
+	}
+	/** @internal */
+	_initialize() {
+		this.after = getDelayedTransitions(this);
+		this.transitions = formatTransitions(this);
+		if (this.type === "choice") this.always = formatChoiceTransitions(this);
+		else if (this.config.always) this.always = mapTransitionConfigs(this.config.always, (transition) => formatTransition(this, "", transition));
+		for (const childState of Object.values(this.states)) childState._initialize();
+		this._refreshEventMetadata();
+	}
+	/** @internal */
+	_refreshEventMetadata() {
+		const on = {};
+		const ownEvents = [];
+		for (const [descriptor, transitions] of this.transitions) {
+			on[descriptor] = transitions.slice();
+			if (transitions.some((transition) => transition.target || transition.reenter || transition.to)) ownEvents.push(descriptor);
+		}
+		this.on = on;
+		this.ownEvents = ownEvents;
+		const events = new Set(ownEvents);
+		for (const state of Object.values(this.states)) for (const event of state.events) events.add(event);
+		this.events = Array.from(events);
+	}
+	get initial() {
+		return memo(this, "initial", () => formatInitialTransition(this, this.config.initial));
+	}
+	/** @internal */
+	next(snapshot, event, actorScope, selectionResults) {
+		if (this.type === "final") return;
+		const descriptorKey = getEventDescriptorKey(event);
+		let candidates = this._candidateCache?.get(descriptorKey);
+		if (!candidates) {
+			candidates = getCandidates(this, event, (message) => actorScope.warn(message));
+			(this._candidateCache ??= /* @__PURE__ */ new Map()).set(descriptorKey, candidates);
+		}
+		const admitted = firstAdmittedCandidate({
+			candidates,
+			admit: (candidate) => admitTransitionCandidate(candidate, event, snapshot, this, actorScope, selectionResults)
+		});
+		return admitted === void 0 ? void 0 : [admitted.candidate];
+	}
+};
+function validateStateNodeConfig(stateNode) {
+	const config = stateNode.config;
+	if (stateNode.type === "history" && !(typeof config.target === "string" && config.target.trim().length > 0 || Array.isArray(config.target) && config.target.length > 0 && config.target.every((target) => typeof target === "string" && target.trim().length > 0))) throw new Error(`Missing history target on "${stateNode.id}"`);
+	if (stateNode.type !== "choice") return;
+	if (typeof config.choice !== "function") throw new Error(`Missing \`choice\` function on "${stateNode.id}"`);
+}
+function formatChoiceTransitions(stateNode) {
+	const choice = stateNode.config.choice;
+	const validateChoiceResult = (result) => {
+		if (!result || result.target === void 0) throw new Error(`Choice "${stateNode.id}" has no target`);
+		return result;
+	};
+	return [formatTransition(stateNode, "", { to: (args) => validateChoiceResult(choice(args)) })];
+}
+function mapTransitionConfigs(transitionsConfig, mapper) {
+	return toTransitionConfigArray(transitionsConfig).map(mapper);
+}
+function formatTransitions(stateNode) {
+	const transitions = /* @__PURE__ */ new Map();
+	const addTransitions = (descriptor, additions) => {
+		transitions.set(descriptor, [...transitions.get(descriptor) ?? [], ...additions]);
+	};
+	if (stateNode.config.on) for (const descriptor of Object.keys(stateNode.config.on)) {
+		if (descriptor === "") throw new Error("Null event transition key");
+		const transitionsConfig = stateNode.config.on[descriptor];
+		transitions.set(descriptor, mapTransitionConfigs(transitionsConfig, (transition) => formatTransition(stateNode, descriptor, transition)));
+	}
+	if (stateNode.config.onDone) {
+		const descriptor = "xstate.done.state";
+		addTransitions(descriptor, mapTransitionConfigs(stateNode.config.onDone, (transition) => formatTransition(stateNode, descriptor, {
+			...transition,
+			matches: {
+				...transition.matches,
+				stateId: stateNode.id
+			}
+		})));
+	}
+	if (stateNode.config.onError) {
+		const descriptor = "xstate.error.*";
+		transitions.set(descriptor, mapTransitionConfigs(stateNode.config.onError, (transition) => formatTransition(stateNode, descriptor, transition)));
+	}
+	const createCancelInvokeTimeoutTransition = (descriptor, timeoutEventId, actorId) => formatTransition(stateNode, descriptor, {
+		matches: { actorId },
+		_eventMatcher: (event, snapshot) => matchesActorSession(event, snapshot, actorId),
+		to: (_args, enq) => {
+			enq.cancel(timeoutEventId);
+			return {};
+		}
+	});
+	const formatInvokeCompletionTransition = (descriptor, transitionConfig, timeoutEventId) => {
+		const { target, to, reenter, ...rest } = transitionConfig;
+		return formatTransition(stateNode, descriptor, {
+			...rest,
+			reenter,
+			to: (args, enq) => {
+				if (to) {
+					let didEnqueue = false;
+					const trackingEnqueue = new Proxy(enq, {
+						apply(target, thisArg, argArray) {
+							didEnqueue = true;
+							return Reflect.apply(target, thisArg, argArray);
+						},
+						get(target, prop, receiver) {
+							const value = Reflect.get(target, prop, receiver);
+							if (typeof value !== "function") return value;
+							return (...argArray) => {
+								didEnqueue = true;
+								return value.apply(target, argArray);
+							};
+						}
+					});
+					const result = to(args, trackingEnqueue);
+					if (result !== void 0 || didEnqueue) enq.cancel(timeoutEventId);
+					return result;
+				}
+				enq.cancel(timeoutEventId);
+				return {
+					target,
+					reenter
+				};
+			}
+		});
+	};
+	for (const invokeDef of stateNode.invoke) {
+		const withInvokeMatch = (transition) => ({
+			...transition,
+			matches: {
+				...transition.matches,
+				actorId: invokeDef.id
+			},
+			_eventMatcher: (event, snapshot) => matchesActorSession(event, snapshot, invokeDef.id)
+		});
+		const invokeTimeoutEventId = invokeDef.timeout !== void 0 ? createInvokeTimeoutEventId(invokeDef.id) : void 0;
+		if (invokeDef.onDone) {
+			const descriptor = "xstate.done.actor";
+			const invokeDoneTransitions = mapTransitionConfigs(invokeDef.onDone, (rawTransition) => {
+				const transition = withInvokeMatch(rawTransition);
+				return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : formatTransition(stateNode, descriptor, transition);
+			});
+			if (invokeTimeoutEventId) invokeDoneTransitions.push(createCancelInvokeTimeoutTransition(descriptor, invokeTimeoutEventId, invokeDef.id));
+			addTransitions(descriptor, invokeDoneTransitions);
+		} else if (invokeTimeoutEventId) {
+			const descriptor = "xstate.done.actor";
+			addTransitions(descriptor, [createCancelInvokeTimeoutTransition(descriptor, invokeTimeoutEventId, invokeDef.id)]);
+		}
+		if (invokeDef.onError) {
+			const descriptor = "xstate.error.actor";
+			addTransitions(descriptor, mapTransitionConfigs(invokeDef.onError, (rawTransition) => {
+				const transition = withInvokeMatch(rawTransition);
+				return invokeTimeoutEventId ? formatInvokeCompletionTransition(descriptor, transition, invokeTimeoutEventId) : formatTransition(stateNode, descriptor, transition);
+			}));
+		}
+		if (invokeDef.onSnapshot) {
+			const descriptor = "xstate.snapshot.actor";
+			addTransitions(descriptor, mapTransitionConfigs(invokeDef.onSnapshot, (transition) => formatTransition(stateNode, descriptor, withInvokeMatch(transition))));
+		}
+	}
+	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;
+}
+function formatInitialTransition(stateNode, _target) {
+	const targetString = typeof _target === "object" && _target !== null ? _target.target : _target;
+	const input = typeof _target === "object" && _target !== null ? _target.input : void 0;
+	const to = typeof _target === "object" && _target !== null ? _target.to : void 0;
+	const meta = typeof _target === "object" && _target !== null ? _target.meta : void 0;
+	const description = typeof _target === "object" && _target !== null ? _target.description : void 0;
+	const resolvedTargets = (Array.isArray(targetString) ? targetString : targetString ? [targetString] : []).map((target) => target.startsWith("#") ? stateNode.machine.getStateNodeById(target.slice(1)) : stateNode.states[target]);
+	if (resolvedTargets.some((target) => !target)) throw new Error(`Initial state not found on "#${stateNode.id}"`);
+	return {
+		source: stateNode,
+		target: resolvedTargets.length ? resolvedTargets : void 0,
+		input,
+		to,
+		meta,
+		description
+	};
+}
+// src/createActor.ts
+let executingCustomAction = false;
+/**
+* Marks a serialized object as an actor reference (`xstate$type` in JSON
+* output and persisted context).
+*/
+const ACTOR_REF_TYPE = "actorRef";
+const emptyInspectionRecords = Object.freeze([]);
+const defaultOptions = Object.freeze({
+	clock: {
+		setTimeout: (fn, ms) => {
+			return setTimeout(fn, ms);
+		},
+		clearTimeout: (id) => {
+			return clearTimeout(id);
+		}
+	},
+	logger: console.log.bind(console)
+});
+function safeCall(fn, arg, report) {
+	try {
+		fn?.(arg);
+	} catch (err) {
+		report(err);
+	}
+}
+function executeExecutableEffects(effects, actorScope) {
+	if (!effects?.length) return;
+	for (const effect of effects) actorScope.actionExecutor(effect);
+}
+function createActorRef(logic, options) {
+	return new Actor(logic, options);
+}
+/**
+* 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.
+*
+* An `Actor` is the concrete runtime instance with lifecycle methods and
+* system-owned internals. It also satisfies the narrower `ActorRef` contract,
+* so consumer APIs should accept `ActorRef` when they only need to send events
+* or read snapshots.
+*
+* @public
+*/
+var Actor = class {
+	logic;
+	/** The current internal state of the actor. */
+	_snapshot;
+	/**
+	* The clock that is responsible for setting and clearing timeouts, such as
+	* delayed events and transitions.
+	*/
+	clock;
+	wallClock;
+	options;
+	/** The unique identifier for this actor relative to its parent. */
+	id;
+	_boundProcess;
+	mailbox;
+	_mailboxStarted = false;
+	observers;
+	/** Whether a consumer subscribed to this actor's error after it errored. */
+	_errorObserved = false;
+	eventListeners;
+	logger;
+	warn;
+	/** @internal */
+	_processingStatus = 0;
+	_forceDeferredActions = false;
+	_parent;
+	/** @internal */
+	_syncSnapshot;
+	ref;
+	_actorScope;
+	/** @internal */
+	_lastSourceRef;
+	/** @internal */
+	_collectedMicrosteps;
+	/** @internal Actions executed during the in-flight transition. */
+	_collectedActions;
+	/** @internal Events relayed to other actors during the in-flight transition. */
+	_collectedSent;
+	_initialEffects;
+	registryKey;
+	/** The globally unique process ID for this invocation. */
+	sessionId;
+	_address;
+	/**
+	* The deterministic logical address of this actor within its system: the
+	* `/`-joined path of actor ids from the root. Stable across persistence and
+	* restore, unlike `sessionId`, which identifies one incarnation.
+	*
+	* `/` separates segments, so an id containing one (a state name with a
+	* slash reaches its invoked child's id) is percent-encoded to keep the
+	* path unambiguous.
+	*/
+	get address() {
+		return this._address ??= this._parent ? `${this._parent.address}/${encodeAddressSegment(this.id)}` : encodeAddressSegment(this.id);
+	}
+	/** The system to which this actor belongs. */
+	system;
+	_trigger;
+	get trigger() {
+		return this._trigger ??= new Proxy({}, { get: (_, eventType) => {
+			return (payload) => {
+				this.send({
+					...payload,
+					type: eventType
+				});
+			};
+		} });
+	}
+	_boundSend;
+	get send() {
+		return this._boundSend ??= this._sendPublic.bind(this);
+	}
+	src;
+	/**
+	* 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;
+		const resolvedOptions = options ? {
+			...defaultOptions,
+			...options
+		} : defaultOptions;
+		const { clock, wallClock, logger, warn, parent, syncSnapshot, id, registryKey, inspect } = resolvedOptions;
+		this.system = parent ? parent.system : resolvedOptions._systemRef?.current ?? createRuntimeSystem(this, {
+			clock,
+			wallClock,
+			crypto: resolvedOptions.crypto,
+			logger,
+			reportUnhandledError: resolvedOptions.reportUnhandledError,
+			warn: warn ?? defaultWarn,
+			snapshot: resolvedOptions.snapshot,
+			createActorRef
+		});
+		if (!parent && resolvedOptions._systemRef && !resolvedOptions._systemRef.current) resolvedOptions._systemRef.current = this.system;
+		if (inspect && !parent) this.system.inspect(toObserver(inspect));
+		if (resolvedOptions.onRejectedEvent && !parent) this.system.onRejectedEvent(resolvedOptions.onRejectedEvent);
+		this.sessionId = resolvedOptions._sessionId ?? bookSessionId(this.system);
+		this.id = resolveActorId(this.system, id, {
+			parent,
+			src: resolvedOptions.src ?? logic
+		});
+		this.logger = options?.logger ?? this.system._logger;
+		this.warn = options?.warn ?? this.system._warn;
+		this.clock = options?.clock ?? this.system._clock;
+		this.wallClock = options?.wallClock ?? this.system._wallClock;
+		this._parent = parent;
+		this._syncSnapshot = syncSnapshot;
+		this.options = resolvedOptions;
+		this.src = resolvedOptions.src ?? logic;
+		this.ref = this;
+		this._actorScope = this;
+		if (registryKey) {
+			this.registryKey = registryKey;
+			this.system._set(registryKey, this);
+		}
+		this._collectedMicrosteps = void 0;
+		const persistedState = options?.snapshot;
+		this._restored = persistedState !== void 0;
+		try {
+			if (persistedState) this._setSnapshot(this.logic.restoreSnapshot ? this.logic.restoreSnapshot(persistedState, this._actorScope) : persistedState);
+			else if (options?._inert) {} else {
+				const [snapshot, effects] = finalizeTransitionResult(this._actorScope, void 0, this.logic.initialTransition(this.options?.input, this._actorScope));
+				this._setSnapshot(snapshot);
+				this._initialEffects = effects.length ? effects : void 0;
+			}
+		} catch (err) {
+			const restoreErrorSnapshot = persistedState && this.logic._createRestoreErrorSnapshot?.(persistedState, err);
+			this._setSnapshot(restoreErrorSnapshot ?? {
+				status: "error",
+				output: void 0,
+				error: err
+			});
+			if (this._deferred) this._deferred.length = 0;
+		}
+		if (registryKey && this._snapshot.status !== "active") this.system._unregister(this);
+		if (this.system._hasInspectionObservers?.() ?? true) this.system._sendInspectionEvent({
+			type: "@xstate.actor",
+			actorRef: this,
+			parentRef: this._parent,
+			id: this.id,
+			src: this.src,
+			snapshot: this._snapshot
+		});
+	}
+	_deferred;
+	_restored = false;
+	/** @internal */
+	_getLogger() {
+		return this.logger;
+	}
+	get self() {
+		return this;
+	}
+	get defer() {
+		const defer = (fn) => this._defer(fn);
+		Object.defineProperty(this, "defer", { value: defer });
+		return defer;
+	}
+	get stopChild() {
+		const stopChild = (child) => this._stopChild(child);
+		Object.defineProperty(this, "stopChild", { value: stopChild });
+		return stopChild;
+	}
+	get emit() {
+		const emit = (event) => this.system.emitEvent(this, event);
+		Object.defineProperty(this, "emit", { value: emit });
+		return emit;
+	}
+	get actionExecutor() {
+		const actionExecutor = (action) => this._executeAction(action);
+		Object.defineProperty(this, "actionExecutor", { value: actionExecutor });
+		return actionExecutor;
+	}
+	/** @internal */
+	_isRunning() {
+		return this._processingStatus === 1;
+	}
+	/** @internal */
+	_defer(fn) {
+		(this._deferred ??= []).push(fn);
+	}
+	/** @internal */
+	_stopChild(child) {
+		if (child._parent !== this) throw new Error(`Cannot stop non-child actor ${child.id}`);
+		child._stop();
+	}
+	/** @internal */
+	_executeAction(action) {
+		const exec = () => {
+			if (this.system._hasInspectionObservers?.() ?? true) (this._collectedActions ??= []).push({
+				type: action.type,
+				params: action.params
+			});
+			const saveExecutingCustomAction = executingCustomAction;
+			try {
+				executingCustomAction = true;
+				const result = action.exec();
+				if (result && typeof result.then === "function") Promise.resolve(result).catch((err) => {
+					if (this._processingStatus === 2) return;
+					this._recoverOrError(err);
+				});
+			} finally {
+				executingCustomAction = saveExecutingCustomAction;
+			}
+		};
+		if (this._processingStatus === 1 && !this._forceDeferredActions) exec();
+		else (this._deferred ??= []).push(exec);
+	}
+	/** Associates each live snapshot with this actor for later pure transitions. */
+	_setSnapshot(snapshot) {
+		const previousSnapshot = this._snapshot;
+		this._snapshot = snapshot;
+		setSnapshotActorRef(snapshot, this, this.system, previousSnapshot);
+	}
+	_setErrorSnapshot(err, snapshot = this._snapshot) {
+		this._setSnapshot({
+			...snapshot,
+			status: "error",
+			error: err
+		});
+	}
+	/** Recover via the logic's error event if possible; otherwise error out. */
+	_recoverOrError(err, snapshot, previousSnapshot) {
+		if (this._tryHandleExecutionError(err, snapshot)) return true;
+		this._setErrorSnapshot(err);
+		this._error(err, previousSnapshot);
+		return false;
+	}
+	_tryHandleExecutionError(err, snapshot = this._snapshot) {
+		const errorEvent = this.logic.getExecutionErrorEvent?.(snapshot, err);
+		if (!errorEvent) return false;
+		try {
+			const [nextSnapshot, effects] = finalizeTransitionResult(this._actorScope, snapshot, this.logic.transition(snapshot, errorEvent, this._actorScope));
+			this._setSnapshot(nextSnapshot);
+			executeExecutableEffects(effects, this._actorScope);
+			this.update(nextSnapshot, errorEvent);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	_next(snapshot) {
+		for (const observer of this.observers ?? emptyInspectionRecords) safeCall(observer.next, snapshot, this.system._reportUnhandledError);
+	}
+	update(snapshot, event) {
+		this._setSnapshot(snapshot);
+		const deferred = this._deferred;
+		if (deferred) {
+			for (const deferredFn of deferred) try {
+				deferredFn();
+			} catch (err) {
+				deferred.length = 0;
+				if (this._tryHandleExecutionError(err, snapshot)) return;
+				this._setErrorSnapshot(err, snapshot);
+				this._error(err);
+				break;
+			}
+			deferred.length = 0;
+		}
+		switch (this._snapshot.status) {
+			case "active": this._next(snapshot);
+		}
+		this._inspectTransition(this._snapshot, event);
+	}
+	/** @internal Emits the transition inspection event; used by the pure
+	* `transition()` path for snapshots driven outside a live actor. */
+	_inspectTransition(snapshot, event) {
+		if (this.system._hasInspectionObservers?.() ?? true) this.system._sendInspectionEvent({
+			type: "@xstate.transition",
+			actorRef: this,
+			event,
+			sourceRef: this._lastSourceRef,
+			targetRef: this,
+			snapshot,
+			microsteps: this._collectedMicrosteps ?? emptyInspectionRecords,
+			actions: this._collectedActions ?? emptyInspectionRecords,
+			sent: this._collectedSent ?? emptyInspectionRecords,
+			eventType: event.type
+		});
+		this._collectedMicrosteps = void 0;
+		this._collectedActions = void 0;
+		this._collectedSent = void 0;
+	}
+	_flushInitialEffects() {
+		if (!this._initialEffects?.length) return true;
+		this._forceDeferredActions = true;
+		try {
+			executeExecutableEffects(this._initialEffects, this._actorScope);
+			this._initialEffects = void 0;
+			return true;
+		} catch (err) {
+			this._initialEffects = void 0;
+			if (this._deferred) this._deferred.length = 0;
+			this._recoverOrError(err);
+			return this._snapshot.status === "active";
+		} finally {
+			this._forceDeferredActions = false;
+		}
+	}
+	subscribe(nextListenerOrObserver, errorListener, completeListener) {
+		const observer = toObserver(nextListenerOrObserver, errorListener, completeListener);
+		if (this._processingStatus !== 2) (this.observers ??= /* @__PURE__ */ new Set()).add(observer);
+		else switch (this._snapshot.status) {
+			case "done":
+				safeCall(observer.complete, void 0, this.system._reportUnhandledError);
+				break;
+			case "error": {
+				const err = this._snapshot.error;
+				if (!observer.error) this.system._reportUnhandledError(err);
+				else {
+					if (!observer.passive) this._errorObserved = true;
+					safeCall(observer.error, err, this.system._reportUnhandledError);
+				}
+				break;
+			}
+		}
+		return { unsubscribe: () => {
+			this.observers?.delete(observer);
+		} };
+	}
+	on(type, handler) {
+		let listeners = this.eventListeners?.get(type);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			(this.eventListeners ??= /* @__PURE__ */ new Map()).set(type, listeners);
+		}
+		listeners.add(handler);
+		return { unsubscribe: () => {
+			listeners.delete(handler);
+		} };
+	}
+	select(selector, equalityFn = Object.is) {
+		return {
+			subscribe: (observerOrFn, errorListener, completeListener) => {
+				const observer = toObserver(observerOrFn, errorListener, completeListener);
+				let selected = selector(this.getSnapshot());
+				return this.subscribe({
+					next: (snapshot) => {
+						const next = selector(snapshot);
+						if (!equalityFn(selected, next)) {
+							selected = next;
+							observer.next?.(next);
+						}
+					},
+					...observer.error !== void 0 && { error: observer.error },
+					...observer.complete !== void 0 && { complete: observer.complete }
+				});
+			},
+			get: () => selector(this.getSnapshot())
+		};
+	}
+	/** Starts the Actor from the initial state */
+	start() {
+		if (this._processingStatus === 1) return this;
+		if (this._processingStatus === 2) {
+			const status = this._snapshot.status;
+			if (status === "done" || status === "error") return this;
+			throw new Error(`Actor ${this.id} was stopped and cannot be restarted. Create a new actor with createActor().`);
+		}
+		if (this._syncSnapshot) this.subscribe({
+			next: (snapshot) => {
+				if (snapshot.status === "active") this.system._relay(this, this._parent, {
+					type: "xstate.snapshot.actor",
+					actorId: this.id,
+					sessionId: this.sessionId,
+					snapshot
+				});
+			},
+			error: () => {}
+		});
+		this.system._register(this.sessionId, this);
+		if (this.registryKey) this.system._set(this.registryKey, this);
+		this._processingStatus = 1;
+		this._lastSourceRef = this._parent;
+		switch (this._snapshot.status) {
+			case "done":
+				if (this._restored) {
+					this._next(this._snapshot);
+					this._stopProcedure();
+					this._complete();
+					return this;
+				}
+				if (!this._flushInitialEffects()) return this;
+				this.update(this._snapshot, createInitEvent(this.options.input));
+				return this;
+			case "error":
+				this._error(this._snapshot.error);
+				return this;
+			case "stopped":
+				this._stopProcedure();
+				this._complete();
+				return this;
+		}
+		if (!this._parent) this.system.start();
+		if (!this._flushInitialEffects()) return this;
+		if (this.logic.start) try {
+			this.logic.start(this._snapshot, this._actorScope, { restored: this._restored });
+		} catch (err) {
+			this._setErrorSnapshot(err);
+			this._error(err);
+			return this;
+		}
+		if (!this._restored && !this._deferred?.length && !this.observers?.size && !(this.system._hasInspectionObservers?.() ?? true)) {
+			if (!refreshSnapshotActorRefRoot(this._snapshot, this, this.system)) this._setSnapshot(this._snapshot);
+			this._collectedMicrosteps = void 0;
+			this._collectedActions = void 0;
+			this._collectedSent = void 0;
+		} else this.update(this._snapshot, createInitEvent(this.options.input));
+		if (this._restored) {
+			const timers = this._snapshot.timers ?? {};
+			const isWallClock = !this.system._clock.now;
+			const now = this.wallClock.now();
+			for (const timer of Object.values(timers)) {
+				const delay = isWallClock && timer.startedAt !== void 0 ? Math.min(timer.delay, Math.max(0, timer.startedAt + timer.delay - now)) : timer.delay;
+				this.system.scheduleTimer(this, timer.id, delay);
+			}
+			this._restored = false;
+		}
+		this._mailboxStarted = true;
+		this.mailbox?.start();
+		return this;
+	}
+	_process(event) {
+		const previousSnapshot = this._snapshot;
+		let nextState;
+		let caughtError;
+		try {
+			nextState = finalizeTransitionResult(this._actorScope, this._snapshot, this.logic.transition(this._snapshot, event, this._actorScope));
+		} catch (err) {
+			caughtError = { err };
+		}
+		if (caughtError) {
+			this._collectedMicrosteps = void 0;
+			this._collectedActions = void 0;
+			this._collectedSent = void 0;
+			if (!this._recoverOrError(caughtError.err)) this._inspectTransition(this._snapshot, event);
+			return;
+		}
+		if (!nextState) return;
+		let snapshot = this._snapshot;
+		try {
+			const [nextSnapshot, effects] = nextState;
+			if (nextSnapshot === previousSnapshot && !effects.length && "machine" in previousSnapshot && !event.type.startsWith("xstate.")) this._reportUnhandledEvent(event);
+			snapshot = nextSnapshot;
+			this._setSnapshot(snapshot);
+			executeExecutableEffects(effects, this._actorScope);
+			this.update(snapshot, event);
+		} catch (err) {
+			if (!this._recoverOrError(err, snapshot, previousSnapshot)) this._inspectTransition(this._snapshot, event);
+			return;
+		}
+		if (event.type === "@xstate.stop") {
+			this._stopProcedure();
+			this._complete();
+		}
+	}
+	_warnedUnhandledTypes;
+	_reportUnhandledEvent(event) {
+		safeCall(() => this.options.onUnhandledEvent?.(event, this._snapshot), void 0, this.system._reportUnhandledError);
+	}
+	/** @internal */
+	_emit(event) {
+		for (const listeners of [this.eventListeners?.get(event.type), this.eventListeners?.get("*")]) if (listeners) for (const handler of listeners) safeCall(handler, event, this.system._reportUnhandledError);
+	}
+	/** @internal */
+	_terminate(termination) {
+		if (termination.status === "done") {
+			this._next(this._snapshot);
+			this._stopProcedure();
+			this._complete();
+			if (this._parent) this.system._relay(this, this._parent, createDoneActorEvent(this.id, termination.output, this.sessionId));
+			return;
+		}
+		if (termination.status === "error") this._error(termination.error);
+	}
+	/** @internal */
+	_stop() {
+		if (this._processingStatus === 2) return this;
+		this.mailbox?.clear();
+		if (this._processingStatus === 0) {
+			this._processingStatus = 2;
+			this.system._unregister(this);
+			return this;
+		}
+		this._send({ type: XSTATE_STOP });
+		this.system._unregister(this);
+		return this;
+	}
+	/** Stops the Actor and unsubscribe all listeners. */
+	stop() {
+		if (this._parent) throw new Error("A non-root actor cannot be stopped directly.");
+		return this._stop();
+	}
+	_complete() {
+		for (const observer of this.observers ?? emptyInspectionRecords) safeCall(observer.complete, void 0, this.system._reportUnhandledError);
+		this.observers?.clear();
+		this.eventListeners?.clear();
+	}
+	/**
+	* Reports an unhandled error unless a consumer observes it before the
+	* report runs. An actor can error before its creator has a chance to
+	* subscribe, so the check waits one macrotask for a subscriber with an
+	* `error` callback.
+	*/
+	_reportUnlessObserved(err) {
+		setTimeout(() => {
+			if (!this._errorObserved) this.system._reportUnhandledError(err);
+		});
+	}
+	_error(err, previousSnapshot) {
+		this._stopProcedure();
+		const children = /* @__PURE__ */ new Set();
+		for (const snapshot of [this._snapshot, previousSnapshot]) {
+			const snapshotChildren = snapshot?.children;
+			for (const child of Object.values(snapshotChildren ?? {})) if (child?._parent === this && typeof child.getSnapshot === "function") children.add(child);
+		}
+		for (const child of this.system._peekChildren?.()?.values() ?? []) if (child._parent === this) children.add(child);
+		for (const child of children) try {
+			if (child.getSnapshot().status !== "active") continue;
+			const result = this.system.stopActor(child);
+			if (result) Promise.resolve(result).catch(this.system._reportUnhandledError);
+		} catch (error) {
+			this.system._reportUnhandledError(error);
+		}
+		if (!this.observers?.size) {
+			if (!this._parent) this._reportUnlessObserved(err);
+		} else {
+			let reportError = false;
+			let handled = false;
+			for (const observer of this.observers) {
+				const errorListener = observer.error;
+				if (!observer.passive) {
+					reportError ||= !errorListener;
+					handled ||= !!errorListener;
+				}
+				safeCall(errorListener, err, this.system._reportUnhandledError);
+			}
+			reportError ||= !handled;
+			this.observers.clear();
+			if (reportError) this._reportUnlessObserved(err);
+		}
+		this.eventListeners?.clear();
+		if (this._parent) this.system._relay(this, this._parent, createErrorActorEvent(this.id, err, this.sessionId));
+	}
+	_stopProcedure() {
+		if (this._processingStatus !== 1) return;
+		this.system.cancelAllTimers(this);
+		this.mailbox?.clear();
+		this.mailbox = void 0;
+		this._boundProcess = void 0;
+		this._mailboxStarted = false;
+		this._processingStatus = 2;
+		this.system._unregister(this);
+	}
+	/** @internal */
+	_send(event) {
+		if (this._processingStatus === 2) {
+			this.system.deadLetter(this._lastSourceRef, this, event, "stopped");
+			return;
+		}
+		let mailbox = this.mailbox;
+		if (!mailbox) {
+			this._boundProcess ??= this._process.bind(this);
+			mailbox = this.mailbox = new Mailbox(this._boundProcess);
+			if (this._mailboxStarted) mailbox.start();
+		}
+		mailbox.enqueue(event);
+	}
+	/**
+	* Sends an event to the running Actor to trigger a transition.
+	*
+	* @param event The event to send
+	*/
+	_sendPublic(event) {
+		this.system._relay(void 0, this, event);
+	}
+	/**
+	* Returns the actor's serializable logical identity: its `id`, `address`,
+	* and registered source key (when the actor was created from one).
+	*/
+	toJSON() {
+		return {
+			xstate$type: ACTOR_REF_TYPE,
+			id: this.id,
+			address: this.address,
+			src: typeof this.src === "string" ? this.src : void 0
+		};
+	}
+	getPersistedSnapshot(options) {
+		return this.logic.getPersistedSnapshot(this._snapshot, options, this.warn);
+	}
+	[symbolObservable]() {
+		return this;
+	}
+	/**
+	* Read an actor’s snapshot synchronously.
+	*
+	* @remarks
+	* The snapshot is the last value the actor published, not a query of its
+	* private state: the actor emits a snapshot when it transitions, and this
+	* returns that cached last emission. The read is coherent within one
+	* synchronous transition turn because event processing runs to completion;
+	* across asynchronous boundaries it may be stale, like any observed value.
+	*
+	* Only co-located actors publish full snapshots. A location-transparent
+	* remote handle exposes lifecycle only (`{ status, output?, error? }`): while
+	* the handle exists among its parent's children the child is presumed
+	* `active`, and its terminal result arrives as a completion event.
+	*
+	* Note that some actors, such as callback actors generated with
+	* `createCallbackLogic`, will not emit snapshots.
+	* @see {@link Actor.(subscribe:1)} 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;
+	}
+};
+/**
+* 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 '@systemfsoftware/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:1)}. Other actor logic creators
+*   include {@link (createCallbackLogic:1)}, {@link (createEventObservableLogic:1)},
+*   {@link (createObservableLogic:1)}, {@link (createLogic:1)}, and
+*   {@link (createAsyncLogic:1)}.
+* @param options - Actor options
+* @public
+*/
+function createActor(logic, ...[options]) {
+	return new Actor(logic, options);
+}
+export { matchesState as $, executeEffects as A, createListenerLogic as B, createCustomEffect as C, createErrorPlatformEvent as Ct, createSpawnEffect as D, createSendToEffect as E, resolveActionsWithContext as F, isInertActorScope as G, systemLogicMetadata as H, takeSpawnAllocationCounters as I, createMachineSnapshot as J, setInertActorScopeSnapshot as K, resolveRegisteredActorSource as L, isBuiltInExecutableAction as M, mergeActorIdCounters as N, createStartEffect as O, reserveChildId as P, recordTimerStart as Q, createSubscriptionLogic as R, beginSpawnAllocation as S, createErrorActorEvent as St, createEmitEffect as T, createInvokeTimeoutEvent as Tt, attachSnapshotActorRef as U, listenerLogic as V, createInertActorScope as W, isMachineSnapshot as X, getPersistedSnapshot as Y, getTimerStart as Z, transitionNode as _, stopActor as _t, InfiniteTransitionError as a, parseDelayToMilliseconds as at, allocateChildId as b, withSystemInspector as bt, getProperAncestors as c, encodeAddressSegment as ct, getTransitionResult as d, parseGeneratedActorId as dt, pathToStateValue as et, hasEffect as f, withExecutionIdentity as ft, resolveStateValue as g, runStep as gt, macrostep as h, deliverEvent as ht, StateNode as i, isAtomicStateNode as it, finalizeTransitionResult as j, createTimerEffect as k, getStateNodeByPath as l, getActorIdPrefix as lt, isInFinalState as m, setSnapshotActorRef as mt, Actor as n, createRemoteActorRef as nt, formatRouteTransitions as o, withActorSelf as ot, initialMicrostep as p, getSnapshotActorRef as pt, cloneMachineSnapshot as q, createActor as r, isRemoteActorRef as rt, getAllStateNodes as s, RUNTIME_OPERATIONS as st, ACTOR_REF_TYPE as t, toStatePath as tt, getStateNodes as u, getRootActorId as ut, checkStateIn as v, terminateActor as vt, createDeadLetterEffect as w, createInitEvent as wt, assertChildIdFree as x, createDoneActorEvent as xt, isStateId as y, hasAmbientInspector as yt, subscriptionLogic as z };