small-state 0.0.0-stage → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,1748 @@
+import { type } from "arktype";
+//#endregion
+//#region src/shared/utils.ts
+function ensureArray(v) {
+	return Array.isArray(v) ? v : !v ? [] : [v];
+}
+function assertOrThrow(validCondition, msg) {
+	if (!validCondition) throw new Error(msg);
+	return true;
+}
+function reportUnhandledError(err) {
+	setTimeout(() => {
+		throw err;
+	});
+}
+function deepFreeze(obj) {
+	if (obj === null || typeof obj !== "object" && typeof obj !== "function") return obj;
+	try {
+		if (Array.isArray(obj)) obj.forEach((el) => deepFreeze(el));
+		else Object.keys(obj).forEach((key) => {
+			const prop = obj[key];
+			if (!Object.isFrozen(prop)) deepFreeze(prop);
+		});
+		return Object.freeze(obj);
+	} catch (error) {
+		console.error("Error occurred in deepFreeze:", error);
+		return obj;
+	}
+}
+function defineFixedProperty(obj, key, value, option) {
+	Object.defineProperty(obj, key, {
+		value,
+		...option
+	});
+}
+function isPlainObject(obj) {
+	if (obj === null || typeof obj !== "object") return false;
+	const proto = Object.getPrototypeOf(obj);
+	return proto === Object.prototype || proto === null;
+}
+function parentPathOf(statePath) {
+	return statePath.slice(0, statePath.lastIndexOf("/"));
+}
+function splitStPath(statePath) {
+	if (statePath === "") return [];
+	if (statePath[0] !== "/") throw new Error(`path must start with '/': "${statePath}"`);
+	return statePath.slice(1).split("/");
+}
+//#endregion
+//#region src/machine/arktype/arktype.internal.ts
+const AnyFn = type("Function").narrow((f) => true);
+const FunctionRecord = type({ "[string]": AnyFn });
+const SingleRecord = type({ "[string]": "unknown" }).narrow((value) => Object.keys(value).length === 1);
+const ActionElement = type.or(AnyFn, "string", SingleRecord);
+//#endregion
+//#region src/machine/arktype/ark_m_config.ts
+const o_Types = type({
+	"+": "reject",
+	"context?": "unknown",
+	"events?": "unknown",
+	"emittable?": "unknown",
+	"input?": "unknown",
+	"output?": "unknown"
+});
+const MachineConfig = type({
+	"+": "reject",
+	"types?": o_Types,
+	"name?": "string",
+	"initialState?": "string",
+	"initContext?": AnyFn,
+	"output?": AnyFn,
+	"guards?": FunctionRecord,
+	"actions?": FunctionRecord,
+	"services?": "Record<string, unknown>"
+});
+//#endregion
+//#region src/machine/m.types.ts
+const EntrySymbol = Symbol("Entry");
+const ExitSymbol = Symbol("Exit");
+const SubStatesSymbol = Symbol("SubStates");
+const ParallelSymbol = Symbol("Parallel");
+const InvokeSymbol = Symbol("Invoke");
+const SystemEventSymbol = Symbol("SystemEvent");
+const MachineSymbol = Symbol("Machine");
+//#endregion
+//#region src/machine/arktype/ark_normalized.ts
+const NormalizedActions = ActionElement.array();
+const x_NormalizedTransitions = type({
+	"to?": "string",
+	"fullTo?": "string",
+	actions: NormalizedActions,
+	guards: NormalizedActions
+}).array();
+const x_InternalEvent = type({
+	"cond?": AnyFn,
+	transitions: x_NormalizedTransitions
+});
+const ChildMachine = type({
+	name: "string",
+	provide: AnyFn,
+	internal: {
+		[MachineSymbol]: "true",
+		initContext: AnyFn.or("undefined"),
+		output: AnyFn.or("undefined"),
+		guards: FunctionRecord,
+		actions: FunctionRecord,
+		services: FunctionRecord,
+		definition: "unknown",
+		topLvDefItem: {
+			events: type({ "[string]": x_NormalizedTransitions }),
+			internalEvents: type({ "[string]": x_InternalEvent })
+		},
+		stateCatalog: type.instanceOf(Map).as()
+	}
+});
+const o_NormalizedInvocations = type({
+	"+": "reject",
+	mainKey: "string",
+	"subKey?": "string|number",
+	"input?": AnyFn,
+	emittableETypesToListen: "string[]",
+	src: type.or({
+		type: "\"function\"",
+		value: AnyFn
+	}, {
+		type: "\"string\"",
+		value: "string"
+	}, {
+		type: "\"machine\"",
+		value: ChildMachine
+	})
+}).array();
+const NStateItemDef = type({
+	"+": "reject",
+	pPath: "string",
+	final: AnyFn.or("boolean"),
+	entryHooks: NormalizedActions.or("null"),
+	exitHooks: NormalizedActions.or("null"),
+	invocations: o_NormalizedInvocations,
+	internalEvents: { "[string]": x_InternalEvent },
+	events: { "[string]": x_NormalizedTransitions }
+});
+const SubStNormalizedDefinition = type([
+	{
+		"dType?": "\"normal\"",
+		initial: "string | undefined",
+		stateOf: { "[string]": {
+			def: NStateItemDef,
+			sub: "null | this"
+		} }
+	},
+	"|",
+	{
+		dType: "\"regions\"",
+		stateOf: { "[string]": {
+			def: NStateItemDef,
+			sub: "null | this"
+		} }
+	}
+]);
+//#endregion
+//#region src/machine/arktype/ark_stdef.ts
+const x_ActionEffects = type.or(ActionElement, ActionElement.array());
+const Transition = type({
+	"+": "reject",
+	"to?": "string",
+	"guard?": x_ActionEffects,
+	"actions?": x_ActionEffects
+});
+const OnFnReturn = type([
+	"string",
+	AnyFn,
+	type.or(Transition, Transition.array())
+]).readonly();
+const EntryHookReturn = type([
+	type.unit(EntrySymbol),
+	AnyFn,
+	"null",
+	x_ActionEffects
+]).readonly();
+const ExitHookReturn = type([
+	type.unit(ExitSymbol),
+	AnyFn,
+	"null",
+	x_ActionEffects
+]).readonly();
+const o_StDefMetaInfo = type({
+	"+": "reject",
+	"final?": AnyFn.or("boolean")
+});
+const o_SubStatesNormalized = type([AnyFn, SubStNormalizedDefinition]).readonly();
+const o_Invocation = type([
+	type.unit(InvokeSymbol),
+	AnyFn,
+	"null",
+	type.or(AnyFn, "string", ChildMachine),
+	{
+		"+": "reject",
+		"subKey?": "string | number",
+		"input?": AnyFn
+	},
+	OnFnReturn.array()
+]).readonly();
+const StateDefinition = type.or(OnFnReturn, EntryHookReturn, ExitHookReturn, o_StDefMetaInfo, o_SubStatesNormalized, o_Invocation).array().or("null");
+//#endregion
+//#region src/machine/machine.ts
+function entryHook(...actions) {
+	return [
+		EntrySymbol,
+		(() => null),
+		null,
+		actions
+	];
+}
+function exitHook(...actions) {
+	return [
+		ExitSymbol,
+		(() => null),
+		null,
+		actions
+	];
+}
+function on(eventType, config) {
+	return [
+		eventType,
+		(() => null),
+		config
+	];
+}
+function subStates(statesDefinition, initialState) {
+	return [(() => SubStatesSymbol), transformNormalizedDefinition(statesDefinition, initialState)];
+}
+function parallel(parallelDefinition) {
+	return [(() => ParallelSymbol), transformParallelNormalizedDefinition()(parallelDefinition)];
+}
+function invoke(service, ...args) {
+	const [config, events] = (() => {
+		if (!args.length) return [{}, []];
+		if (Array.isArray(args[0])) return [{}, args];
+		const [first, ...rest] = args;
+		return [first, rest];
+	})();
+	return [
+		InvokeSymbol,
+		(() => null),
+		null,
+		service,
+		config,
+		events
+	];
+}
+const o_getNormalizedStDefTemplate = () => ({
+	def: {
+		pPath: "",
+		final: false,
+		entryHooks: null,
+		exitHooks: null,
+		invocations: [],
+		internalEvents: {},
+		events: {}
+	},
+	sub: null
+});
+function o_normalizeTransitions(transitions) {
+	return transitions.map(({ actions, guard, ...rest }) => ({
+		actions: ensureArray(actions),
+		guards: ensureArray(guard),
+		...rest
+	}));
+}
+function x_parseStDefItems(items, stateName) {
+	let { def, sub } = o_getNormalizedStDefTemplate();
+	if (!items?.length) {
+		def.final = !items;
+		return {
+			def,
+			sub
+		};
+	}
+	const _getPath = () => `${def.pPath}/${stateName}`;
+	for (const [i, item] of items.entries()) {
+		if (!Array.isArray(item)) {
+			if ("final" in item) {
+				const { final } = item;
+				def.final = typeof final === "function" ? final : !!final;
+			}
+			continue;
+		}
+		switch (typeof item?.[0]) {
+			case "string": {
+				const [eType, _, transitions] = item;
+				if (Object.hasOwn(def.events, eType) || Object.hasOwn(def.internalEvents, eType)) throw new Error(`createMachine: Duplicate event definition for event "${eType}", at "${stateName}"[${i}]`);
+				const mid = ensureArray(transitions);
+				if (!mid.length || mid.some((t) => !Object.keys(t).length)) throw new Error(`createMachine: on(eventType, config): Empty config is not allowed: on("${eType}", ${JSON.stringify(transitions)}), at "${stateName}"[${i}]`);
+				const nTransitions = o_normalizeTransitions(mid);
+				switch (eType) {
+					case ":always:":
+						def.internalEvents[":always:"] = { transitions: nTransitions };
+						break;
+					case ":childDone:":
+						def.internalEvents[":childDone:"] = {
+							cond: ({ path }) => path === _getPath(),
+							transitions: nTransitions
+						};
+						break;
+					default: def.events[eType] = nTransitions;
+				}
+				break;
+			}
+			case "symbol":
+				switch (item[0]) {
+					case InvokeSymbol: {
+						const rawSrc = item[3];
+						const src = (() => {
+							switch (typeof rawSrc) {
+								case "object": return {
+									type: "machine",
+									value: rawSrc
+								};
+								case "function": return {
+									type: "function",
+									value: rawSrc
+								};
+								default: return {
+									type: "string",
+									value: rawSrc
+								};
+							}
+						})();
+						const { invocations, internalEvents } = def;
+						const emittableETypesToListen = [];
+						invocations.push({
+							...item[4],
+							src,
+							emittableETypesToListen,
+							mainKey: ""
+						});
+						const suffixNum = invocations.length - 1;
+						let hasErrObserver = false;
+						for (const [j, [ivkEType, _, ivkTransitions]] of item[5].entries()) {
+							const transitions = ensureArray(ivkTransitions);
+							if (!transitions.length || transitions.some((t) => !Object.keys(t).length)) throw new Error(`createMachine: on(eventType, config): The 'config' argument is required, at state:"${stateName}"[${i}] > invoke events[${j}] event:"${ivkEType}"`);
+							const eType = `invoke/${ivkEType}[${suffixNum}]`;
+							if (Object.hasOwn(internalEvents, eType)) throw new Error(`createMachine: Duplicate event definition for event "${ivkEType}", at state:"${stateName}"[${i}] > invoke events[${j}]`);
+							internalEvents[eType] = {
+								cond: ({ path }) => path === _getPath(),
+								transitions: o_normalizeTransitions(transitions)
+							};
+							if (ivkEType === ":error:") hasErrObserver = true;
+							else if (ivkEType !== ":done:") emittableETypesToListen.push(ivkEType);
+						}
+						if (!hasErrObserver) internalEvents[`invoke/:error:[${suffixNum}]`] = {
+							cond: ({ path }) => path === _getPath(),
+							transitions: [{
+								guards: [],
+								actions: [({ e }) => {
+									throw e.error;
+								}]
+							}]
+						};
+						break;
+					}
+					case EntrySymbol:
+						def.entryHooks = ensureArray(item[3]);
+						break;
+					case ExitSymbol: def.exitHooks = ensureArray(item[3]);
+				}
+				break;
+			case "function": {
+				const subStDict = item[1];
+				if (sub) throw new Error(`createMachine: Duplicated subStates: at "${stateName}"[${i}] { ${Object.keys("stateOf" in subStDict ? subStDict.stateOf : {}).map((el) => `${el}:...`).join(", ")} }`);
+				sub = subStDict;
+				break;
+			}
+			default: throw new Error(`createMachine: Unexpected array[0] type: ${JSON.stringify(item?.[0])}`);
+		}
+	}
+	return {
+		def,
+		sub
+	};
+}
+function o_normalizeStates(stateDefOf) {
+	return Object.entries(stateDefOf).reduce((acc, [stKey, stDefs], i) => {
+		if (stKey.includes("/")) throw new Error(`createMachine: State names cannot contain the character "/": "${stKey}"`);
+		else if (Array.isArray(stDefs) || stDefs == null) try {
+			const { def, sub } = x_parseStDefItems(StateDefinition.assert(stDefs), stKey);
+			acc[stKey] = {
+				def,
+				sub
+			};
+		} catch (err) {
+			if (err instanceof Error) throw new Error(`createMachine:(at state "${stKey}") ${err.name}: ${err.message}`);
+		}
+		else throw new Error(`createMachine: Invalid state definition for state "${String(stKey)}". Expected an array but got ${typeof stDefs}.`);
+		return acc;
+	}, {});
+}
+function transformNormalizedDefinition(stateDefOf, initialState) {
+	const firstState = Object.keys(stateDefOf)?.[0];
+	return {
+		initial: !firstState ? void 0 : initialState && assertOrThrow(Object.hasOwn(stateDefOf, initialState), `createMachine: Invalid initialState: "${initialState}"`) ? initialState : firstState,
+		stateOf: o_normalizeStates(stateDefOf)
+	};
+}
+function transformParallelNormalizedDefinition() {
+	return (parallelDefinition) => {
+		return {
+			dType: "regions",
+			stateOf: Object.fromEntries(Object.entries(parallelDefinition).map(([regionName, rawDefinition]) => {
+				if (regionName.includes("/")) throw new Error(`createMachine: Parallel region state names cannot contain the character "/": "${regionName}"`);
+				const len = rawDefinition.length;
+				const leafDefOf = rawDefinition[len - 1] || {};
+				const { def } = x_parseStDefItems(rawDefinition[len - 2] || [], regionName);
+				return [regionName, {
+					def,
+					sub: transformNormalizedDefinition(leafDefOf, void 0)
+				}];
+			}))
+		};
+	};
+}
+function o_setPPathAndInvocationMainKeyThenAddCatalog(nStItemRecord, parent, addToCatalog, isRegion, addRegionPath) {
+	for (const [key, nState] of Object.entries(nStItemRecord)) {
+		const { def, sub } = nState;
+		def.pPath = parent;
+		const stPath = `${parent}/${key}`;
+		for (const [i, e] of def.invocations.entries()) e.mainKey = e.src.type === "string" ? e.src.value : `${stPath}[${i}]`;
+		addToCatalog(stPath, nState);
+		if (isRegion) addRegionPath(stPath);
+		if (sub) {
+			const isParallel = "dType" in sub && sub.dType === "regions";
+			o_setPPathAndInvocationMainKeyThenAddCatalog(sub.stateOf, stPath, addToCatalog, isParallel, addRegionPath);
+		}
+	}
+}
+function o_getTransitionFullPath(to, crrPath, pPath, stateCatalog) {
+	const pth = to[0] === "/" ? to : to.startsWith("./") ? `${crrPath}/${to.slice(2)}` : to.startsWith("../") ? `${pPath}/${to.slice(3)}` : "";
+	if (pth) return stateCatalog.has(pth) ? pth : "";
+	for (const pthFn of [() => `${crrPath}/${to}`, () => `${pPath}/${to}`]) {
+		const pth = pthFn();
+		if (stateCatalog.has(pth)) return pth;
+	}
+	return "";
+}
+function x_readyToValidateTransitionAndSetFullTo(stateCatalog, statePath, pPath, regionPaths) {
+	const ancestorRegion = regionPaths.find((regionPath) => pPath.startsWith(regionPath));
+	const parallelRoot = !ancestorRegion ? null : parentPathOf(ancestorRegion);
+	return (transitions, eType) => {
+		for (const transition of transitions) {
+			const { to } = transition;
+			if (!to) continue;
+			const tFullPath = o_getTransitionFullPath(to, statePath, pPath, stateCatalog);
+			if (!tFullPath) throw new Error(`createMachine: Invalid transition "${to}" in state "${statePath || "/"}" (on:"${eType}").`);
+			if (ancestorRegion && !tFullPath.startsWith(ancestorRegion) && tFullPath.startsWith(parallelRoot)) throw new Error(`createMachine: Transitions in a parallel state cannot target a different region: on('${eType}', ['${to}', ...]) in state "${statePath || "/"}".`);
+			transition.fullTo = tFullPath;
+		}
+	};
+}
+function o_validateTransitionAndSetFullTo(stateCatalog, regionPaths) {
+	stateCatalog.forEach(({ def }, statePath) => {
+		const { events, internalEvents, pPath } = def;
+		const _validateTransitionAndSetFullTo = x_readyToValidateTransitionAndSetFullTo(stateCatalog, statePath, pPath, regionPaths);
+		Object.entries(events).forEach(([eType, transitions]) => {
+			if (!transitions) return;
+			_validateTransitionAndSetFullTo(transitions, eType);
+		});
+		Object.entries(internalEvents).forEach(([eType, internalEvent]) => _validateTransitionAndSetFullTo(internalEvent.transitions, eType));
+	});
+}
+function getDefinitionAndCatalog(config, defineStates) {
+	{
+		const configOut = MachineConfig(config);
+		if (configOut instanceof type.errors) throw new Error(`createMachine: Invalid machine config: ${configOut.summary}`);
+	}
+	const rawDefinition = defineStates({
+		on,
+		entryHook,
+		exitHook,
+		subStates,
+		parallel,
+		invoke
+	});
+	const [stateDefDict, globalEvents] = Array.isArray(rawDefinition) ? [rawDefinition[rawDefinition.length - 1], rawDefinition[rawDefinition.length - 2]] : [rawDefinition, []];
+	{
+		const dType = stateDefDict === null ? "null" : typeof stateDefDict;
+		if (dType !== "object") throw new Error(`createMachine: Invalid state definition: Expected an object but got ${dType}.`);
+		if (Object.keys(stateDefDict).length === 0) throw new Error(`createMachine: No states in machine definition.`);
+	}
+	const { initial, stateOf } = transformNormalizedDefinition(stateDefDict, config.initialState);
+	const stateCatalog = /* @__PURE__ */ new Map();
+	const regionPaths = [];
+	o_setPPathAndInvocationMainKeyThenAddCatalog(stateOf, "", (stPath, state) => stateCatalog.set(stPath, state), false, (regionPath) => regionPaths.push(regionPath));
+	regionPaths.sort((a, b) => b.length - a.length);
+	o_validateTransitionAndSetFullTo(stateCatalog, regionPaths);
+	const { def: { events, internalEvents } } = x_parseStDefItems(globalEvents || [], "(root)");
+	{
+		const _validateTransitionAndSetFullTo = x_readyToValidateTransitionAndSetFullTo(stateCatalog, "", "", regionPaths);
+		Object.entries(events).forEach(([eType, transitions]) => {
+			if (!transitions) return;
+			_validateTransitionAndSetFullTo(transitions, eType);
+		});
+		Object.entries(internalEvents).forEach(([eType, internalEvent]) => _validateTransitionAndSetFullTo(internalEvent.transitions, eType));
+	}
+	return {
+		definition: {
+			initial,
+			stateOf
+		},
+		topLvDefItem: {
+			events,
+			internalEvents
+		},
+		stateCatalog,
+		regionPaths
+	};
+}
+function defServiceFn(fn) {
+	return fn;
+}
+function isMachine(v) {
+	if (!(v && typeof v === "object" && "internal" in v)) return false;
+	const { internal } = v;
+	return !!(internal && typeof internal === "object" && MachineSymbol in internal);
+}
+function makeMachine(config, defineStates) {
+	const { definition, topLvDefItem, stateCatalog } = getDefinitionAndCatalog(config, defineStates);
+	const { name, initContext, output, guards, actions, services } = config;
+	return deepFreeze({
+		name: name || "(machine)",
+		provide,
+		internal: {
+			[MachineSymbol]: true,
+			initContext,
+			output,
+			guards: guards || {},
+			actions: actions || {},
+			services: services || {},
+			definition,
+			topLvDefItem,
+			stateCatalog
+		}
+	});
+}
+function provide(implementations) {
+	const { internal } = this;
+	const { guards, actions, services } = internal;
+	return deepFreeze({
+		...this,
+		internal: {
+			...internal,
+			guards: {
+				...guards,
+				...implementations.guards
+			},
+			actions: {
+				...actions,
+				...implementations.actions
+			},
+			services: {
+				...services,
+				...implementations.services
+			}
+		}
+	});
+}
+//#endregion
+//#region src/runtime/MailBox.ts
+var MailBox = class {
+	#isActive = false;
+	#current = null;
+	#last = null;
+	#process;
+	#flush;
+	constructor(process, isAsync = false) {
+		this.#process = process;
+		this.#flush = isAsync ? this.#_flushAsync : this.#_flush;
+	}
+	start() {
+		this.#isActive = true;
+		this.#flush();
+	}
+	clear() {
+		if (this.#current) {
+			this.#current.next = null;
+			this.#last = this.#current;
+		}
+	}
+	enqueue(value, payload) {
+		const newElement = {
+			value,
+			payload,
+			next: null
+		};
+		if (this.#current) {
+			this.#last.next = newElement;
+			this.#last = newElement;
+			return;
+		}
+		this.#current = newElement;
+		this.#last = newElement;
+		if (this.#isActive) this.#flush();
+	}
+	#_flush() {
+		while (this.#current) {
+			const { value, payload } = this.#current;
+			this.#process(value, payload);
+			this.#current = this.#current.next;
+		}
+		this.#last = null;
+	}
+	async #_flushAsync() {
+		while (this.#current) {
+			const { value, payload } = this.#current;
+			await this.#process(value, payload);
+			this.#current = this.#current.next;
+		}
+		this.#last = null;
+	}
+};
+//#endregion
+//#region src/runtime/runtime_utils.ts
+function x_resolveActionElement(kind, type, implRecord, keyParams = void 0) {
+	switch (typeof type) {
+		case "function": return [type];
+		case "string":
+			if (!Object.hasOwn(implRecord, type)) throw new Error(`unknown ${kind} type: "${type}"`);
+			return [implRecord[type], keyParams];
+		case "object": {
+			const entries = Object.entries(type);
+			if (!(entries.length === 1 && isPlainObject(type))) throw new Error(`invalid ${kind} type: "${JSON.stringify(type)}"`);
+			const [key, val] = entries[0];
+			if (!Object.hasOwn(implRecord, key)) throw new Error(`unknown ${kind} type: "${key}"`);
+			return [implRecord[key], val];
+		}
+		default: throw new Error(`invalid ${kind} type: "${JSON.stringify(type)}"`);
+	}
+}
+function resolveGuardElement(type, machineGuards, keyParams = void 0) {
+	return x_resolveActionElement("Guard", type, machineGuards, keyParams);
+}
+function resolveActionElement(type, machineActions, keyParams = void 0) {
+	return x_resolveActionElement("Action", type, machineActions, keyParams);
+}
+const runtimeUtils = { makeFnBaseParam(context, event, input) {
+	return {
+		context,
+		c: context,
+		event,
+		e: event,
+		input
+	};
+} };
+function readyToEvalGuard(fnBaseParam, machineGuards) {
+	return (guard) => {
+		const [fn, params] = resolveGuardElement(guard, machineGuards);
+		return fn(fnBaseParam, typeof params !== "function" ? params : params(fnBaseParam));
+	};
+}
+function traverseStateRouteMatch(stateRoute, stPathSplitted) {
+	let focusedRoute = stateRoute;
+	let routeIdx = 0;
+	const len = stPathSplitted.length;
+	let i = 0;
+	for (; i < len; i++, routeIdx++) {
+		const sName = stPathSplitted[i];
+		const routeEl = focusedRoute[routeIdx];
+		if (!routeEl) return {
+			isExhausted: false,
+			endIdx: i,
+			remaining: [focusedRoute, routeIdx]
+		};
+		else if (typeof routeEl === "string") {
+			if (sName !== routeEl.valueOf()) return {
+				isExhausted: false,
+				endIdx: i,
+				remaining: [focusedRoute, routeIdx]
+			};
+			continue;
+		}
+		const { parallel, regions } = routeEl;
+		if (sName !== parallel) return {
+			isExhausted: false,
+			endIdx: i
+		};
+		i += 1;
+		if (i >= len) return {
+			isExhausted: true,
+			endIdx: i,
+			remaining: [
+				focusedRoute,
+				routeIdx,
+				true
+			]
+		};
+		const regionRoute = regions[stPathSplitted[i]];
+		if (!regionRoute) return {
+			isExhausted: false,
+			endIdx: i
+		};
+		focusedRoute = regionRoute;
+		routeIdx = -1;
+	}
+	return {
+		isExhausted: true,
+		endIdx: i,
+		remaining: [focusedRoute, routeIdx]
+	};
+}
+//#endregion
+//#region src/runtime/runtime_step.core.ts
+function buildTransitionCandidate(transition, tIndex, firedIn, leaves) {
+	return {
+		transition,
+		tIndex,
+		firedIn,
+		leaves
+	};
+}
+const x_getStItemDef = (stPath, stateCatalog) => {
+	const stateItem = stateCatalog.get(stPath);
+	if (!stateItem) throw new Error(`Unknown state path "${stPath}"`);
+	return stateItem.def;
+};
+function o_deriveLowestCommonAncestor(model, leaves) {
+	let crrLeaves = leaves;
+	let bgn = 1;
+	let end = model.indexOf("/", bgn) + 1;
+	while (end) {
+		const needle = model.slice(bgn, end);
+		crrLeaves = crrLeaves.filter((pth) => pth.startsWith(needle, bgn));
+		if (!crrLeaves.length) break;
+		bgn = end;
+		end = model.indexOf("/", bgn) + 1;
+	}
+	return model.slice(0, bgn - 1);
+}
+function x_removeConflictedTransitions(tCandidates, activeParallels) {
+	if (tCandidates.length < 2 || !activeParallels.length) return tCandidates.map(({ transition, tIndex, leaves }) => {
+		const { fullTo } = transition;
+		return {
+			tIndex,
+			transition,
+			lca: !fullTo ? void 0 : o_deriveLowestCommonAncestor(fullTo, leaves)
+		};
+	});
+	const stateStayingTExecs = [];
+	const nonPExitedTExecs = [];
+	const accStChangingTExecDict = Object.create(null);
+	for (const tCand of tCandidates) {
+		const { transition, tIndex, leaves } = tCand;
+		const { fullTo } = transition;
+		if (!fullTo) {
+			stateStayingTExecs.push({
+				transition,
+				tIndex
+			});
+			continue;
+		}
+		const lca = o_deriveLowestCommonAncestor(fullTo, leaves);
+		const exitedParallel = (() => {
+			const idx = fullTo.indexOf("/", lca.length + 1);
+			const needle = idx == -1 ? fullTo : fullTo.slice(0, idx + 1);
+			const candidates = activeParallels.filter((p) => !p.startsWith(needle) && p.startsWith(lca));
+			return !candidates.length ? "" : candidates.reduce((a, b) => a.length <= b.length ? a : b);
+		})();
+		if (!exitedParallel) nonPExitedTExecs.push({
+			transition,
+			tIndex,
+			lca
+		});
+		else if (!(exitedParallel in accStChangingTExecDict)) accStChangingTExecDict[exitedParallel] = {
+			transition,
+			tIndex,
+			lca
+		};
+	}
+	const [tmp1, tmp2] = (() => {
+		const _adoptedParallels = [];
+		return [Object.entries(accStChangingTExecDict).sort(([pathA], [pathB]) => pathA > pathB ? 1 : -1).reduce((acc, [pth, tExec]) => {
+			if (!_adoptedParallels.some((parPath) => pth.startsWith(parPath))) {
+				_adoptedParallels.push(pth);
+				acc.push(tExec);
+			}
+			return acc;
+		}, []), nonPExitedTExecs.filter(({ lca }) => !_adoptedParallels.some((pth) => lca?.startsWith(pth)))];
+	})();
+	return [
+		...stateStayingTExecs,
+		...tmp1,
+		...tmp2
+	];
+}
+function o_findChildOrSelfTransition(stPath, stateRoute, childIdx, activeParallelSet, stateCatalog, findTransition, eType) {
+	const [childCandidates, cLeaves] = x_findDeepestTransitions(stateRoute, childIdx, stPath, activeParallelSet, stateCatalog, findTransition, eType);
+	if (childCandidates.length) return [childCandidates, []];
+	const result = findTransition(x_getStItemDef(stPath, stateCatalog), eType);
+	const leaves = cLeaves.length ? cLeaves : [stPath];
+	if (!result) return [[], leaves];
+	const { transition, tIndex } = result;
+	return [[buildTransitionCandidate(transition, tIndex, stPath, leaves)], []];
+}
+function x_findDeepestTransitions(stateRoute, idx, parentPath, activeParallelSet, stateCatalog, findTransition, eType = "") {
+	if (idx >= stateRoute.length) return [[], []];
+	const stateNameOrParallel = stateRoute[idx];
+	if (typeof stateNameOrParallel === "string") return o_findChildOrSelfTransition(`${parentPath}/${stateNameOrParallel}`, stateRoute, idx + 1, activeParallelSet, stateCatalog, findTransition, eType);
+	const { parallel, regions } = stateNameOrParallel;
+	const parallelRoot = `${parentPath}/${parallel}`;
+	activeParallelSet.add(parallelRoot);
+	const accTCandidates = [];
+	const accLeaves = [];
+	for (const key in regions) {
+		const [resultCandidates, resultLeaves] = o_findChildOrSelfTransition(`${parentPath}/${parallel}/${key}`, regions[key], 0, activeParallelSet, stateCatalog, findTransition, eType);
+		if (resultCandidates.length) accTCandidates.push(...resultCandidates);
+		if (resultLeaves.length) accLeaves.push(...resultLeaves);
+	}
+	if (accTCandidates.length) return [accTCandidates, []];
+	const result = findTransition(x_getStItemDef(parallelRoot, stateCatalog), eType);
+	if (!result) return [[], accLeaves];
+	const { transition, tIndex } = result;
+	return [[buildTransitionCandidate(transition, tIndex, parallelRoot, accLeaves)], []];
+}
+function o_unwrapSystemEvent(event) {
+	return !(SystemEventSymbol in event && event.payload) ? event : event.payload;
+}
+function o_evalActionParams(param, context, event, input) {
+	return typeof param !== "function" ? param : param(runtimeUtils.makeFnBaseParam(context, event, input));
+}
+function readyAction(origContext, rawEvent, input, machineGuards, machineActions, rtOutbound) {
+	const event = o_unwrapSystemEvent(rawEvent);
+	const { emit } = rtOutbound;
+	let context = deepFreeze(origContext);
+	let updateApplications = [];
+	let enqActions = [];
+	const update = (updates) => {
+		if (!updates || typeof updates !== "object") throw new Error(`RT"${rtOutbound.id}"> Invalid updates argument: ${JSON.stringify(updates)}`);
+		updateApplications.push(updates);
+	};
+	function applyUpdate() {
+		for (const updates of updateApplications) {
+			const partial = Object.entries(updates).reduce((acc, [key, val]) => {
+				acc[key] = typeof val === "function" ? val() : val;
+				return acc;
+			}, {});
+			context = {
+				...context,
+				...partial
+			};
+		}
+		if (!updateApplications.length) return;
+		context = deepFreeze(context);
+		updateApplications = [];
+	}
+	function check(type, ...args) {
+		const [fn, params] = resolveGuardElement(type, machineGuards, args?.[0]);
+		const fnBaseParam = runtimeUtils.makeFnBaseParam(context, event, input);
+		return fn(fnBaseParam, typeof params !== "function" ? params : params(fnBaseParam));
+	}
+	function sendTo(serviceName, ...args) {
+		const [subKey, sEvent] = args.length == 2 ? args : ["", args[0]];
+		const childKey = subKey || typeof subKey === "number" ? `${serviceName}:${subKey}` : serviceName;
+		if (!Object.hasOwn(rtOutbound.children, childKey)) throw new Error(`RT"${rtOutbound.id}"> Cannot send event to "${childKey}": child not found.`);
+		rtOutbound.children[childKey]?.send(sEvent);
+	}
+	let isProcessingQueue = false;
+	function enqueue(type, ...args) {
+		if (isProcessingQueue) throw new Error(`RT"${rtOutbound.id}"> Nested enqueue operations are not supported.`);
+		const [fn, params] = resolveActionElement(type, machineActions, args?.[0]);
+		enqActions.push({
+			fn,
+			params
+		});
+	}
+	let saveContext = origContext;
+	let saveFnBaseParam;
+	return {
+		makeFnBaseParam() {
+			if (!(context === saveContext && saveFnBaseParam)) {
+				saveContext = context;
+				saveFnBaseParam = runtimeUtils.makeFnBaseParam(context, event, input);
+			}
+			return saveFnBaseParam;
+		},
+		execAction(transitionAction, eventOverride) {
+			const bodies = resolveActionElement(transitionAction, machineActions);
+			const qEvent = !eventOverride ? event : o_unwrapSystemEvent(eventOverride);
+			if (bodies.length === 1) bodies[0]({
+				context,
+				c: context,
+				event: qEvent,
+				e: qEvent,
+				input,
+				update,
+				sendTo,
+				emit,
+				check,
+				enqueue
+			});
+			else {
+				const [fn, params] = bodies;
+				fn({
+					context,
+					c: context,
+					event: qEvent,
+					e: qEvent,
+					input,
+					update,
+					emit
+				}, o_evalActionParams(params, context, qEvent, input));
+			}
+			applyUpdate();
+		},
+		processQueue() {
+			isProcessingQueue = true;
+			try {
+				for (const { fn, params } of enqActions) {
+					fn({
+						context,
+						c: context,
+						event,
+						e: event,
+						input,
+						update,
+						emit
+					}, o_evalActionParams(params, context, event, input));
+					applyUpdate();
+				}
+			} finally {
+				enqActions = [];
+				isProcessingQueue = false;
+			}
+		},
+		getResult() {
+			return { context };
+		}
+	};
+}
+function o_readyToFindInternalEventTransition(fnBaseParam, machineGuards, internalEPayload) {
+	const _evalGuard = readyToEvalGuard(fnBaseParam, machineGuards);
+	return ({ internalEvents }, eType) => {
+		const internalEType = eType;
+		if (Object.hasOwn(internalEvents, internalEType)) {
+			const cond = internalEvents[internalEType].cond;
+			if (!cond || cond(internalEPayload)) {
+				const { transitions } = internalEvents[internalEType];
+				const tIndex = transitions.findIndex(({ guards }) => !guards.length || guards.every((e) => _evalGuard(e)));
+				if (tIndex != -1) return {
+					tIndex,
+					transition: transitions[tIndex]
+				};
+			}
+		}
+	};
+}
+function o_readyToFindTransitionByEvent(fnBaseParam, machineGuards) {
+	const _evalGuard = readyToEvalGuard(fnBaseParam, machineGuards);
+	return ({ events }, eType) => {
+		if (Object.hasOwn(events, eType)) {
+			const transitions = events[eType];
+			const tIndex = transitions.findIndex(({ guards }) => !guards.length || guards.every((e) => _evalGuard(e)));
+			if (tIndex != -1) return {
+				tIndex,
+				transition: transitions[tIndex]
+			};
+		}
+	};
+}
+function deriveEventTransition(eType, internalEPayload, fnBaseParam, crrStates, machineGuards, stateCatalog, topLvDefItem) {
+	const findTransition = internalEPayload ? o_readyToFindInternalEventTransition(fnBaseParam, machineGuards, internalEPayload) : o_readyToFindTransitionByEvent(fnBaseParam, machineGuards);
+	const activeParallelSet = /* @__PURE__ */ new Set();
+	const [tCandidates, cLeaves] = x_findDeepestTransitions(crrStates, 0, "", activeParallelSet, stateCatalog, findTransition, eType);
+	if (!tCandidates.length) {
+		const result = findTransition(topLvDefItem, eType);
+		if (result) {
+			const { transition, tIndex } = result;
+			tCandidates.push(buildTransitionCandidate(transition, tIndex, "/", cLeaves));
+		}
+	}
+	return x_removeConflictedTransitions(tCandidates, [...activeParallelSet].sort((a, b) => a > b ? -1 : 1));
+}
+function* o_genExitPaths(parent, stateRoute, idx, asRootpath = false) {
+	if (idx >= stateRoute.length) return;
+	const el = stateRoute[idx];
+	if (typeof el === "string") {
+		const pth = `${parent}/${el}`;
+		yield* o_genExitPaths(pth, stateRoute, idx + 1);
+		yield pth;
+		return;
+	}
+	const { parallel, regions } = el;
+	const rootPath = asRootpath ? parent : `${parent}/${parallel}`;
+	for (const regionName in regions) {
+		const pth = `${rootPath}/${regionName}`;
+		yield* o_genExitPaths(pth, regions[regionName], 0);
+		yield pth;
+	}
+	if (!asRootpath) yield rootPath;
+}
+function* genExitPathsAndDeleteFromCrrStates(crrStates, lca, fullTo = ":DUMMY:") {
+	const { remaining, isExhausted } = traverseStateRouteMatch(crrStates, splitStPath(lca));
+	if (!isExhausted) throw new Error(`During transition to "${fullTo}", state "${lca}" is not found in ${JSON.stringify(crrStates)}`);
+	const [stateRoute, startIdx, asRootpath] = remaining;
+	yield* o_genExitPaths(lca, stateRoute, startIdx, asRootpath);
+	if (!asRootpath) stateRoute.splice(startIdx);
+	else if (typeof stateRoute[startIdx] === "object") stateRoute[startIdx].regions = {};
+	else throw new Error(`Internal error: unexpected stateRoute: ${JSON.stringify(stateRoute)}, lca:${lca}`);
+}
+function oo_addSubStatesToDest(destinations, { initial, stateOf }) {
+	if (!initial || initial in destinations) return destinations;
+	destinations[initial] = Object.create(null);
+	const { sub } = stateOf[initial];
+	if (!sub) return destinations;
+	else if (sub.dType === "regions") oo_addParallelToDestTree(destinations[initial], sub.stateOf);
+	else oo_addSubStatesToDest(destinations[initial], sub);
+	return destinations;
+}
+function oo_addParallelToDestTree(destinations, regionStItemOf, routeRegions) {
+	for (const key in regionStItemOf) {
+		if (key in destinations || routeRegions?.[key]?.length) continue;
+		destinations[key] = Object.create(null);
+		oo_addSubStatesToDest(destinations[key], regionStItemOf[key].sub);
+	}
+}
+function* o_genStateEntryData(transitionDest, target, rIdx, stateDefinition) {
+	const { stateOf } = stateDefinition;
+	let isLeaf = true;
+	for (const dKey in transitionDest) {
+		isLeaf = false;
+		const stDef = stateOf?.[dKey];
+		if (!stDef) throw new Error(`Unknown state "${dKey}"`);
+		const { def, sub } = stDef;
+		const isParallel = sub?.dType === "regions";
+		const childTree = transitionDest[dKey];
+		if (rIdx >= 0) {
+			if (isParallel) {
+				const { route } = target;
+				const el = route[rIdx];
+				if (typeof el === "object" && "parallel" in el && el.parallel === dKey) {
+					oo_addParallelToDestTree(childTree, sub.stateOf, el.regions);
+					yield* o_genStateEntryData(childTree, {
+						isRegions: true,
+						regions: el.regions
+					}, rIdx, sub);
+					continue;
+				}
+			} else if (target.isRegions) {
+				const { regions } = target;
+				if (dKey in regions) {
+					if (sub) yield* o_genStateEntryData(childTree, {
+						isRegions: false,
+						route: regions[dKey],
+						isRegionChild: true
+					}, 0, sub);
+					continue;
+				}
+			} else {
+				const { route } = target;
+				if (route[rIdx]?.valueOf() === dKey) {
+					if (sub) yield* o_genStateEntryData(childTree, {
+						isRegions: false,
+						route,
+						isRegionChild: false
+					}, rIdx + 1, sub);
+					continue;
+				}
+			}
+		}
+		if (isParallel) {
+			const regions = Object.create(null);
+			const el = {
+				parallel: dKey,
+				regions
+			};
+			const { route, isRegionChild } = target;
+			route.push(el);
+			yield [def, {
+				stateName: dKey,
+				isRegionChild
+			}];
+			oo_addParallelToDestTree(childTree, sub.stateOf);
+			yield* o_genStateEntryData(childTree, {
+				isRegions: true,
+				regions
+			}, -1, sub);
+		} else if (target.isRegions) {
+			const route = [];
+			target.regions[dKey] = route;
+			yield [def, { stateName: dKey }];
+			if (sub) yield* o_genStateEntryData(childTree, {
+				isRegions: false,
+				route,
+				isRegionChild: true
+			}, -1, sub);
+		} else {
+			const { route, isRegionChild } = target;
+			route.push(dKey);
+			yield [def, {
+				stateName: dKey,
+				isRegionChild
+			}];
+			if (sub) yield* o_genStateEntryData(childTree, {
+				isRegions: false,
+				route,
+				isRegionChild: false
+			}, -1, sub);
+		}
+	}
+	if (isLeaf && "initial" in stateDefinition && stateDefinition.initial) yield* o_genStateEntryData(oo_addSubStatesToDest(Object.create(null), stateDefinition), target, -1, stateDefinition);
+}
+function* updateStateRouteForEntry(fullToSplittees, crrStates, stateDefinition) {
+	yield* o_genStateEntryData((() => {
+		const root = Object.create(null);
+		for (const stateNames of fullToSplittees) {
+			let focused = root;
+			for (const stName of stateNames) {
+				focused[stName] = focused[stName] || Object.create(null);
+				focused = focused[stName];
+			}
+		}
+		return root;
+	})(), {
+		isRegions: false,
+		route: crrStates,
+		isRegionChild: false
+	}, 0, stateDefinition);
+}
+function launchInvocations(invocations, path, makeFnBaseParam, machineServices, rtOutbound) {
+	const { enqueueEvent } = rtOutbound;
+	const fnBaseParam = makeFnBaseParam();
+	for (const [i, { input, mainKey, subKey, src, emittableETypesToListen }] of invocations.entries()) {
+		const [srcType, srcValue] = (() => {
+			const { type, value } = src;
+			if (type !== "string") return [type, value];
+			const service = machineServices[value];
+			if (!service) throw new Error(`RT"${rtOutbound.id}"> invoke: Unknown src: "${value}"`);
+			return [typeof service === "function" ? "function" : "machine", service];
+		})();
+		const childKey = subKey ? `${mainKey}:${subKey}` : mainKey;
+		if (rtOutbound.children[childKey]) throw new Error(`RT"${rtOutbound.id}"> Service with ID '${childKey}' is already running.`);
+		const onDone = (output) => enqueueEvent({
+			type: `invoke/:done:[${i}]`,
+			payload: {
+				type: ":done:",
+				output
+			},
+			[SystemEventSymbol]: true
+		}, { path });
+		const onError = (error) => {
+			enqueueEvent({
+				type: `invoke/:error:[${i}]`,
+				payload: {
+					type: ":error:",
+					error
+				},
+				[SystemEventSymbol]: true
+			}, { path });
+		};
+		const inputValue = input && typeof input === "function" ? input(fnBaseParam) : void 0;
+		switch (srcType) {
+			case "machine": {
+				const childRt = makeRuntime(srcValue, {
+					id: `${rtOutbound.id}/${childKey}`,
+					input: () => inputValue
+				});
+				rtOutbound.children = {
+					...rtOutbound.children,
+					[childKey]: childRt
+				};
+				childRt.subscribe(({ runtimeStatus, output }) => {
+					if (runtimeStatus === "done") onDone(output);
+				}, onError);
+				for (const eType of emittableETypesToListen) childRt.onEmitted(eType, (emittedEvent) => {
+					enqueueEvent({
+						type: `invoke/${eType}[${i}]`,
+						payload: emittedEvent,
+						[SystemEventSymbol]: true
+					}, { path });
+				});
+				childRt.start();
+				break;
+			}
+			case "function": {
+				const abortController = new AbortController();
+				const { signal } = abortController;
+				const emit = (emittedEvent) => {
+					if (!(emittedEvent && typeof emittedEvent === "object" && emittableETypesToListen.includes(emittedEvent?.type))) throw new Error(`RT"${rtOutbound.id}"> Invalid emittedEvent: ${JSON.stringify(emittedEvent)}`);
+					enqueueEvent({
+						type: `invoke/${emittedEvent?.type}[${i}]`,
+						payload: emittedEvent,
+						[SystemEventSymbol]: true
+					}, { path });
+				};
+				const listeners = /* @__PURE__ */ new Set();
+				const listen = (listener) => {
+					listeners.add(listener);
+				};
+				const child = {
+					send(event) {
+						listeners.forEach((listener) => listener(event));
+					},
+					stop() {
+						abortController.abort();
+						listeners.clear();
+					}
+				};
+				rtOutbound.children = {
+					...rtOutbound.children,
+					[childKey]: child
+				};
+				const result = (() => {
+					try {
+						return srcValue(inputValue, emit, listen, signal);
+					} catch (error) {
+						if (!signal.aborted) onError(error);
+					}
+				})();
+				const _handleOutput = (output) => {
+					if (typeof output === "function") {
+						if (signal.aborted) output();
+						else child.stop = () => {
+							abortController.abort();
+							listeners.clear();
+							output();
+						};
+					} else if (!signal.aborted) onDone(output);
+				};
+				if (!(result instanceof Promise)) {
+					_handleOutput(result);
+					return;
+				}
+				result.then((output) => _handleOutput(output)).catch((error) => {
+					if (!signal.aborted) onError(error);
+				});
+				break;
+			}
+		}
+	}
+}
+function stopInvocations(invocations, rtOutbound) {
+	const newChildren = { ...rtOutbound.children };
+	for (const { mainKey, subKey } of invocations) {
+		const key = subKey ? `${mainKey}:${subKey}` : mainKey;
+		newChildren[key].stop();
+		delete newChildren[key];
+	}
+	rtOutbound.children = newChildren;
+}
+function o_gatherAllChildrenOutputs(regions, parent, fnBaseParams, stateCatalog) {
+	const output = {};
+	for (const key in regions) {
+		const regionChild = regions[key][0];
+		if (!regionChild) continue;
+		else if (typeof regionChild === "object") {
+			const result = regionChild.output;
+			if (!result) return null;
+			output[key] = result;
+			continue;
+		}
+		const { final } = x_getStItemDef(`${parent}/${key}/${regionChild}`, stateCatalog);
+		if (!final) return null;
+		if (typeof final === "function") output[key] = final(fnBaseParams);
+	}
+	return output;
+}
+function* genChildDoneEvents(reachedFinalStateData = [], fnBaseParams, crrStates, stateCatalog) {
+	const accParallelRoots = /* @__PURE__ */ new Set();
+	for (const [pPath, isRegionChild, final] of reachedFinalStateData) {
+		if (!pPath) continue;
+		if (isRegionChild) accParallelRoots.add(parentPathOf(pPath));
+		else yield [{
+			type: ":childDone:",
+			output: typeof final === "function" ? final(fnBaseParams) : void 0
+		}, { path: pPath }];
+	}
+	{
+		const seen = /* @__PURE__ */ new Set();
+		for (const parallelRoot of accParallelRoots) {
+			let focusedPath = parentPathOf(parallelRoot);
+			while (focusedPath) {
+				if (seen.has(focusedPath)) break;
+				seen.add(focusedPath);
+				const item = stateCatalog.get(focusedPath);
+				const pPath = item.def.pPath;
+				if (item.sub?.dType === "regions") {
+					accParallelRoots.add(focusedPath);
+					focusedPath = pPath;
+					continue;
+				} else if (!pPath) break;
+				const pItem = stateCatalog.get(pPath);
+				if (pItem.sub?.dType !== "regions") break;
+				accParallelRoots.add(pPath);
+				focusedPath = pItem.def.pPath;
+			}
+		}
+	}
+	const parallelRoots = [...accParallelRoots].sort((a, b) => a > b ? -1 : 1);
+	const last = parallelRoots.length - 1;
+	for (const [i, parallelRoot] of parallelRoots.entries()) {
+		const def = stateCatalog.get(parallelRoot)?.def;
+		if (i >= last && !def?.internalEvents[":childDone:"]?.transitions.length) break;
+		const { remaining, isExhausted } = traverseStateRouteMatch(crrStates, splitStPath(parallelRoot));
+		if (!isExhausted) throw new Error(`Internal error: state "${parallelRoot}" is not found in current states.`);
+		const [route, idx] = remaining;
+		const parallelRouteEl = route[idx];
+		const output = o_gatherAllChildrenOutputs(parallelRouteEl.regions, parallelRoot, fnBaseParams, stateCatalog);
+		if (output) {
+			parallelRouteEl.output = output;
+			yield [{
+				type: ":childDone:",
+				output
+			}, { path: parallelRoot }];
+		}
+	}
+}
+function o_readyToFindAlwaysTransition(fnBaseParam, machineGuards) {
+	const _evalGuard = readyToEvalGuard(fnBaseParam, machineGuards);
+	return ({ internalEvents }) => {
+		const transitions = internalEvents[":always:"]?.transitions;
+		if (transitions) {
+			const tIndex = transitions.findIndex(({ guards }) => !guards.length || guards.every((e) => _evalGuard(e)));
+			if (tIndex != -1) return {
+				tIndex,
+				transition: transitions[tIndex]
+			};
+		}
+	};
+}
+function evalAlwaysEvent(fnBaseParam, crrStates, machineGuards, stateCatalog) {
+	const findTransition = o_readyToFindAlwaysTransition(fnBaseParam, machineGuards);
+	const activeParallelSet = /* @__PURE__ */ new Set();
+	const [tCandidates] = x_findDeepestTransitions(crrStates, 0, "", activeParallelSet, stateCatalog, findTransition);
+	return x_removeConflictedTransitions(tCandidates, [...activeParallelSet].sort((a, b) => a > b ? -1 : 1));
+}
+//#endregion
+//#region src/runtime/runtime_step.ts
+function execTExecActions(tExecs, actionRunner, errLocation, internalQueueEvent) {
+	const { execAction, processQueue } = actionRunner;
+	let i, tExec, action;
+	try {
+		for (tExec of tExecs) for ([i, action] of tExec.transition.actions.entries()) {
+			execAction(action, internalQueueEvent);
+			processQueue();
+		}
+	} catch (err) {
+		const { lca, tIndex } = tExec;
+		const msg = err instanceof Error ? err.message : String(err);
+		console.error(`small-state: ${msg}`, {
+			state: lca,
+			location: `${errLocation}[${tIndex}], actions[${i}]`
+		});
+		throw err;
+	}
+}
+function initRuntime(realContext, input, crrStates, machineInternal, rtOutbound, event = { type: ":init:" }) {
+	const { definition, guards, actions } = machineInternal;
+	const { initial } = definition;
+	const actionRunner = readyAction(realContext, event, input, guards, actions, rtOutbound);
+	const [hasTransitioned, doneEvent] = runMicrosteps([{
+		transition: {
+			to: initial,
+			fullTo: `/${initial}`,
+			guards: [],
+			actions: []
+		},
+		tIndex: -1
+	}], crrStates, actionRunner, machineInternal, rtOutbound);
+	{
+		const { context } = actionRunner.getResult();
+		return {
+			context,
+			crrStates,
+			hasTransitioned,
+			doneEvent
+		};
+	}
+}
+function macrostep(eType, internalEPayload, crrStates, actionRunner, machineInternal, rtOutbound) {
+	const { guards, stateCatalog, topLvDefItem } = machineInternal;
+	const tExecs = deriveEventTransition(eType, internalEPayload, actionRunner.makeFnBaseParam(), crrStates, guards, stateCatalog, topLvDefItem);
+	execTExecActions(tExecs, actionRunner, "transition");
+	const [hasTransitioned, doneEvent] = runMicrosteps(tExecs, crrStates, actionRunner, machineInternal, rtOutbound);
+	{
+		const { context } = actionRunner.getResult();
+		return {
+			context,
+			crrStates,
+			hasTransitioned,
+			doneEvent
+		};
+	}
+}
+function runMicrosteps(tExecs, crrStates, actionRunner, machineInternal, rtOutbound) {
+	const internalQueue = [];
+	let [hasTransitioned, doneEvent] = runExitAndEntryThenAlways(tExecs, crrStates, actionRunner, machineInternal, rtOutbound, internalQueue);
+	const { guards, stateCatalog, topLvDefItem } = machineInternal;
+	const { makeFnBaseParam } = actionRunner;
+	while (internalQueue.length) {
+		const [event, payload] = internalQueue.shift();
+		const internalTExecs = deriveEventTransition(event.type, payload, makeFnBaseParam(), crrStates, guards, stateCatalog, topLvDefItem);
+		execTExecActions(internalTExecs, actionRunner, event.type, event);
+		[hasTransitioned, doneEvent] = runExitAndEntryThenAlways(internalTExecs, crrStates, actionRunner, machineInternal, rtOutbound, internalQueue) || hasTransitioned;
+	}
+	return [hasTransitioned, doneEvent];
+}
+function runExitAndEntryThenAlways(tExecs, crrStates, actionRunner, machineInternal, rtOutbound, internalQueue) {
+	let [alwaysTExecs, hasTransitioned, doneEvent] = exitAndEntry(tExecs, crrStates, actionRunner, machineInternal, rtOutbound, internalQueue);
+	let i = 0;
+	while (alwaysTExecs.length) {
+		let tmp;
+		[alwaysTExecs, tmp, doneEvent] = exitAndEntry(alwaysTExecs, crrStates, actionRunner, machineInternal, rtOutbound, internalQueue);
+		hasTransitioned ||= tmp;
+		if (++i > 1e3) throw new Error(`RT"${rtOutbound.id}"> Maximum number of microsteps exceeded.`);
+	}
+	return [hasTransitioned, doneEvent];
+}
+function exitAndEntry(tExecs, crrStates, actionRunner, { guards, services, stateCatalog, definition }, rtOutbound, internalQueue) {
+	let doneEvent;
+	const { makeFnBaseParam, execAction, processQueue } = actionRunner;
+	for (const { lca, transition } of tExecs) {
+		if (lca === void 0) continue;
+		{
+			const exitPaths = genExitPathsAndDeleteFromCrrStates(crrStates, lca, transition.fullTo);
+			let i, action;
+			try {
+				for (const pth of exitPaths) {
+					const { def } = stateCatalog.get(pth);
+					const { invocations, exitHooks } = def;
+					if (exitHooks) for ([i, action] of exitHooks.entries()) {
+						execAction(action);
+						processQueue();
+					}
+					if (invocations.length) stopInvocations(invocations, rtOutbound);
+				}
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				console.error(`small-state: ${msg}`, {
+					runtimeId: rtOutbound.id,
+					state: lca,
+					location: `exitHooks[${i}]`
+				});
+				throw err;
+			}
+		}
+	}
+	const stChangingTExecs = tExecs.filter(({ transition: { fullTo } }) => fullTo);
+	if (stChangingTExecs.length) {
+		const accReachedFinal = [];
+		const fullToSplittees = stChangingTExecs.map(({ transition }) => splitStPath(transition.fullTo));
+		const enteredStItemDefs = updateStateRouteForEntry(fullToSplittees, crrStates, definition);
+		let i = 0, j, action;
+		try {
+			for (const [def, additional] of enteredStItemDefs) {
+				const { invocations, entryHooks, final, pPath } = def;
+				if (entryHooks) for ([j, action] of entryHooks.entries()) {
+					execAction(action);
+					processQueue();
+				}
+				if (invocations.length) launchInvocations(invocations, `${pPath}/${additional.stateName}`, makeFnBaseParam, services, rtOutbound);
+				if (final) {
+					if (!pPath) doneEvent = {
+						type: ":done:",
+						output: typeof final === "function" ? final(makeFnBaseParam()) : void 0
+					};
+					else accReachedFinal.push([
+						pPath,
+						additional.isRegionChild,
+						final
+					]);
+				}
+				i += 1;
+			}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			const pth = "/" + fullToSplittees[i]?.join("/");
+			console.error(`small-state: ${msg}`, {
+				runtimeId: rtOutbound.id,
+				state: pth,
+				location: `entryHooks[${j}]`
+			});
+			throw err;
+		}
+		internalQueue.push(...genChildDoneEvents(accReachedFinal, makeFnBaseParam(), crrStates, stateCatalog));
+	}
+	const alwaysTExecs = evalAlwaysEvent(makeFnBaseParam(), crrStates, guards, stateCatalog);
+	execTExecActions(alwaysTExecs, actionRunner, ":always:");
+	return [
+		alwaysTExecs,
+		!!stChangingTExecs.length,
+		doneEvent
+	];
+}
+//#endregion
+//#region src/runtime/Runtime.ts
+function isRuntime(v) {
+	return v instanceof Runtime;
+}
+function makeRuntime(machine, options) {
+	return new Runtime(machine, options);
+}
+const STOP_EVENT = { type: "system/stop" };
+let idCounter = 0;
+var Runtime = class {
+	id;
+	machine;
+	#machineInternal;
+	#input;
+	#realContext;
+	#crrStates = [];
+	#sentQueue = new MailBox(this.#processSentEvent.bind(this));
+	#enqueueEvent = this.#sentQueue.enqueue.bind(this.#sentQueue);
+	#outbound = {
+		id: "",
+		enqueueEvent: this.#enqueueEvent,
+		emit: this.#_emit.bind(this),
+		children: {}
+	};
+	#subscribers = /* @__PURE__ */ new Set();
+	#emittedListeners = /* @__PURE__ */ new Map();
+	#snapshot = {};
+	get states() {
+		return this.#snapshot.states;
+	}
+	get stateValue() {
+		return this.#snapshot.stateValue;
+	}
+	get context() {
+		return this.#snapshot.context;
+	}
+	get runtimeStatus() {
+		return this.#snapshot.runtimeStatus;
+	}
+	get output() {
+		return this.#snapshot.output;
+	}
+	getSnapshot() {
+		return this.#snapshot;
+	}
+	constructor(machine, { id, input } = {}) {
+		defineFixedProperty(this, "id", id || `${machine.name}:${idCounter++}`, { enumerable: true });
+		defineFixedProperty(this, "machine", machine, { enumerable: true });
+		this.#machineInternal = machine.internal;
+		this.#input = input?.();
+		this.#outbound.id = this.id;
+		const { initContext } = machine.internal;
+		const context = initContext ? initContext(this.#input) : null;
+		this.#buildAndSetSnapshot(context, true, "notStarted")();
+	}
+	subscribe(onSnapshot, onError) {
+		const subscriber = {
+			onSnapshot,
+			onError
+		};
+		this.#subscribers.add(subscriber);
+		return () => {
+			this.#subscribers.delete(subscriber);
+		};
+	}
+	start() {
+		if (this.runtimeStatus !== "notStarted") return this;
+		const result = (() => {
+			try {
+				return initRuntime(this.#realContext, this.#input, this.#crrStates, this.#machineInternal, this.#outbound);
+			} catch (err) {
+				this.#handleError(err);
+			}
+		})();
+		if (!result) return this;
+		const { context, hasTransitioned, doneEvent } = result;
+		this.#buildAndSetSnapshot(context, hasTransitioned, "active")(doneEvent);
+		this.#sentQueue.start();
+		return this;
+	}
+	send(event) {
+		const eventObj = typeof event === "string" ? { type: event } : event;
+		if (this.#snapshot.runtimeStatus !== "active") {
+			console.warn(`RT"${this.id}"> Event "${eventObj.type}" was sent to non-active runtime: ${this.id}`);
+			return this;
+		}
+		this.#enqueueEvent(eventObj);
+		return this;
+	}
+	stop() {
+		if (this.#snapshot.runtimeStatus !== "active") return this;
+		this.#sentQueue.clear();
+		this.#enqueueEvent(STOP_EVENT, {});
+		return this;
+	}
+	onEmitted(emittedEventType, handler) {
+		let listeners = this.#emittedListeners.get(emittedEventType);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.#emittedListeners.set(emittedEventType, listeners);
+		}
+		const handlerWrapper = (emittedEvent) => handler(emittedEvent);
+		listeners.add(handlerWrapper);
+		return () => {
+			listeners.delete(handlerWrapper);
+		};
+	}
+	#processSentEvent(event, internalEPayload) {
+		if (event === STOP_EVENT) {
+			this.#dispose();
+			return this.#buildAndSetSnapshot(this.#realContext, false, "stopped")();
+		}
+		const result = (() => {
+			try {
+				const { guards, actions } = this.#machineInternal;
+				const actionRunner = readyAction(this.#realContext, event, this.#input, guards, actions, this.#outbound);
+				return macrostep(event.type, internalEPayload, this.#crrStates, actionRunner, this.#machineInternal, this.#outbound);
+			} catch (err) {
+				this.#handleError(err);
+			}
+		})();
+		if (!result) return;
+		const { context, crrStates, hasTransitioned, doneEvent } = result;
+		this.#crrStates = crrStates;
+		this.#buildAndSetSnapshot(context, hasTransitioned)(doneEvent);
+	}
+	#dispose() {
+		{
+			const children = { ...this.#outbound.children };
+			for (const id in children) {
+				children[id].stop();
+				delete children[id];
+			}
+			this.#outbound.children = children;
+		}
+		this.#sentQueue.clear();
+		this.#subscribers.clear();
+		this.#emittedListeners.clear();
+	}
+	#_emit(emittedEvent) {
+		const listeners = this.#emittedListeners.get(emittedEvent.type);
+		const wildcardListener = this.#emittedListeners.get("*");
+		if (!(listeners || wildcardListener)) return;
+		for (const handler of [...listeners || [], ...wildcardListener || []]) try {
+			handler(emittedEvent);
+		} catch (err) {
+			reportUnhandledError(err);
+		}
+	}
+	#buildAndSetSnapshot(newRealContext, hasTransitioned, runtimeStatus) {
+		const oldSnapshot = this.#snapshot;
+		const crrStates = this.#crrStates;
+		const states = !hasTransitioned ? oldSnapshot.states : !crrStates.length ? [] : makeStateList(this.#crrStates);
+		let { context } = oldSnapshot;
+		const contextUpdated = newRealContext !== this.#realContext;
+		if (contextUpdated) {
+			this.#realContext = newRealContext;
+			context = !newRealContext ? newRealContext : Object.entries(newRealContext).reduce((acc, [k, v]) => {
+				if (!k.startsWith("_")) acc[k] = v;
+				return acc;
+			}, {});
+		}
+		return (doneEvent) => {
+			if (!(hasTransitioned || contextUpdated || runtimeStatus)) return;
+			const { stateCatalog, output } = this.#machineInternal;
+			const isCompleted = !!(doneEvent || states.length && states.every((stPath) => stateCatalog.get(stPath)?.def.final));
+			this.#snapshot = {
+				runtimeId: this.id,
+				states,
+				get stateValue() {
+					return states.length <= 1 ? states[0] : states;
+				},
+				context,
+				c: context,
+				runtimeStatus: isCompleted ? "done" : runtimeStatus || oldSnapshot.runtimeStatus,
+				output: !(isCompleted && output) ? void 0 : output(runtimeUtils.makeFnBaseParam(newRealContext, doneEvent || {
+					type: ":done:",
+					output: void 0
+				}, this.#input)),
+				error: void 0,
+				_children: this.#outbound.children,
+				_runtime: this
+			};
+			Object.defineProperty(this.#snapshot, "_runtime", { enumerable: false });
+			{
+				const snapshot = this.#snapshot;
+				for (const { onSnapshot } of this.#subscribers) {
+					if (!onSnapshot) continue;
+					try {
+						onSnapshot(snapshot, oldSnapshot);
+					} catch (err) {
+						reportUnhandledError(err);
+					}
+				}
+			}
+			if (isCompleted) this.#dispose();
+		};
+	}
+	#handleError(err) {
+		this.#snapshot = {
+			...this.#snapshot,
+			runtimeStatus: "error",
+			error: err
+		};
+		let shouldReport = !this.#subscribers.size;
+		for (const { onError } of this.#subscribers) {
+			shouldReport ||= !onError;
+			try {
+				onError?.(err);
+			} catch (err2) {
+				reportUnhandledError(err2);
+			}
+		}
+		this.#dispose();
+		if (shouldReport) reportUnhandledError(err);
+	}
+};
+function makeStateList(stateRoute, idx = 0, parent = "") {
+	if (idx >= stateRoute.length) return [parent];
+	const el = stateRoute[idx];
+	if (typeof el === "string") return makeStateList(stateRoute, idx + 1, `${parent}/${el}`);
+	const { parallel, regions } = el;
+	const ret = [];
+	for (const key in regions) ret.push(...makeStateList(regions[key], 0, `${parent}/${parallel}/${key}`));
+	return ret;
+}
+//#endregion
+//#region src/tools/waitFor.ts
+async function waitFor(runtime, cond, options) {
+	if (runtime.runtimeStatus === "notStarted") throw new Error(`RT"${runtime.id}" is not started.`);
+	return new Promise((resolve, reject) => {
+		let done = false;
+		let unsubscribe;
+		const dispose = () => {
+			clearTimeout(timeoutId);
+			done = true;
+			unsubscribe?.();
+		};
+		const check = (snapshot) => {
+			if (!cond(snapshot)) return;
+			dispose();
+			resolve(snapshot);
+		};
+		const timeoutId = !options?.timeout ? void 0 : setTimeout(() => {
+			dispose();
+			reject(`waitFor: timeout of ${options.timeout} ms exceeded`);
+		}, options.timeout);
+		check(runtime.getSnapshot());
+		if (done) return;
+		unsubscribe = runtime.subscribe((snapshot) => {
+			check(snapshot);
+		});
+	});
+}
+//#endregion
+export { defServiceFn, isMachine, isRuntime, makeMachine, makeRuntime, waitFor };