@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/{xstate.esm-nY3M5UYm.esm.js → xstate.esm-Cf4e0Cfd.esm.js}

@@ -90,7 +90,7 @@ function createManager(options) {
 		currentErrorPayload = nextErrorPayload;
 	}) : void 0;
 	let isStopped = false;
-	const base = {
+	return Object.defineProperties({
 		getState,
 		subscribe,
 		stop() {
@@ -105,10 +105,8 @@ function createManager(options) {
 			instrumentation?.onModuleClosed(instrumentation.moduleName);
 			actor.stop();
 		}
-	};
-	return Object.defineProperties(base, Object.getOwnPropertyDescriptors(api));
+	}, Object.getOwnPropertyDescriptors(api));
 }
-
 //#endregion
 //#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dev/dist/xstate-dev.esm.js
 function getGlobal() {
@@ -126,7 +124,6 @@ const devToolsAdapter = (service) => {
 	const devTools = getDevTools();
 	if (devTools) devTools.register(service);
 };
-
 //#endregion
 //#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/raise-9ad1c5c6.esm.js
 var Mailbox = class {
@@ -169,13 +166,10 @@ var Mailbox = class {
 		this._last = null;
 	}
 };
-const STATE_DELIMITER = ".";
 const TARGETLESS_KEY = "";
-const NULL_EVENT = "";
 const STATE_IDENTIFIER = "#";
 const WILDCARD = "*";
 const XSTATE_INIT = "xstate.init";
-const XSTATE_ERROR = "xstate.error";
 const XSTATE_STOP = "xstate.stop";
 /**
 * Returns an event that represents an implicit event that is sent after the
@@ -310,11 +304,11 @@ function toArray(value) {
 	if (value === void 0) return [];
 	return toArrayStrict(value);
 }
-function resolveOutput(mapper, context, event, self$1) {
+function resolveOutput(mapper, context, event, self) {
 	if (typeof mapper === "function") return mapper({
 		context,
 		event,
-		self: self$1
+		self
 	});
 	return mapper;
 }
@@ -336,11 +330,11 @@ function normalizeTarget(target) {
 }
 function toObserver(nextHandler, errorHandler, completionHandler) {
 	const isObserver = typeof nextHandler === "object";
-	const self$1 = isObserver ? nextHandler : void 0;
+	const self = isObserver ? nextHandler : void 0;
 	return {
-		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self$1),
-		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self$1),
-		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self$1)
+		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
 	};
 }
 function createInvokeId(stateNodeId, index) {
@@ -376,11 +370,12 @@ function createSystem(rootActor, options) {
 			};
 			const scheduledEventId = createScheduledEventId(source, id);
 			system._snapshot._scheduledEvents[scheduledEventId] = scheduledEvent;
-			timerMap[scheduledEventId] = clock.setTimeout(() => {
+			const timeout = clock.setTimeout(() => {
 				delete timerMap[scheduledEventId];
 				delete system._snapshot._scheduledEvents[scheduledEventId];
 				system._relay(source, target, event);
 			}, delay);
+			timerMap[scheduledEventId] = timeout;
 		},
 		cancel: (source, id) => {
 			const scheduledEventId = createScheduledEventId(source, id);
@@ -466,12 +461,11 @@ function createSystem(rootActor, options) {
 	return system;
 }
 let executingCustomAction = false;
-const $$ACTOR_TYPE = 1;
-let ProcessingStatus = /* @__PURE__ */ function(ProcessingStatus$1) {
-	ProcessingStatus$1[ProcessingStatus$1["NotStarted"] = 0] = "NotStarted";
-	ProcessingStatus$1[ProcessingStatus$1["Running"] = 1] = "Running";
-	ProcessingStatus$1[ProcessingStatus$1["Stopped"] = 2] = "Stopped";
-	return ProcessingStatus$1;
+let ProcessingStatus = /*#__PURE__*/ function(ProcessingStatus) {
+	ProcessingStatus[ProcessingStatus["NotStarted"] = 0] = "NotStarted";
+	ProcessingStatus[ProcessingStatus["Running"] = 1] = "Running";
+	ProcessingStatus[ProcessingStatus["Stopped"] = 2] = "Stopped";
+	return ProcessingStatus;
 }({});
 const defaultOptions = {
 	clock: {
@@ -736,8 +730,8 @@ var Actor = class {
 				if (!observer.error) reportUnhandledError(err);
 				else try {
 					observer.error(err);
-				} catch (err$1) {
-					reportUnhandledError(err$1);
+				} catch (err) {
+					reportUnhandledError(err);
 				}
 				break;
 			}
@@ -824,7 +818,7 @@ var Actor = class {
 			return;
 		}
 		this.update(nextState, event);
-		if (event.type === XSTATE_STOP) {
+		if (event.type === "xstate.stop") {
 			this._stopProcedure();
 			this._complete();
 		}
@@ -903,7 +897,7 @@ var Actor = class {
 	}
 	toJSON() {
 		return {
-			xstate$$type: $$ACTOR_TYPE,
+			xstate$$type: 1,
 			id: this.id
 		};
 	}
@@ -1034,12 +1028,12 @@ function executeCancel(actorScope, params) {
 * @param sendId The `id` of the `sendTo(...)` action to cancel.
 */
 function cancel(sendId) {
-	function cancel$1(_args, _params) {}
-	cancel$1.type = "xstate.cancel";
-	cancel$1.sendId = sendId;
-	cancel$1.resolve = resolveCancel;
-	cancel$1.execute = executeCancel;
-	return cancel$1;
+	function cancel(_args, _params) {}
+	cancel.type = "xstate.cancel";
+	cancel.sendId = sendId;
+	cancel.resolve = resolveCancel;
+	cancel.execute = executeCancel;
+	return cancel;
 }
 function resolveSpawn(actorScope, snapshot, actionArgs, _actionParams, { id, systemId, src, input, syncSnapshot }) {
 	const logic = typeof src === "string" ? resolveReferencedActor(snapshot.machine, src) : src;
@@ -1084,16 +1078,16 @@ function executeSpawn(actorScope, { actorRef }) {
 	});
 }
 function spawnChild(...[src, { id, systemId, input, syncSnapshot = false } = {}]) {
-	function spawnChild$1(_args, _params) {}
-	spawnChild$1.type = "xstate.spawnChild";
-	spawnChild$1.id = id;
-	spawnChild$1.systemId = systemId;
-	spawnChild$1.src = src;
-	spawnChild$1.input = input;
-	spawnChild$1.syncSnapshot = syncSnapshot;
-	spawnChild$1.resolve = resolveSpawn;
-	spawnChild$1.execute = executeSpawn;
-	return spawnChild$1;
+	function spawnChild(_args, _params) {}
+	spawnChild.type = "xstate.spawnChild";
+	spawnChild.id = id;
+	spawnChild.systemId = systemId;
+	spawnChild.src = src;
+	spawnChild.input = input;
+	spawnChild.syncSnapshot = syncSnapshot;
+	spawnChild.resolve = resolveSpawn;
+	spawnChild.execute = executeSpawn;
+	return spawnChild;
 }
 function resolveStop(_, snapshot, args, actionParams, { actorRef }) {
 	const actorRefOrString = typeof actorRef === "function" ? actorRef(args, actionParams) : actorRef;
@@ -1126,12 +1120,12 @@ function executeStop(actorScope, actorRef) {
 * @param actorRef The actor to stop.
 */
 function stopChild(actorRef) {
-	function stop$1(_args, _params) {}
-	stop$1.type = "xstate.stopChild";
-	stop$1.actorRef = actorRef;
-	stop$1.resolve = resolveStop;
-	stop$1.execute = executeStop;
-	return stop$1;
+	function stop(_args, _params) {}
+	stop.type = "xstate.stopChild";
+	stop.actorRef = actorRef;
+	stop.resolve = resolveStop;
+	stop.execute = executeStop;
+	return stop;
 }
 function checkNot(snapshot, { context, event }, { guards }) {
 	return !evaluateGuard(guards[0], context, event, snapshot);
@@ -1166,12 +1160,12 @@ function checkNot(snapshot, { context, event }, { guards }) {
 * @returns A guard
 */
 function not(guard) {
-	function not$1(_args, _params) {
+	function not(_args, _params) {
 		return false;
 	}
-	not$1.check = checkNot;
-	not$1.guards = [guard];
-	return not$1;
+	not.check = checkNot;
+	not.guards = [guard];
+	return not;
 }
 function checkAnd(snapshot, { context, event }, { guards }) {
 	return guards.every((guard) => evaluateGuard(guard, context, event, snapshot));
@@ -1206,12 +1200,12 @@ function checkAnd(snapshot, { context, event }, { guards }) {
 * @returns A guard action object
 */
 function and(guards) {
-	function and$1(_args, _params) {
+	function and(_args, _params) {
 		return false;
 	}
-	and$1.check = checkAnd;
-	and$1.guards = guards;
-	return and$1;
+	and.check = checkAnd;
+	and.guards = guards;
+	return and;
 }
 function evaluateGuard(guard, context, event, snapshot) {
 	const { machine } = snapshot;
@@ -1367,7 +1361,7 @@ function formatTransition(stateNode, descriptor, transitionConfig) {
 function formatTransitions(stateNode) {
 	const transitions = /* @__PURE__ */ new Map();
 	if (stateNode.config.on) for (const descriptor of Object.keys(stateNode.config.on)) {
-		if (descriptor === NULL_EVENT) throw new Error("Null events (\"\") cannot be specified as a transition key. Use `always: { ... }` instead.");
+		if (descriptor === "") throw new Error("Null events (\"\") cannot be specified as a transition key. Use `always: { ... }` instead.");
 		const transitionsConfig = stateNode.config.on[descriptor];
 		transitions.set(descriptor, toTransitionConfigArray(transitionsConfig).map((t) => formatTransition(stateNode, descriptor, t)));
 	}
@@ -1421,7 +1415,7 @@ function resolveTarget(stateNode, targets) {
 	return targets.map((target) => {
 		if (typeof target !== "string") return target;
 		if (isStateId(target)) return stateNode.machine.getStateNodeById(target);
-		const isInternalTarget = target[0] === STATE_DELIMITER;
+		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 {
@@ -1779,7 +1773,7 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
 			continue;
 		}
 		const builtinAction = resolvedAction;
-		const [nextState, params, actions$1] = builtinAction.resolve(actorScope, intermediateSnapshot, actionArgs, actionParams, resolvedAction, extra);
+		const [nextState, params, actions] = builtinAction.resolve(actorScope, intermediateSnapshot, actionArgs, actionParams, resolvedAction, extra);
 		intermediateSnapshot = nextState;
 		if ("retryResolve" in builtinAction) retries?.push([builtinAction, params]);
 		if ("execute" in builtinAction) actorScope.actionExecutor({
@@ -1788,7 +1782,7 @@ function resolveAndExecuteActionsWithContext(currentSnapshot, event, actorScope,
 			params,
 			exec: builtinAction.execute.bind(null, actorScope, params)
 		});
-		if (actions$1) intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions$1, extra, retries);
+		if (actions) intermediateSnapshot = resolveAndExecuteActionsWithContext(intermediateSnapshot, event, actorScope, actions, extra, retries);
 	}
 	return intermediateSnapshot;
 }
@@ -1806,17 +1800,17 @@ function resolveActionsAndContext(currentSnapshot, event, actorScope, actions, i
 function macrostep(snapshot, event, actorScope, internalQueue) {
 	let nextSnapshot = snapshot;
 	const microstates = [];
-	function addMicrostate(microstate, event$1, transitions) {
+	function addMicrostate(microstate, event, transitions) {
 		actorScope.system._sendInspectionEvent({
 			type: "@xstate.microstep",
 			actorRef: actorScope.self,
-			event: event$1,
+			event,
 			snapshot: microstate,
 			_transitions: transitions
 		});
 		microstates.push(microstate);
 	}
-	if (event.type === XSTATE_STOP) {
+	if (event.type === "xstate.stop") {
 		nextSnapshot = cloneMachineSnapshot(stopChildren(nextSnapshot, event, actorScope), { status: "stopped" });
 		addMicrostate(nextSnapshot, event, []);
 		return {
@@ -1903,7 +1897,7 @@ const machineSnapshotCan = function can(event) {
 	return !!transitionData?.length && transitionData.some((t) => t.target !== void 0 || t.actions.length);
 };
 const machineSnapshotToJSON = function toJSON() {
-	const { _nodes: nodes, tags, machine, getMeta, toJSON: toJSON$1, can, hasTag, matches, ...jsonValues } = this;
+	const { _nodes: nodes, tags, machine, getMeta, toJSON, can, hasTag, matches, ...jsonValues } = this;
 	return {
 		...jsonValues,
 		tags: Array.from(tags)
@@ -1975,7 +1969,7 @@ function persistContext(contextPart) {
 		if (value && typeof value === "object") if ("sessionId" in value && "send" in value && "ref" in value) {
 			copy ??= Array.isArray(contextPart) ? contextPart.slice() : { ...contextPart };
 			copy[key] = {
-				xstate$$type: $$ACTOR_TYPE,
+				xstate$$type: 1,
 				id: value.id
 			};
 		} else {
@@ -2012,8 +2006,8 @@ function executeRaise(actorScope, params) {
 	const { event, delay, id } = params;
 	if (typeof delay === "number") {
 		actorScope.defer(() => {
-			const self$1 = actorScope.self;
-			actorScope.system.scheduler.schedule(self$1, self$1, event, delay, id);
+			const self = actorScope.self;
+			actorScope.system.scheduler.schedule(self, self, event, delay, id);
 		});
 		return;
 	}
@@ -2025,480 +2019,15 @@ function executeRaise(actorScope, params) {
 * @param eventType The event to raise.
 */
 function raise(eventOrExpr, options) {
-	function raise$1(_args, _params) {}
-	raise$1.type = "xstate.raise";
-	raise$1.event = eventOrExpr;
-	raise$1.id = options?.id;
-	raise$1.delay = options?.delay;
-	raise$1.resolve = resolveRaise;
-	raise$1.execute = executeRaise;
-	return raise$1;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/actors/dist/xstate-actors.esm.js
-/**
-* Represents an actor created by `fromTransition`.
-*
-* The type of `self` within the actor's logic.
-*
-* @example
-*
-* ```ts
-* import {
-*   fromTransition,
-*   createActor,
-*   type AnyActorSystem
-* } from 'xstate';
-*
-* //* The actor's stored context.
-* type Context = {
-*   // The current count.
-*   count: number;
-*   // The amount to increase `count` by.
-*   step: number;
-* };
-* // The events the actor receives.
-* type Event = { type: 'increment' };
-* // The actor's input.
-* type Input = { step?: number };
-*
-* // Actor logic that increments `count` by `step` when it receives an event of
-* // type `increment`.
-* const logic = fromTransition<Context, Event, AnyActorSystem, Input>(
-*   (state, event, actorScope) => {
-*     actorScope.self;
-*     //         ^? TransitionActorRef<Context, Event>
-*
-*     if (event.type === 'increment') {
-*       return {
-*         ...state,
-*         count: state.count + state.step
-*       };
-*     }
-*     return state;
-*   },
-*   ({ input, self }) => {
-*     self;
-*     // ^? TransitionActorRef<Context, Event>
-*
-*     return {
-*       count: 0,
-*       step: input.step ?? 1
-*     };
-*   }
-* );
-*
-* const actor = createActor(logic, { input: { step: 10 } });
-* //    ^? TransitionActorRef<Context, Event>
-* ```
-*
-* @see {@link fromTransition}
-*/
-/**
-* Returns actor logic given a transition function and its initial state.
-*
-* A “transition function” is a function that takes the current `state` and
-* received `event` object as arguments, and returns the next state, similar to
-* a reducer.
-*
-* Actors created from transition logic (“transition actors”) can:
-*
-* - Receive events
-* - Emit snapshots of its state
-*
-* The transition function’s `state` is used as its transition actor’s
-* `context`.
-*
-* Note that the "state" for a transition function is provided by the initial
-* state argument, and is not the same as the State object of an actor or a
-* state within a machine configuration.
-*
-* @example
-*
-* ```ts
-* const transitionLogic = fromTransition(
-*   (state, event) => {
-*     if (event.type === 'increment') {
-*       return {
-*         ...state,
-*         count: state.count + 1
-*       };
-*     }
-*     return state;
-*   },
-*   { count: 0 }
-* );
-*
-* const transitionActor = createActor(transitionLogic);
-* transitionActor.subscribe((snapshot) => {
-*   console.log(snapshot);
-* });
-* transitionActor.start();
-* // => {
-* //   status: 'active',
-* //   context: { count: 0 },
-* //   ...
-* // }
-*
-* transitionActor.send({ type: 'increment' });
-* // => {
-* //   status: 'active',
-* //   context: { count: 1 },
-* //   ...
-* // }
-* ```
-*
-* @param transition The transition function used to describe the transition
-*   logic. It should return the next state given the current state and event.
-*   It receives the following arguments:
-*
-*   - `state` - the current state.
-*   - `event` - the received event.
-*   - `actorScope` - the actor scope object, with properties like `self` and
-*       `system`.
-*
-* @param initialContext The initial state of the transition function, either an
-*   object representing the state, or a function which returns a state object.
-*   If a function, it will receive as its only argument an object with the
-*   following properties:
-*
-*   - `input` - the `input` provided to its parent transition actor.
-*   - `self` - a reference to its parent transition actor.
-*
-* @returns Actor logic
-* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
-*/
-function fromTransition(transition, initialContext) {
-	return {
-		config: transition,
-		transition: (snapshot, event, actorScope) => {
-			return {
-				...snapshot,
-				context: transition(snapshot.context, event, actorScope)
-			};
-		},
-		getInitialSnapshot: (_, input) => {
-			return {
-				status: "active",
-				output: void 0,
-				error: void 0,
-				context: typeof initialContext === "function" ? initialContext({ input }) : initialContext
-			};
-		},
-		getPersistedSnapshot: (snapshot) => snapshot,
-		restoreSnapshot: (snapshot) => snapshot
-	};
-}
-const instanceStates = /* @__PURE__ */ new WeakMap();
-/**
-* Represents an actor created by `fromCallback`.
-*
-* The type of `self` within the actor's logic.
-*
-* @example
-*
-* ```ts
-* import { fromCallback, createActor } from 'xstate';
-*
-* // The events the actor receives.
-* type Event = { type: 'someEvent' };
-* // The actor's input.
-* type Input = { name: string };
-*
-* // Actor logic that logs whenever it receives an event of type `someEvent`.
-* const logic = fromCallback<Event, Input>(({ self, input, receive }) => {
-*   self;
-*   // ^? CallbackActorRef<Event, Input>
-*
-*   receive((event) => {
-*     if (event.type === 'someEvent') {
-*       console.log(`${input.name}: received "someEvent" event`);
-*       // logs 'myActor: received "someEvent" event'
-*     }
-*   });
-* });
-*
-* const actor = createActor(logic, { input: { name: 'myActor' } });
-* //    ^? CallbackActorRef<Event, Input>
-* ```
-*
-* @see {@link fromCallback}
-*/
-/**
-* An actor logic creator which returns callback logic as defined by a callback
-* function.
-*
-* @remarks
-* Useful for subscription-based or other free-form logic that can send events
-* back to the parent actor.
-*
-* Actors created from callback logic (“callback actors”) can:
-*
-* - Receive events via the `receive` function
-* - Send events to the parent actor via the `sendBack` function
-*
-* Callback actors are a bit different from other actors in that they:
-*
-* - Do not work with `onDone`
-* - Do not produce a snapshot using `.getSnapshot()`
-* - Do not emit values when used with `.subscribe()`
-* - Can not be stopped with `.stop()`
-*
-* @example
-*
-* ```typescript
-* const callbackLogic = fromCallback(({ sendBack, receive }) => {
-*   let lockStatus = 'unlocked';
-*
-*   const handler = (event) => {
-*     if (lockStatus === 'locked') {
-*       return;
-*     }
-*     sendBack(event);
-*   };
-*
-*   receive((event) => {
-*     if (event.type === 'lock') {
-*       lockStatus = 'locked';
-*     } else if (event.type === 'unlock') {
-*       lockStatus = 'unlocked';
-*     }
-*   });
-*
-*   document.body.addEventListener('click', handler);
-*
-*   return () => {
-*     document.body.removeEventListener('click', handler);
-*   };
-* });
-* ```
-*
-* @param callback - The callback function used to describe the callback logic
-*   The callback function is passed an object with the following properties:
-*
-*   - `receive` - A function that can send events back to the parent actor; the
-*       listener is then called whenever events are received by the callback
-*       actor
-*   - `sendBack` - A function that can send events back to the parent actor
-*   - `input` - Data that was provided to the callback actor
-*   - `self` - The parent actor of the callback actor
-*   - `system` - The actor system to which the callback actor belongs The callback
-*       function can (optionally) return a cleanup function, which is called
-*       when the actor is stopped.
-*
-* @returns Callback logic
-* @see {@link CallbackLogicFunction} for more information about the callback function and its object argument
-* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
-*/
-function fromCallback(callback) {
-	return {
-		config: callback,
-		start: (state, actorScope) => {
-			const { self: self$1, system, emit: emit$1 } = actorScope;
-			const callbackState = {
-				receivers: void 0,
-				dispose: void 0
-			};
-			instanceStates.set(self$1, callbackState);
-			callbackState.dispose = callback({
-				input: state.input,
-				system,
-				self: self$1,
-				sendBack: (event) => {
-					if (self$1.getSnapshot().status === "stopped") return;
-					if (self$1._parent) system._relay(self$1, self$1._parent, event);
-				},
-				receive: (listener) => {
-					callbackState.receivers ??= /* @__PURE__ */ new Set();
-					callbackState.receivers.add(listener);
-				},
-				emit: emit$1
-			});
-		},
-		transition: (state, event, actorScope) => {
-			const callbackState = instanceStates.get(actorScope.self);
-			if (event.type === XSTATE_STOP) {
-				state = {
-					...state,
-					status: "stopped",
-					error: void 0
-				};
-				callbackState.dispose?.();
-				return state;
-			}
-			callbackState.receivers?.forEach((receiver) => receiver(event));
-			return state;
-		},
-		getInitialSnapshot: (_, input) => {
-			return {
-				status: "active",
-				output: void 0,
-				error: void 0,
-				input
-			};
-		},
-		getPersistedSnapshot: (snapshot) => snapshot,
-		restoreSnapshot: (snapshot) => snapshot
-	};
+	function raise(_args, _params) {}
+	raise.type = "xstate.raise";
+	raise.event = eventOrExpr;
+	raise.id = options?.id;
+	raise.delay = options?.delay;
+	raise.resolve = resolveRaise;
+	raise.execute = executeRaise;
+	return raise;
 }
-const XSTATE_PROMISE_RESOLVE = "xstate.promise.resolve";
-const XSTATE_PROMISE_REJECT = "xstate.promise.reject";
-/**
-* Represents an actor created by `fromPromise`.
-*
-* The type of `self` within the actor's logic.
-*
-* @example
-*
-* ```ts
-* import { fromPromise, createActor } from 'xstate';
-*
-* // The actor's resolved output
-* type Output = string;
-* // The actor's input.
-* type Input = { message: string };
-*
-* // Actor logic that fetches the url of an image of a cat saying `input.message`.
-* const logic = fromPromise<Output, Input>(async ({ input, self }) => {
-*   self;
-*   // ^? PromiseActorRef<Output, Input>
-*
-*   const data = await fetch(
-*     `https://cataas.com/cat/says/${input.message}`
-*   );
-*   const url = await data.json();
-*   return url;
-* });
-*
-* const actor = createActor(logic, { input: { message: 'hello world' } });
-* //    ^? PromiseActorRef<Output, Input>
-* ```
-*
-* @see {@link fromPromise}
-*/
-const controllerMap = /* @__PURE__ */ new WeakMap();
-/**
-* An actor logic creator which returns promise logic as defined by an async
-* process that resolves or rejects after some time.
-*
-* Actors created from promise actor logic (“promise actors”) can:
-*
-* - Emit the resolved value of the promise
-* - Output the resolved value of the promise
-*
-* Sending events to promise actors will have no effect.
-*
-* @example
-*
-* ```ts
-* const promiseLogic = fromPromise(async () => {
-*   const result = await fetch('https://example.com/...').then((data) =>
-*     data.json()
-*   );
-*
-*   return result;
-* });
-*
-* const promiseActor = createActor(promiseLogic);
-* promiseActor.subscribe((snapshot) => {
-*   console.log(snapshot);
-* });
-* promiseActor.start();
-* // => {
-* //   output: undefined,
-* //   status: 'active'
-* //   ...
-* // }
-*
-* // After promise resolves
-* // => {
-* //   output: { ... },
-* //   status: 'done',
-* //   ...
-* // }
-* ```
-*
-* @param promiseCreator A function which returns a Promise, and accepts an
-*   object with the following properties:
-*
-*   - `input` - Data that was provided to the promise actor
-*   - `self` - The parent actor of the promise actor
-*   - `system` - The actor system to which the promise actor belongs
-*
-* @see {@link https://stately.ai/docs/input | Input docs} for more information about how input is passed
-*/
-function fromPromise(promiseCreator) {
-	return {
-		config: promiseCreator,
-		transition: (state, event, scope) => {
-			if (state.status !== "active") return state;
-			switch (event.type) {
-				case XSTATE_PROMISE_RESOLVE: {
-					const resolvedValue = event.data;
-					return {
-						...state,
-						status: "done",
-						output: resolvedValue,
-						input: void 0
-					};
-				}
-				case XSTATE_PROMISE_REJECT: return {
-					...state,
-					status: "error",
-					error: event.data,
-					input: void 0
-				};
-				case XSTATE_STOP:
-					controllerMap.get(scope.self)?.abort();
-					return {
-						...state,
-						status: "stopped",
-						input: void 0
-					};
-				default: return state;
-			}
-		},
-		start: (state, { self: self$1, system, emit: emit$1 }) => {
-			if (state.status !== "active") return;
-			const controller = new AbortController();
-			controllerMap.set(self$1, controller);
-			Promise.resolve(promiseCreator({
-				input: state.input,
-				system,
-				self: self$1,
-				signal: controller.signal,
-				emit: emit$1
-			})).then((response) => {
-				if (self$1.getSnapshot().status !== "active") return;
-				controllerMap.delete(self$1);
-				system._relay(self$1, self$1, {
-					type: XSTATE_PROMISE_RESOLVE,
-					data: response
-				});
-			}, (errorData) => {
-				if (self$1.getSnapshot().status !== "active") return;
-				controllerMap.delete(self$1);
-				system._relay(self$1, self$1, {
-					type: XSTATE_PROMISE_REJECT,
-					data: errorData
-				});
-			});
-		},
-		getInitialSnapshot: (_, input) => {
-			return {
-				status: "active",
-				output: void 0,
-				error: void 0,
-				input
-			};
-		},
-		getPersistedSnapshot: (snapshot) => snapshot,
-		restoreSnapshot: (snapshot) => snapshot
-	};
-}
-const emptyLogic = fromTransition((_) => void 0, void 0);
-
 //#endregion
 //#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/assign-ab9cc19e.esm.js
 function createSpawner(actorScope, { machine, context }, event, spawnedChildren) {
@@ -2602,13 +2131,12 @@ function resolveAssign(actorScope, snapshot, actionArgs, actionParams, { assignm
 *   update.
 */
 function assign(assignment) {
-	function assign$1(_args, _params) {}
-	assign$1.type = "xstate.assign";
-	assign$1.assignment = assignment;
-	assign$1.resolve = resolveAssign;
-	return assign$1;
+	function assign(_args, _params) {}
+	assign.type = "xstate.assign";
+	assign.assignment = assignment;
+	assign.resolve = resolveAssign;
+	return assign;
 }
-
 //#endregion
 //#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/StateMachine-37bc3882.esm.js
 const cache = /* @__PURE__ */ new WeakMap();
@@ -2691,7 +2219,7 @@ var StateNode = class StateNode {
 		this.key = options._key;
 		this.machine = options._machine;
 		this.path = this.parent ? this.parent.path.concat(this.key) : [];
-		this.id = this.config.id || [this.machine.id, ...this.path].join(STATE_DELIMITER);
+		this.id = this.config.id || [this.machine.id, ...this.path].join(".");
 		this.type = this.config.type || (this.config.states && Object.keys(this.config.states).length ? "compound" : this.config.history ? "history" : "atomic");
 		this.description = this.config.description;
 		this.order = this.machine.idMap.size;
@@ -2714,7 +2242,7 @@ var StateNode = class StateNode {
 	/** @internal */
 	_initialize() {
 		this.transitions = formatTransitions(this);
-		if (this.config.always) this.always = toTransitionConfigArray(this.config.always).map((t) => formatTransition(this, NULL_EVENT, t));
+		if (this.config.always) this.always = toTransitionConfigArray(this.config.always).map((t) => formatTransition(this, "", t));
 		Object.keys(this.states).forEach((key) => {
 			this.states[key]._initialize();
 		});
@@ -2788,7 +2316,7 @@ var StateNode = class StateNode {
 	/** The mapping of events to transitions. */
 	get on() {
 		return memo(this, "on", () => {
-			return [...this.transitions].flatMap(([descriptor, t]) => t.map((t$1) => [descriptor, t$1])).reduce((map, [descriptor, transition]) => {
+			return [...this.transitions].flatMap(([descriptor, t]) => t.map((t) => [descriptor, t])).reduce((map, [descriptor, transition]) => {
 				map[descriptor] = map[descriptor] || [];
 				map[descriptor].push(transition);
 				return map;
@@ -2963,10 +2491,10 @@ var StateMachine = class StateMachine {
 			status: "active"
 		}, this);
 		if (typeof context === "function") {
-			const assignment = ({ spawn, event, self: self$1 }) => context({
+			const assignment = ({ spawn, event, self }) => context({
 				spawn,
 				input: event.input,
-				self: self$1
+				self
 			});
 			return resolveActionsAndContext(preInitial, initEvent, actorScope, [assign(assignment)], internalQueue, void 0);
 		}
@@ -3021,7 +2549,7 @@ var StateMachine = class StateMachine {
 			const src = actorData.src;
 			const logic = typeof src === "string" ? resolveReferencedActor(this, src) : src;
 			if (!logic) return;
-			children[actorId] = createActor(logic, {
+			const actorRef = createActor(logic, {
 				id: actorId,
 				parent: _actorScope.self,
 				syncSnapshot: actorData.syncSnapshot,
@@ -3029,6 +2557,7 @@ var StateMachine = class StateMachine {
 				src,
 				systemId: actorData.systemId
 			});
+			children[actorId] = actorRef;
 		});
 		function resolveHistoryReferencedState(root, referenced) {
 			if (referenced instanceof StateNode) return referenced;
@@ -3058,17 +2587,17 @@ var StateMachine = class StateMachine {
 			historyValue: revivedHistoryValue
 		}, this);
 		const seen = /* @__PURE__ */ new Set();
-		function reviveContext(contextPart, children$1) {
+		function reviveContext(contextPart, children) {
 			if (seen.has(contextPart)) return;
 			seen.add(contextPart);
 			for (const key in contextPart) {
 				const value = contextPart[key];
 				if (value && typeof value === "object") {
-					if ("xstate$$type" in value && value.xstate$$type === $$ACTOR_TYPE) {
-						contextPart[key] = children$1[value.id];
+					if ("xstate$$type" in value && value.xstate$$type === 1) {
+						contextPart[key] = children[value.id];
 						continue;
 					}
-					reviveContext(value, children$1);
+					reviveContext(value, children);
 				}
 			}
 		}
@@ -3076,7 +2605,6 @@ var StateMachine = class StateMachine {
 		return restoredSnapshot;
 	}
 };
-
 //#endregion
 //#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/log-7cbae384.esm.js
 function resolveEmit(_, snapshot, args, actionParams, { event: eventOrExpr }) {
@@ -3126,12 +2654,12 @@ function executeEmit(actorScope, { event }) {
 * ```
 */
 function emit(eventOrExpr) {
-	function emit$1(_args, _params) {}
-	emit$1.type = "xstate.emit";
-	emit$1.event = eventOrExpr;
-	emit$1.resolve = resolveEmit;
-	emit$1.execute = executeEmit;
-	return emit$1;
+	function emit(_args, _params) {}
+	emit.type = "xstate.emit";
+	emit.event = eventOrExpr;
+	emit.resolve = resolveEmit;
+	emit.execute = executeEmit;
+	return emit;
 }
 /**
 * @remarks
@@ -3162,10 +2690,10 @@ function emit(eventOrExpr) {
 */
 /** @deprecated Use `AnyMachineSnapshot` instead */
 /** @ignore */
-let SpecialTargets = /* @__PURE__ */ function(SpecialTargets$1) {
-	SpecialTargets$1["Parent"] = "#_parent";
-	SpecialTargets$1["Internal"] = "#_internal";
-	return SpecialTargets$1;
+let SpecialTargets = /*#__PURE__*/ function(SpecialTargets) {
+	SpecialTargets["Parent"] = "#_parent";
+	SpecialTargets["Internal"] = "#_internal";
+	return SpecialTargets;
 }({});
 /** @deprecated Use `AnyActor` instead. */
 /** @deprecated Use `Actor<T>` instead. */
@@ -3218,7 +2746,7 @@ function executeSendTo(actorScope, params) {
 			actorScope.system.scheduler.schedule(actorScope.self, to, event, delay, id);
 			return;
 		}
-		actorScope.system._relay(actorScope.self, to, event.type === XSTATE_ERROR ? createErrorActorEvent(actorScope.self.id, event.data) : event);
+		actorScope.system._relay(actorScope.self, to, event.type === "xstate.error" ? createErrorActorEvent(actorScope.self.id, event.data) : event);
 	});
 }
 /**
@@ -3233,16 +2761,16 @@ function executeSendTo(actorScope, params) {
 *   - `delay` - The number of milliseconds to delay the sending of the event.
 */
 function sendTo(to, eventOrExpr, options) {
-	function sendTo$1(_args, _params) {}
-	sendTo$1.type = "xstate.sendTo";
-	sendTo$1.to = to;
-	sendTo$1.event = eventOrExpr;
-	sendTo$1.id = options?.id;
-	sendTo$1.delay = options?.delay;
-	sendTo$1.resolve = resolveSendTo;
-	sendTo$1.retryResolve = retryResolveSendTo;
-	sendTo$1.execute = executeSendTo;
-	return sendTo$1;
+	function sendTo(_args, _params) {}
+	sendTo.type = "xstate.sendTo";
+	sendTo.to = to;
+	sendTo.event = eventOrExpr;
+	sendTo.id = options?.id;
+	sendTo.delay = options?.delay;
+	sendTo.resolve = resolveSendTo;
+	sendTo.retryResolve = retryResolveSendTo;
+	sendTo.execute = executeSendTo;
+	return sendTo;
 }
 /**
 * Sends an event to this machine's parent.
@@ -3255,32 +2783,32 @@ function sendParent(event, options) {
 }
 function resolveEnqueueActions(actorScope, snapshot, args, actionParams, { collect }) {
 	const actions = [];
-	const enqueue = function enqueue$1(action) {
+	const enqueue = function enqueue(action) {
 		actions.push(action);
 	};
-	enqueue.assign = (...args$1) => {
-		actions.push(assign(...args$1));
+	enqueue.assign = (...args) => {
+		actions.push(assign(...args));
 	};
-	enqueue.cancel = (...args$1) => {
-		actions.push(cancel(...args$1));
+	enqueue.cancel = (...args) => {
+		actions.push(cancel(...args));
 	};
-	enqueue.raise = (...args$1) => {
-		actions.push(raise(...args$1));
+	enqueue.raise = (...args) => {
+		actions.push(raise(...args));
 	};
-	enqueue.sendTo = (...args$1) => {
-		actions.push(sendTo(...args$1));
+	enqueue.sendTo = (...args) => {
+		actions.push(sendTo(...args));
 	};
-	enqueue.sendParent = (...args$1) => {
-		actions.push(sendParent(...args$1));
+	enqueue.sendParent = (...args) => {
+		actions.push(sendParent(...args));
 	};
-	enqueue.spawnChild = (...args$1) => {
-		actions.push(spawnChild(...args$1));
+	enqueue.spawnChild = (...args) => {
+		actions.push(spawnChild(...args));
 	};
-	enqueue.stopChild = (...args$1) => {
-		actions.push(stopChild(...args$1));
+	enqueue.stopChild = (...args) => {
+		actions.push(stopChild(...args));
 	};
-	enqueue.emit = (...args$1) => {
-		actions.push(emit(...args$1));
+	enqueue.emit = (...args) => {
+		actions.push(emit(...args));
 	};
 	collect({
 		context: args.context,
@@ -3319,11 +2847,11 @@ function resolveEnqueueActions(actorScope, snapshot, args, actionParams, { colle
 * ```
 */
 function enqueueActions(collect) {
-	function enqueueActions$1(_args, _params) {}
-	enqueueActions$1.type = "xstate.enqueueActions";
-	enqueueActions$1.collect = collect;
-	enqueueActions$1.resolve = resolveEnqueueActions;
-	return enqueueActions$1;
+	function enqueueActions(_args, _params) {}
+	enqueueActions.type = "xstate.enqueueActions";
+	enqueueActions.collect = collect;
+	enqueueActions.resolve = resolveEnqueueActions;
+	return enqueueActions;
 }
 function resolveLog(_, snapshot, actionArgs, actionParams, { value, label }) {
 	return [
@@ -3352,15 +2880,14 @@ function log(value = ({ context, event }) => ({
 	context,
 	event
 }), label) {
-	function log$1(_args, _params) {}
-	log$1.type = "xstate.log";
-	log$1.value = value;
-	log$1.label = label;
-	log$1.resolve = resolveLog;
-	log$1.execute = executeLog;
-	return log$1;
-}
-
+	function log(_args, _params) {}
+	log.type = "xstate.log";
+	log.value = value;
+	log.label = label;
+	log.resolve = resolveLog;
+	log.execute = executeLog;
+	return log;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/xstate@5.24.0/node_modules/xstate/dist/xstate.esm.js
 /**
@@ -3448,6 +2975,5 @@ function setup({ schemas, actors, actions, guards, delays }) {
 		})
 	};
 }
-
 //#endregion
-export { fromPromise as a, not as c, fromCallback as i, createManager as l, sendTo as n, and as o, assign as r, createActor as s, setup as t };
+export { and as a, createManager as c, XSTATE_STOP as i, sendTo as n, createActor as o, assign as r, not as s, setup as t };