vestjs-runtime 1.7.0 → 2.0.2

package/dist/IsolateSerializer-B1hE3gmT.mjs

@@ -0,0 +1,1004 @@
+import { t as __export } from "./chunk-CLMFDpHK.mjs";
+import { n as IsolateKeys, t as ExcludedFromDump } from "./IsolateKeys-B21aPuBk.mjs";
+import { StateMachine, asArray, assign, bus, deferThrow, dynamicValue, hasOwnProperty, invariant, isFailure, isNotEmpty, isNotNullish, isNullish, isPromise, isStringValue, isUnsafeKey, makeResult, noop, text, tinyState } from "vest-utils";
+import { createCascade } from "context";
+import { expandObject, minifyObject } from "vest-utils/minifyObject";
+
+//#region src/Isolate/IsolateStatus.ts
+const IsolateStatus = {
+	DONE: "DONE",
+	HAS_PENDING: "HAS_PENDING",
+	INITIAL: "INITIAL",
+	PENDING: "PENDING"
+};
+
+//#endregion
+//#region src/Isolate/IsolateInspector.ts
+var IsolateInspector = class IsolateInspector {
+	static at(isolate, at) {
+		if (isNullish(isolate)) return null;
+		return isolate.children?.[at] ?? null;
+	}
+	static cursor(isolate) {
+		if (isNullish(isolate)) return 0;
+		return isolate.children?.length ?? 0;
+	}
+	static canReorder(isolate) {
+		if (isNullish(isolate)) return false;
+		return IsolateInspector.allowsReorder(isolate.parent);
+	}
+	static allowsReorder(isolate) {
+		return isolate?.allowReorder === true;
+	}
+	static usesKey(isolate) {
+		if (isNullish(isolate)) return false;
+		return isNotNullish(isolate.key);
+	}
+	static getChildByKey(isolate, key) {
+		if (isNullish(isolate)) return null;
+		return isolate.keys?.[key] ?? null;
+	}
+	static getStatus(isolate) {
+		if (isNullish(isolate)) return IsolateStatus.INITIAL;
+		return isolate.status ?? IsolateStatus.INITIAL;
+	}
+	static statusEquals(isolate, status) {
+		return IsolateInspector.getStatus(isolate) === status;
+	}
+	static isPending(isolate) {
+		return IsolateInspector.statusEquals(isolate, IsolateStatus.PENDING);
+	}
+	static isHasPending(isolate) {
+		return IsolateInspector.statusEquals(isolate, IsolateStatus.HAS_PENDING);
+	}
+	static hasPending(isolate) {
+		return IsolateInspector.isPending(isolate) || IsolateInspector.isHasPending(isolate);
+	}
+	static hasActiveChildren(isolate) {
+		if (isNullish(isolate) || isNullish(isolate.children)) return false;
+		return isolate.children.some((child) => IsolateInspector.hasPending(child));
+	}
+	static getParent(isolate) {
+		return isolate?.parent ?? null;
+	}
+};
+
+//#endregion
+//#region src/Isolate/IsolateStateMachine.ts
+const machine = {
+	initial: IsolateStatus.INITIAL,
+	states: {
+		[IsolateStatus.DONE]: {},
+		[IsolateStatus.INITIAL]: {
+			[IsolateStatus.PENDING]: IsolateStatus.PENDING,
+			[IsolateStatus.HAS_PENDING]: IsolateStatus.HAS_PENDING,
+			[IsolateStatus.DONE]: IsolateStatus.DONE
+		},
+		[IsolateStatus.PENDING]: { [IsolateStatus.DONE]: IsolateStatus.DONE },
+		[IsolateStatus.HAS_PENDING]: {
+			[IsolateStatus.DONE]: [IsolateStatus.DONE, (isolate) => !IsolateInspector.hasActiveChildren(isolate)],
+			[IsolateStatus.PENDING]: IsolateStatus.PENDING
+		}
+	}
+};
+const IsolateStateMachine = StateMachine(machine);
+
+//#endregion
+//#region src/Isolate/IsolateMutator.ts
+function bubbleUpPending(isolate) {
+	if (isNullish(isolate)) return;
+	if (IsolateInspector.isHasPending(isolate)) return;
+	if (isFailure(IsolateMutator.setHasPending(isolate))) return;
+	bubbleUpPending(isolate.parent);
+}
+function bubbleUpDone(isolate) {
+	if (isNullish(isolate)) return;
+	if (!IsolateInspector.isHasPending(isolate)) return;
+	if (isFailure(IsolateMutator.setStatus(isolate, IsolateStatus.DONE, isolate))) return;
+	bubbleUpDone(isolate.parent);
+}
+var IsolateMutator = class IsolateMutator {
+	static setParent(isolate, parent) {
+		isolate.parent = parent;
+		return isolate;
+	}
+	static saveOutput(isolate, output) {
+		isolate.output = output;
+		return isolate;
+	}
+	static setKey(isolate, key) {
+		isolate.key = key;
+		return isolate;
+	}
+	static addChild(isolate, child) {
+		invariant(isolate);
+		isolate.children = isolate.children ?? [];
+		isolate.children.push(child);
+		IsolateMutator.setParent(child, isolate);
+		if (IsolateInspector.hasPending(child)) bubbleUpPending(isolate);
+	}
+	static removeChild(isolate, node) {
+		isolate.children = isolate.children?.filter((child) => child !== node) ?? null;
+	}
+	static addChildKey(isolate, key, node) {
+		invariant(isolate);
+		isolate.keys = isolate.keys ?? {};
+		isolate.keys[key] = node;
+	}
+	static slice(isolate, at) {
+		if (isNullish(isolate.children)) return;
+		isolate.children.length = at;
+	}
+	static setData(isolate, data) {
+		isolate.data = data;
+	}
+	static abort(isolate, reason) {
+		if (isNullish(isolate.abortController)) return;
+		isolate.abortController.abort(reason);
+	}
+	static setStatus(isolate, status, payload) {
+		if (isolate.status === status) return makeResult.Err(`Isolate status is already ${status}`);
+		isolate.status = IsolateStateMachine.staticTransition(isolate.status ?? IsolateStatus.INITIAL, status, payload);
+		return makeResult.Ok(isolate.status);
+	}
+	static setPending(isolate) {
+		if (isFailure(IsolateMutator.setStatus(isolate, IsolateStatus.PENDING))) return;
+		RuntimeApi.registerPending(isolate);
+		bubbleUpPending(isolate.parent);
+	}
+	static setHasPending(isolate) {
+		return IsolateMutator.setStatus(isolate, IsolateStatus.HAS_PENDING);
+	}
+	static setDone(isolate) {
+		if (isFailure(IsolateMutator.setStatus(isolate, IsolateStatus.DONE, isolate))) return;
+		bubbleUpDone(isolate.parent);
+		RuntimeApi.removePending(isolate);
+	}
+};
+
+//#endregion
+//#region src/IsolateWalker.ts
+var IsolateWalker_exports = /* @__PURE__ */ __export({
+	closest: () => closest,
+	closestExists: () => closestExists,
+	every: () => every,
+	find: () => find,
+	findAll: () => findAll,
+	findClosest: () => findClosest,
+	has: () => has,
+	mapFirst: () => mapFirst,
+	pluck: () => pluck,
+	reduce: () => reduce,
+	some: () => some,
+	walk: () => walk
+});
+/**
+* Walks the isolate tree starting from the given node.
+* @param startNode - The starting node for the traversal.
+* @param callback - The callback function to be called for each visited node.
+* @param visitOnly - Optional predicate to filter which nodes to visit.
+*/
+function walk(startNode, callback, visitOnly) {
+	if (!startNode) return makeResult.Ok(void 0);
+	const stack = [startNode];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		const res = visit(node, visitOnly, callback);
+		if (isFailure(res)) return res;
+		if (node.children) pushChildren(stack, node.children);
+	}
+	return makeResult.Ok(void 0);
+}
+function visit(node, visitOnly, callback) {
+	if (shouldVisit(node, visitOnly)) return callback(node);
+	return makeResult.Ok(void 0);
+}
+function pushChildren(stack, children) {
+	for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+}
+function shouldVisit(node, visitOnly) {
+	return isNullish(visitOnly) || dynamicValue(visitOnly, node);
+}
+/**
+* Reduces the isolate tree to a single value.
+* @param startNode - The starting node for the traversal.
+* @param callback - The reducer function.
+* @param initialValue - The initial value for the accumulator.
+* @param visitOnly - Optional predicate to filter which nodes to visit.
+* @returns The final accumulated value.
+*/
+function reduce(startNode, callback, initialValue, visitOnly) {
+	let acc = initialValue;
+	walk(startNode, (node) => {
+		const res = callback(acc, node);
+		if (isFailure(res)) return makeResult.Err(res.error);
+		acc = res.unwrap();
+		return makeResult.Ok(void 0);
+	}, visitOnly);
+	return acc;
+}
+/**
+* Checks if any node in the tree satisfies the predicate.
+* @param startNode - The starting node for the traversal.
+* @param predicate - The predicate function to test each node.
+* @param visitOnly - Optional predicate to filter which nodes to visit.
+* @returns True if any node satisfies the predicate, false otherwise.
+*/
+function some(startNode, predicate, visitOnly) {
+	let hasMatch = false;
+	walk(startNode, (node) => {
+		if (predicate(node)) {
+			hasMatch = true;
+			return makeResult.Err(void 0);
+		}
+		return makeResult.Ok(void 0);
+	}, visitOnly);
+	return hasMatch;
+}
+/**
+* Checks if the tree contains a node that matches the predicate.
+* @param startNode - The starting node for the traversal.
+* @param match - The predicate function to match nodes.
+* @returns True if a matching node is found, false otherwise.
+*/
+function has(startNode, match) {
+	return some(startNode, () => true, match);
+}
+/**
+* Traverses up the tree to find the closest ancestor that satisfies the predicate,
+* then returns the first direct descendant of that ancestor that satisfies the predicate.
+* @param startNode - The starting node.
+* @param predicate - The predicate to match.
+* @returns The found node or null.
+*/
+function findClosest(startNode, predicate) {
+	let found = null;
+	let current = startNode;
+	while (current) {
+		found = current.children?.find(predicate) ?? null;
+		if (found) break;
+		current = current.parent;
+	}
+	return found;
+}
+/**
+* Finds the first node in the tree that satisfies the predicate.
+* @param startNode - The starting node.
+* @param predicate - The predicate to match.
+* @param visitOnly - Optional predicate to filter which nodes to visit.
+* @returns The found node or null.
+*/
+function find(startNode, predicate, visitOnly) {
+	let found = null;
+	walk(startNode, (node) => {
+		if (predicate(node)) {
+			found = node;
+			return makeResult.Err(void 0);
+		}
+		return makeResult.Ok(void 0);
+	}, visitOnly);
+	return found;
+}
+/**
+* Finds all nodes in the tree that satisfy the predicate.
+* @param startNode - The starting node.
+* @param predicate - The predicate to match.
+* @param visitOnly - Optional predicate to filter which nodes to visit.
+* @returns An array of found nodes.
+*/
+function findAll(startNode, predicate, visitOnly) {
+	const found = [];
+	walk(startNode, (node) => {
+		if (predicate(node)) found.push(node);
+		return makeResult.Ok(void 0);
+	}, visitOnly);
+	return found;
+}
+/**
+* Checks if every node in the tree satisfies the predicate.
+* @param startNode - The starting node.
+* @param predicate - The predicate to match.
+* @param visitOnly - Optional predicate to filter which nodes to visit.
+* @returns True if all nodes satisfy the predicate, false otherwise.
+*/
+function every(startNode, predicate, visitOnly) {
+	let hasMatch = true;
+	walk(startNode, (node) => {
+		if (!predicate(node)) {
+			hasMatch = false;
+			return makeResult.Err(void 0);
+		}
+		return makeResult.Ok(void 0);
+	}, visitOnly);
+	return hasMatch;
+}
+/**
+* Removes nodes from the tree that satisfy the predicate.
+* @param startNode - The starting node.
+* @param predicate - The predicate to match nodes to remove.
+* @param visitOnly - Optional predicate to filter which nodes to visit.
+*/
+function pluck(startNode, predicate, visitOnly) {
+	walk(startNode, (node) => {
+		if (predicate(node) && node.parent) IsolateMutator.removeChild(node.parent, node);
+		return makeResult.Ok(void 0);
+	}, visitOnly);
+}
+/**
+* Finds the closest ancestor of the startNode that satisfies the predicate.
+* @param startNode - The starting node.
+* @param predicate - The predicate to match.
+* @returns The found ancestor or null.
+*/
+function closest(startNode, predicate) {
+	let current = startNode;
+	do {
+		if (predicate(current)) return current;
+		current = current.parent;
+	} while (current);
+	return null;
+}
+/**
+* Checks if an ancestor satisfying the predicate exists.
+* @param startNode - The starting node.
+* @param predicate - The predicate to match.
+* @returns True if such an ancestor exists, false otherwise.
+*/
+function closestExists(startNode, predicate) {
+	return !!closest(startNode, predicate);
+}
+/**
+* Traverses the tree and returns the first non-nullish value returned by the callback.
+* It optimizes traversal by only visiting nodes that have pending isolates or are pending themselves.
+*/
+function mapFirst(startNode, callback) {
+	const stack = [startNode];
+	let result = null;
+	const breakout = (value) => result = { value };
+	while (stack.length > 0) {
+		if (result) break;
+		processNode(stack.pop(), stack, callback, breakout);
+	}
+	return result?.value ?? null;
+}
+function processNode(node, stack, callback, breakout) {
+	if (!IsolateInspector.hasPending(node)) return;
+	runCallback(node, callback, breakout);
+	if (node.children) pushChildren(stack, node.children);
+}
+function runCallback(node, callback, breakout) {
+	if (IsolateInspector.isPending(node)) callback(node, breakout);
+}
+
+//#endregion
+//#region src/Isolate/IsolateTransient.ts
+/**
+* Creates a transient isolate.
+*
+* Transient isolates are isolates that:
+* 1. Do not persist in the history tree.
+* 2. Are not reconciled with previous runs.
+* 3. Do not appear in the serialized suite dump.
+* 4. Do not interfere with the index of their siblings (they are skipped by the reconciler).
+*
+* This is useful for "structural" isolates that are used for control flow or grouping
+* but do not hold state that needs to be preserved between runs, such as `focused` (skip/only) isolates.
+*/
+function IsolateTransient(callback, type = "Transient", payload = {}) {
+	return Isolate.create(type, callback, {
+		...payload,
+		transient: true
+	});
+}
+
+//#endregion
+//#region src/Isolate/IsolateFocused.ts
+const VestIsolateTypeFocused = "Focused";
+let FocusModes = /* @__PURE__ */ function(FocusModes$1) {
+	FocusModes$1["SKIP"] = "skip";
+	FocusModes$1["ONLY"] = "only";
+	return FocusModes$1;
+}({});
+/**
+* Creates a focused isolate.
+* Focused isolates are transient because they only affect the current run
+* and do not need to be preserved in history or appearing in the suite result.
+*/
+function IsolateFocused(focusMode, match) {
+	const matchedFields = asArray(match).filter(isStringValue).filter(isNotEmpty);
+	const matchAll = match === true;
+	if (!isNotEmpty(matchedFields) && !matchAll) return;
+	return IsolateTransient(noop, VestIsolateTypeFocused, {
+		focusMode,
+		match: matchedFields,
+		matchAll
+	});
+}
+var FocusSelectors = class {
+	static isSkipFocused(focus, fieldName) {
+		if (!focus) return false;
+		const data = focus.data;
+		if (!data || data.focusMode !== FocusModes.SKIP) return false;
+		if (data.matchAll) return true;
+		return hasFocus(focus, fieldName);
+	}
+	static isOnlyFocused(focus, fieldName) {
+		if (!focus) return false;
+		const data = focus.data;
+		if (!data || data.focusMode !== FocusModes.ONLY) return false;
+		if (data.matchAll) return true;
+		return hasFocus(focus, fieldName);
+	}
+	static isIsolateFocused(isolate) {
+		return isolate[IsolateKeys.Type] === VestIsolateTypeFocused;
+	}
+};
+function hasFocus(focus, fieldName) {
+	const match = asArray(focus?.data?.match);
+	if (!match.length) return false;
+	return !fieldName || match.includes(fieldName);
+}
+
+//#endregion
+//#region src/errors/ErrorStrings.ts
+let ErrorStrings = /* @__PURE__ */ function(ErrorStrings$1) {
+	ErrorStrings$1["NO_ACTIVE_ISOLATE"] = "Not within an active isolate";
+	ErrorStrings$1["UNABLE_TO_PICK_NEXT_ISOLATE"] = "Unable to pick next isolate. This is a bug, please report it to the Vest maintainers.";
+	ErrorStrings$1["ENCOUNTERED_THE_SAME_KEY_TWICE"] = "Encountered the same key \"{key}\" twice. This may lead to inconsistent or overriding of results.";
+	ErrorStrings$1["INVALID_ISOLATE_CANNOT_PARSE"] = "Invalid isolate was passed to IsolateSerializer. Cannot proceed.";
+	return ErrorStrings$1;
+}({});
+
+//#endregion
+//#region src/Orchestrator/RuntimeStates.ts
+let RuntimeState = /* @__PURE__ */ function(RuntimeState$1) {
+	RuntimeState$1["PENDING"] = "PENDING";
+	RuntimeState$1["STABLE"] = "STABLE";
+	return RuntimeState$1;
+}({});
+
+//#endregion
+//#region src/VestRuntime.ts
+const PersistedContext = createCascade((stateRef, parentContext) => {
+	if (parentContext) return null;
+	invariant(stateRef.historyRoot);
+	const ref = stateRef;
+	const [historyRootNode] = ref.historyRoot();
+	ref.implicitOnlyNodes.clear();
+	const ctxRef = {};
+	assign(ctxRef, {
+		historyNode: historyRootNode,
+		runtimeNode: null,
+		runtimeRoot: null,
+		stateRef
+	});
+	return ctxRef;
+});
+/**
+* Runs a function within the Vest runtime context.
+* This is the main entry point for executing Vest suites.
+*/
+const Run = PersistedContext.run;
+/**
+* Retrieves the current runtime state (e.g., STABLE, PENDING).
+*/
+function useRuntimeState() {
+	return useIsStable() ? RuntimeState.STABLE : RuntimeState.PENDING;
+}
+/**
+* Checks if the runtime is currently stable (no pending tests).
+*/
+function useIsStable() {
+	const root = useAvailableRoot();
+	if (!root) return true;
+	return !IsolateInspector.hasPending(root);
+}
+/**
+* Retrieves the application-specific data stored in the runtime.
+*/
+function useXAppData() {
+	return useX().stateRef.appData;
+}
+/**
+* Creates a new state reference for such as the history root, pending isolates, and the current runtime state.
+*/
+function createRef(Reconciler$1, setter) {
+	return Object.freeze({
+		Bus: bus.createBus(),
+		Reconciler: Reconciler$1,
+		appData: dynamicValue(setter),
+		historyRoot: tinyState.createTinyState(null),
+		implicitOnlyNodes: /* @__PURE__ */ new Set()
+	});
+}
+/**
+* Dispatches a runtime event to the internal Bus.
+* This is used to trigger state changes and notifications.
+*/
+function dispatch(event) {
+	useX().stateRef.Bus.emit(event.type, event.payload);
+}
+/**
+* Registers an isolate as pending.
+* This is used to track async tests and other async operations.
+*/
+function registerPending(isolate) {
+	dispatch({
+		type: "ISOLATE_PENDING",
+		payload: isolate
+	});
+}
+/**
+* Removes an isolate from the pending set.
+* This is used when an async test or operation completes.
+*/
+function removePending(isolate) {
+	dispatch({
+		type: "ISOLATE_DONE",
+		payload: isolate
+	});
+}
+/**
+* Retrieves the Reconciler used by the current runtime.
+*/
+function useReconciler() {
+	return useX().stateRef.Reconciler;
+}
+/**
+* Persists the current runtime context to a callback function.
+* This allows the callback to be executed later (e.g. in an async operation)
+* while still having access to the correct runtime context.
+*/
+function persist(cb) {
+	const prev = PersistedContext.useX();
+	return ((...args) => {
+		const ctxToUse = PersistedContext.use() ?? prev;
+		return PersistedContext.run(ctxToUse.stateRef, () => cb(...args));
+	});
+}
+/**
+* Retrieves the current runtime context.
+* Throws if called outside of a Vest runtime.
+*/
+function useX() {
+	return PersistedContext.useX();
+}
+/**
+* Retrieves the history root state.
+*/
+function useHistoryRoot() {
+	return useX().stateRef.historyRoot();
+}
+/**
+* Retrieves the current history isolate (the one matching the current runtime isolate).
+*/
+function useHistoryIsolate() {
+	return useX().historyNode;
+}
+/**
+* Returns the history isolate at the current position.
+* If there is a parent isolate, it returns the history node from the parent's children.
+* Otherwise, it returns the history node.
+* @returns {Nullable<TIsolate>} The history isolate at the current position.
+*/
+function useHistoryIsolateAtCurrentPosition() {
+	const parent = useIsolate();
+	const historyNode = useHistoryIsolate();
+	if (!parent) return historyNode;
+	if (isNullish(historyNode)) return null;
+	const nonTransientIndex = countNonTransientBefore(parent.children || [], IsolateInspector.cursor(parent));
+	return findNthNonTransient(historyNode.children || [], nonTransientIndex);
+}
+/**
+* Counts non-transient children before the given cursor position.
+*/
+function countNonTransientBefore(siblings, cursor) {
+	let count = 0;
+	for (let i = 0; i < cursor; i++) if (!siblings[i]?.transient) count++;
+	return count;
+}
+/**
+* Finds the Nth non-transient child in a children array.
+* This is used to align the reconciler cursor, skipping over
+* transient nodes that should not affect the index of stateful nodes.
+*/
+function findNthNonTransient(children, n) {
+	return children.filter((child) => child && !child.transient)[n] ?? null;
+}
+/**
+* Sets the history root for the runtime.
+* This is used to hydrate the runtime with previous results.
+*/
+function useSetHistoryRoot(history) {
+	const [, setHistoryRoot] = useHistoryRoot();
+	setHistoryRoot(history);
+}
+/**
+* Retrieves the currently active isolate in the runtime tree.
+*/
+function useIsolate() {
+	return useX().runtimeNode ?? null;
+}
+/**
+* Retrieves the current cursor position within the active isolate.
+*/
+function useCurrentCursor() {
+	const isolate = useIsolate();
+	return isolate ? IsolateInspector.cursor(isolate) : 0;
+}
+/**
+* Retrieves the root of the current runtime tree.
+*/
+function useRuntimeRoot() {
+	return useX().runtimeRoot;
+}
+/**
+* Adds a child isolate to the current isolate and sets the parent-child relationship.
+*/
+function useSetNextIsolateChild(child) {
+	const currentIsolate = useIsolate();
+	invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
+	IsolateMutator.addChild(currentIsolate, child);
+	IsolateMutator.setParent(child, currentIsolate);
+	if (FocusSelectors.isIsolateFocused(child) && child.data?.focusMode === FocusModes.ONLY) useX().stateRef.implicitOnlyNodes.add(currentIsolate);
+}
+/**
+* Sets a key for a child isolate within the current isolate.
+* Throws if the key is already taken.
+*/
+function useSetIsolateKey(key, node) {
+	if (!key) return;
+	const currentIsolate = useIsolate();
+	invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
+	if (isNullish(IsolateInspector.getChildByKey(currentIsolate, key))) {
+		IsolateMutator.addChildKey(currentIsolate, key, node);
+		return;
+	}
+	deferThrow(text(ErrorStrings.ENCOUNTERED_THE_SAME_KEY_TWICE, { key }));
+}
+/**
+* Returns the available root isolate.
+* If a runtime root exists (i.e. we are currently running a suite), it returns that.
+* Otherwise, it returns the history root (i.e. the result of the last run).
+*/
+function useAvailableRoot() {
+	const root = useRuntimeRoot();
+	if (root) return root;
+	const [historyRoot] = useHistoryRoot();
+	return historyRoot;
+}
+/**
+* Checks whether a specific key is heavily focused out.
+*/
+function useIsFocusedOut(key) {
+	const current = useIsolate();
+	if (!current) return false;
+	const focusMatch = findClosest(current, (child) => {
+		if (!FocusSelectors.isIsolateFocused(child)) return false;
+		const data = child.data;
+		if (!data) return false;
+		if (data.matchAll) return true;
+		if (isNullish(key)) return false;
+		return asArray(data.match).includes(key);
+	});
+	if (focusMatch) {
+		if (FocusSelectors.isSkipFocused(focusMatch, key)) return true;
+		if (FocusSelectors.isOnlyFocused(focusMatch, key)) return false;
+	}
+	return hasImplicitOnly();
+}
+function hasImplicitOnly() {
+	let current = useIsolate();
+	const registry = useX().stateRef.implicitOnlyNodes;
+	while (current) {
+		if (registry.has(current)) return true;
+		current = current.parent;
+	}
+	return false;
+}
+/**
+* Resets the history root.
+*/
+function reset() {
+	const [, , resetHistoryRoot] = useHistoryRoot();
+	resetHistoryRoot();
+}
+const RuntimeApi = {
+	Run,
+	createRef,
+	dispatch,
+	hasImplicitOnly,
+	persist,
+	registerPending,
+	removePending,
+	reset,
+	useAvailableRoot,
+	useCurrentCursor,
+	useHistoryRoot,
+	useIsFocusedOut,
+	useIsStable,
+	useRuntimeState,
+	useSetHistoryRoot,
+	useSetNextIsolateChild,
+	useXAppData
+};
+
+//#endregion
+//#region src/Bus.ts
+var Bus_exports = /* @__PURE__ */ __export({
+	useBus: () => useBus,
+	useEmit: () => useEmit,
+	usePrepareEmitter: () => usePrepareEmitter
+});
+function useBus() {
+	return useX().stateRef.Bus;
+}
+function useEmit(event, data) {
+	const emit = useBus().emit;
+	if (!isNullish(event)) emit(event, data);
+	return persist(emit);
+}
+function usePrepareEmitter(event) {
+	const emit = useEmit();
+	return (arg) => emit(event, arg);
+}
+
+//#endregion
+//#region src/Isolate/IsolateIndexer.ts
+function createHistoryIndex(children) {
+	const index = /* @__PURE__ */ new Map();
+	if (!children) return index;
+	for (const child of children) addToIndex(index, child);
+	return index;
+}
+function addToIndex(index, isolate) {
+	const { key } = isolate;
+	if (isNullish(key)) return;
+	const existing = index.get(key);
+	if (existing) if (Array.isArray(existing)) existing.push(isolate);
+	else index.set(key, [existing, isolate]);
+	else index.set(key, isolate);
+}
+
+//#endregion
+//#region src/Isolate/IsolateSelectors.ts
+var IsolateSelectors_exports = /* @__PURE__ */ __export({
+	isIsolateType: () => isIsolateType,
+	isSameIsolateIdentity: () => isSameIsolateIdentity,
+	isSameIsolateType: () => isSameIsolateType
+});
+function isIsolateType(node, type) {
+	return node?.[IsolateKeys.Type] === type;
+}
+function isSameIsolateType(a, b) {
+	return isIsolateType(a, b[IsolateKeys.Type]);
+}
+function isSameIsolateIdentity(a, b) {
+	return Object.is(a, b) || isSameIsolateType(a, b) && a.key === b.key;
+}
+
+//#endregion
+//#region src/Reconciler.ts
+function BaseReconciler(currentNode, historyNode) {
+	if (isNullish(historyNode)) return currentNode;
+	return currentNode;
+}
+var Reconciler = class {
+	/**
+	* Reconciles the current isolate with the history isolate.
+	* If the current isolate is of a different type than the history isolate,
+	* the current isolate is returned.
+	* Otherwise, the reconciler function is called to determine the next isolate.
+	* If the reconciler function returns null or undefined, the base reconciler is used.
+	* If no history isolate exists, the current isolate is returned.
+	* @param node The current isolate to reconcile.
+	* @returns The next isolate after reconciliation.
+	*/
+	static reconcile(node) {
+		if (node.transient) return node;
+		const nextNodeResult = pickNextNode(node, useHistoryIsolateAtCurrentPosition());
+		invariant(nextNodeResult, ErrorStrings.UNABLE_TO_PICK_NEXT_ISOLATE);
+		return nextNodeResult;
+	}
+	static dropNextNodesOnReorder(reorderLogic, newNode, prevNode) {
+		const didReorder = reorderLogic(newNode, prevNode);
+		if (didReorder) removeAllNextNodesInIsolate();
+		return didReorder;
+	}
+	static handleIsolateNodeWithKey(node, revoke) {
+		invariant(IsolateInspector.usesKey(node));
+		const prevNodeByKey = getNodeByKey(node.key);
+		let nextNode = node;
+		if (!isNullish(prevNodeByKey) && !dynamicValue(revoke, prevNodeByKey)) nextNode = prevNodeByKey;
+		useSetIsolateKey(node.key, nextNode);
+		return nextNode;
+	}
+};
+function pickNextNode(currentNode, historyNode) {
+	if (isNullish(historyNode)) return handleNoHistoryNode(currentNode);
+	if (!isSameIsolateType(currentNode, historyNode)) return currentNode;
+	return useReconciler()(currentNode, historyNode) ?? BaseReconciler(currentNode, historyNode);
+}
+function handleNoHistoryNode(newNode) {
+	if (IsolateInspector.usesKey(newNode)) return Reconciler.handleIsolateNodeWithKey(newNode, false);
+	return newNode;
+}
+function removeAllNextNodesInIsolate() {
+	const currentNode = useIsolate();
+	const historyNode = useHistoryIsolate();
+	if (!historyNode || !currentNode)
+ /* istanbul ignore next */
+	return;
+	IsolateMutator.slice(historyNode, IsolateInspector.cursor(currentNode));
+}
+const historyIndexCache = /* @__PURE__ */ new WeakMap();
+function getNodeByKey(key) {
+	const historyParent = useHistoryIsolate();
+	if (isNullish(key) || !historyParent) return null;
+	const match = getHistoryIndex(historyParent).get(key);
+	if (!match) return null;
+	if (Array.isArray(match)) return match[0];
+	return match;
+}
+function getHistoryIndex(historyParent) {
+	let index = historyIndexCache.get(historyParent);
+	if (!index) {
+		index = createHistoryIndex(historyParent.children);
+		historyIndexCache.set(historyParent, index);
+	}
+	return index;
+}
+
+//#endregion
+//#region src/Isolate/Isolate.ts
+let _IsolateKeys$Keys, _IsolateKeys$Parent, _IsolateKeys$AllowReo, _IsolateKeys$Transien, _IsolateKeys$Status, _IsolateKeys$AbortCon;
+var Isolate = class {
+	static create(type, callback, payload = void 0, key) {
+		const parent = useIsolate();
+		const newCreatedNode = IsolateMutator.setParent(baseIsolate(type, payload, key), parent);
+		const nextIsolateChild = Reconciler.reconcile(newCreatedNode);
+		const localHistoryNode = useHistoryIsolateAtCurrentPosition();
+		const shouldRunNew = Object.is(nextIsolateChild, newCreatedNode);
+		if (parent) useSetNextIsolateChild(nextIsolateChild);
+		let output;
+		if (shouldRunNew) output = useRunAsNew(localHistoryNode, newCreatedNode, callback);
+		else {
+			const emit = useEmit();
+			output = nextIsolateChild.output;
+			emit("ISOLATE_RECONCILED", nextIsolateChild);
+		}
+		IsolateMutator.saveOutput(nextIsolateChild, output);
+		if (!parent) useSetHistoryRoot(nextIsolateChild);
+		return nextIsolateChild;
+	}
+	static isIsolate(node) {
+		return isNotNullish(node) && node[IsolateKeys.Type];
+	}
+};
+/**
+* Creates a new child isolate context where the local history node is the current history node, thus advancing the history cursor.
+* Runs the callback function and returns its output.
+* @param localHistoryNode The local history node.
+* @param current The current isolate.
+* @param callback The callback function to execute.
+* @returns The output of the callback function.
+*/
+function useRunAsNew(localHistoryNode, current, callback) {
+	const runtimeRoot = useRuntimeRoot();
+	const output = Run({
+		historyNode: localHistoryNode,
+		runtimeNode: current,
+		...!runtimeRoot && { runtimeRoot: current }
+	}, () => useRunAsNewCallback(current, callback));
+	current.output = output;
+	return output;
+}
+function useRunAsNewCallback(current, callback) {
+	const emit = useEmit();
+	emit("ISOLATE_ENTER", current);
+	const output = callback(current);
+	if (isPromise(output)) {
+		emit("ISOLATE_PENDING", current);
+		IsolateMutator.setPending(current);
+		output.then(persist((iso) => {
+			if (Isolate.isIsolate(iso)) IsolateMutator.addChild(current, iso);
+			IsolateMutator.setDone(current);
+			emit("ASYNC_ISOLATE_DONE", current);
+		}), persist(() => {
+			IsolateMutator.setDone(current);
+			emit("ASYNC_ISOLATE_DONE", current);
+		}));
+	} else IsolateMutator.setDone(current);
+	return output;
+}
+var IsolateInstance = class {
+	static {
+		IsolateKeys.Type, _IsolateKeys$Keys = IsolateKeys.Keys, _IsolateKeys$Parent = IsolateKeys.Parent, _IsolateKeys$AllowReo = IsolateKeys.AllowReorder, _IsolateKeys$Transien = IsolateKeys.Transient, _IsolateKeys$Status = IsolateKeys.Status, _IsolateKeys$AbortCon = IsolateKeys.AbortController, IsolateKeys.Data;
+	}
+	constructor(type, payload = void 0, key = null) {
+		this.children = null;
+		this[_IsolateKeys$Keys] = null;
+		this[_IsolateKeys$Parent] = null;
+		this.output = null;
+		this.key = null;
+		this[_IsolateKeys$AllowReo] = void 0;
+		this[_IsolateKeys$Transien] = void 0;
+		this[_IsolateKeys$Status] = IsolateStatus.INITIAL;
+		this[_IsolateKeys$AbortCon] = null;
+		this[IsolateKeys.Type] = type;
+		this.key = key;
+		const { allowReorder, transient, status, ...data } = payload ?? {};
+		this[IsolateKeys.AllowReorder] = allowReorder;
+		this[IsolateKeys.Transient] = transient;
+		if (status) this[IsolateKeys.Status] = status;
+		this[IsolateKeys.Data] = data;
+	}
+};
+function baseIsolate(type, payload = void 0, key = null) {
+	return new IsolateInstance(type, payload, key);
+}
+
+//#endregion
+//#region src/exports/IsolateSerializer.ts
+var IsolateSerializer = class IsolateSerializer {
+	static safeDeserialize(node) {
+		try {
+			const expanded = expandNode(node);
+			if (isFailure(IsolateSerializer.validateIsolate(expanded))) return makeResult.Err(new Error(ErrorStrings.INVALID_ISOLATE_CANNOT_PARSE));
+			return makeResult.Ok(hydrateIsolate(expanded));
+		} catch (error) {
+			return makeResult.Err(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	static deserialize(node) {
+		return IsolateSerializer.safeDeserialize(node).unwrap();
+	}
+	static serialize(isolate, replacer) {
+		if (isNullish(isolate)) return "";
+		const minified = minifyObject(isolate, (value, key) => {
+			if (ExcludedFromDump.has(key)) return;
+			if (value?.transient) return;
+			if (replacer) return replacer(value, key);
+			return value;
+		});
+		return JSON.stringify(minified);
+	}
+	static validateIsolate(node) {
+		return hasOwnProperty(node, IsolateKeys.Type) ? makeResult.Ok(node) : makeResult.Err(text(ErrorStrings.INVALID_ISOLATE_CANNOT_PARSE));
+	}
+};
+function processChildren(current, queue) {
+	const children = current.children;
+	if (!children) return;
+	current.children = children.map((child) => {
+		const nextChild = { ...child };
+		IsolateMutator.setParent(nextChild, current);
+		queue.push(nextChild);
+		if (nextChild.key) {
+			current.keys = current.keys ?? {};
+			current.keys[nextChild.key] = nextChild;
+		}
+		return nextChild;
+	});
+}
+function hydrateIsolate(root) {
+	const queue = [root];
+	while (queue.length) {
+		const current = queue.shift();
+		if (current) processChildren(current, queue);
+	}
+	return root;
+}
+function expandNode(node) {
+	const parsed = isStringValue(node) ? JSON.parse(node, safeReviver) : { ...node };
+	const root = Array.isArray(parsed) ? parsed : [parsed, {}];
+	return expandObject(root[0], root[1]);
+}
+function safeReviver(key, value) {
+	if (isUnsafeKey(key)) return;
+	return value;
+}
+
+//#endregion
+export { Bus_exports as a, FocusModes as c, IsolateTransient as d, IsolateWalker_exports as f, IsolateStatus as g, IsolateInspector as h, IsolateSelectors_exports as i, FocusSelectors as l, IsolateStateMachine as m, Isolate as n, RuntimeApi as o, IsolateMutator as p, Reconciler as r, useAvailableRoot as s, IsolateSerializer as t, IsolateFocused as u };
+//# sourceMappingURL=IsolateSerializer-B1hE3gmT.mjs.map