vestjs-runtime 1.6.0 → 1.7.0

package/types/vestjs-runtime.d.ts

@@ -1,372 +1,278 @@
-import { a as IsolateStatus, i as TIsolate, n as IsolateKey, o as IsolateKeys, r as IsolatePayload, t as Isolate } from "./Isolate-HYIh82M8.cjs";
-import { t as IsolateSerializer } from "./IsolateSerializer-CQpP6A4m.cjs";
-import { BusType, CB, DynamicValue, Maybe, Nullable, Nullish, OneOrMoreOf, Result, TinyState } from "vest-utils";
-
-//#region rolldown:runtime
-//#endregion
-//#region src/RuntimeEvents.d.ts
-type RuntimeEvents = {
-  ASYNC_ISOLATE_DONE: TIsolate;
-  ISOLATE_DONE: TIsolate;
-  ISOLATE_ENTER: TIsolate;
-  ISOLATE_PENDING: TIsolate;
-  ISOLATE_RECONCILED: TIsolate;
+/// <reference types="node" />
+import { CB, Maybe, Nullable, TinyState, BusType, DynamicValue } from "vest-utils";
+declare const RuntimeEvents: {
+    ASYNC_ISOLATE_DONE: string;
+    ISOLATE_DONE: string;
+    ISOLATE_ENTER: string;
+    ISOLATE_PENDING: string;
 };
-//#endregion
-//#region src/Reconciler.d.ts
-interface IReconciler<I = any> {
-  (currentNode: I, historyNode: I): Nullable<I>;
+declare enum IsolateKeys {
+    Type = "$type",
+    Keys = "keys",
+    Key = "key",
+    Parent = "parent",
+    Data = "data",
+    AllowReorder = "allowReorder",
+    Status = "status",
+    AbortController = "abortController",
+    Children = "children"
 }
-declare class Reconciler {
-  /**
-   * 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: TIsolate): TIsolate;
-  static dropNextNodesOnReorder<I extends TIsolate>(reorderLogic: (newNode: I, prevNode: Maybe<TIsolate>) => boolean, newNode: I, prevNode: Maybe<TIsolate>): boolean;
-  static handleIsolateNodeWithKey<I extends TIsolate>(node: TIsolate, revoke: ((node: I) => boolean) | false): TIsolate;
+type IsolateKey = Nullable<string>;
+type TIsolate<P extends IsolatePayload = IsolatePayload> = {
+    [IsolateKeys.AllowReorder]?: boolean;
+    [IsolateKeys.Parent]: Nullable<TIsolate>;
+    [IsolateKeys.Type]: string;
+    [IsolateKeys.Keys]: Nullable<Record<string, TIsolate>>;
+    [IsolateKeys.Data]: DataOnly<P>;
+    [IsolateKeys.Status]?: string;
+    [IsolateKeys.AbortController]: AbortController;
+    children: Nullable<TIsolate[]>;
+    key: IsolateKey;
+    output: any;
+} & UsedFeaturesOnly<P>;
+type DataOnly<P extends IsolatePayload> = Omit<P, keyof IsolateFeatures>;
+type UsedFeaturesOnly<P extends IsolatePayload> = Pick<P, keyof IsolateFeatures>;
+declare class Isolate {
+    // eslint-disable-next-line max-statements
+    static create<Payload extends IsolatePayload>(type: string, callback: CB, payload?: Maybe<Payload>, key?: IsolateKey): TIsolate<Payload>;
+    static isIsolate(node: any): node is TIsolate;
+}
+type IsolateData = Record<string, any>;
+type IsolatePayload = IsolateData & IsolateFeatures;
+type IsolateFeatures = {
+    [IsolateKeys.AllowReorder]?: boolean;
+    [IsolateKeys.Status]?: string;
+};
+// import { isSameIsolateType } from 'IsolateSelectors';
+// I would rather not use `any` here, but instead use `Isolate`.
+// The problem is that it breaks the actual implementation of `Isolate` in `IsolateTest`
+// As it is not properly extending `Isolate`.
+interface IRecociler<I = any> {
+    (currentNode: I, historyNode: I): Nullable<I>;
 }
-declare namespace IsolateWalker_d_exports {
-  export { closest, closestExists, every, find, findAll, findClosest, has, mapFirst, pluck, reduce, some, walk };
+declare class Reconciler {
+    /**
+     * 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: TIsolate): TIsolate;
+    static dropNextNodesOnReorder<I extends TIsolate>(reorderLogic: (newNode: I, prevNode: Maybe<TIsolate>) => boolean, newNode: I, prevNode: Maybe<TIsolate>): boolean;
+    static handleIsolateNodeWithKey<I extends TIsolate>(node: TIsolate, 
+    // The revoke function allows the caller to revoke the previous node
+    revoke: ((node: I) => boolean) | false): TIsolate;
 }
-type VisitOnlyPredicate = (isolate: TIsolate) => boolean;
-/**
- * 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.
- */
-declare function walk(startNode: TIsolate, callback: (isolate: TIsolate) => Result<void>, visitOnly?: VisitOnlyPredicate): Result<void>;
-/**
- * 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.
- */
-declare function reduce<T>(startNode: TIsolate, callback: (acc: T, isolate: TIsolate) => Result<T>, initialValue: T, visitOnly?: VisitOnlyPredicate): T;
-/**
- * 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.
- */
-declare function some(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): boolean;
-/**
- * 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.
- */
-declare function has(startNode: TIsolate, match: VisitOnlyPredicate): boolean;
-/**
- * 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.
- */
-declare function findClosest<I extends TIsolate = TIsolate>(startNode: TIsolate, predicate: (node: TIsolate) => boolean): Nullable<I>;
-/**
- * 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.
- */
-declare function find(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): Nullable<TIsolate>;
-/**
- * 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.
- */
-declare function findAll(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): TIsolate[];
-/**
- * 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.
- */
-declare function every(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): boolean;
-/**
- * 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.
- */
-declare function pluck(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): void;
-/**
- * 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.
- */
-declare function closest<I extends TIsolate = TIsolate>(startNode: TIsolate, predicate: (node: TIsolate) => boolean): Nullable<I>;
-/**
- * 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.
- */
-declare function closestExists(startNode: TIsolate, predicate: (node: TIsolate) => boolean): boolean;
-/**
- * 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.
- */
-declare function mapFirst<T>(startNode: TIsolate, callback: (isolate: TIsolate, breakout: (value: T) => void) => void): T | null;
-//#endregion
-//#region src/Orchestrator/RuntimeStates.d.ts
-declare enum RuntimeState {
-  PENDING = "PENDING",
-  STABLE = "STABLE",
+declare namespace Walker {
+    enum IsolateKeys {
+        Type = "$type",
+        Keys = "keys",
+        Key = "key",
+        Parent = "parent",
+        Data = "data",
+        AllowReorder = "allowReorder",
+        Status = "status",
+        AbortController = "abortController",
+        Children = "children"
+    }
+    const ExcludedFromDump: Set<IsolateKeys>;
+    type IsolateKey = Nullable<string>;
+    type TIsolate<P extends IsolatePayload = IsolatePayload> = {
+        [IsolateKeys.AllowReorder]?: boolean;
+        [IsolateKeys.Parent]: Nullable<TIsolate>;
+        [IsolateKeys.Type]: string;
+        [IsolateKeys.Keys]: Nullable<Record<string, TIsolate>>;
+        [IsolateKeys.Data]: DataOnly<P>;
+        [IsolateKeys.Status]?: string;
+        [IsolateKeys.AbortController]: AbortController;
+        children: Nullable<TIsolate[]>;
+        key: IsolateKey;
+        output: any;
+    } & UsedFeaturesOnly<P>;
+    type DataOnly<P extends IsolatePayload> = Omit<P, keyof IsolateFeatures>;
+    type UsedFeaturesOnly<P extends IsolatePayload> = Pick<P, keyof IsolateFeatures>;
+    class Isolate {
+        // eslint-disable-next-line max-statements
+        static create<Payload extends IsolatePayload>(type: string, callback: CB, payload?: Maybe<Payload>, key?: IsolateKey): TIsolate<Payload>;
+        static isIsolate(node: any): node is TIsolate;
+    }
+    type IsolateData = Record<string, any>;
+    type IsolatePayload = IsolateData & IsolateFeatures;
+    type IsolateFeatures = {
+        [IsolateKeys.AllowReorder]?: boolean;
+        [IsolateKeys.Status]?: string;
+    };
+    type VisitOnlyPredicate = (isolate: TIsolate) => boolean;
+    // eslint-disable-next-line
+    function walk(startNode: TIsolate, callback: (isolate: TIsolate, breakout: CB<void>) => void, visitOnly?: VisitOnlyPredicate): void;
+    function reduce<T>(startNode: TIsolate, callback: (acc: T, isolate: TIsolate, breakout: CB<void>) => T, initialValue: T, visitOnly?: VisitOnlyPredicate): T;
+    // This function returns true if the given predicate function returns true for any Isolate object in the tree.
+    // If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+    function some(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): boolean;
+    // This function returns true if the given predicate function returns true for any Isolate object in the tree.
+    // If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+    function has(startNode: TIsolate, match: VisitOnlyPredicate): boolean;
+    // traverses up to a parent node that satisfies the predicate
+    // and returns the first direct descendant that satisfies the predicate
+    function findClosest<I extends TIsolate = TIsolate>(startNode: TIsolate, predicate: (node: TIsolate) => boolean): Nullable<I>;
+    // This function returns the first Isolate object in the tree that satisfies the given predicate function.
+    // If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+    function find(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): Nullable<TIsolate>;
+    // this function acts like find, but returns an array of all matching nodes
+    function findAll(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): TIsolate[];
+    // This function returns true if the given predicate function returns true for every Isolate object in the tree.
+    // If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+    function every(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): boolean;
+    // This function removes all Isolate objects in the tree that
+    // satisfy the given predicate function and have a parent.
+    // If visitOnly is provided, only Isolate objects that satisfy the predicate are visited.
+    function pluck(startNode: TIsolate, predicate: (node: TIsolate) => boolean, visitOnly?: VisitOnlyPredicate): void;
+    // Returns the closest ancestor Isolate object of the given
+    //startNode that satisfies the given predicate function.
+    function closest(startNode: TIsolate, predicate: (node: TIsolate) => boolean): Nullable<TIsolate>;
+    // This function returns true if the closest ancestor Isolates of the
+    // given startNode that satisfies the given predicate function exists.
+    function closestExists(startNode: TIsolate, predicate: (node: TIsolate) => boolean): boolean;
 }
-//#endregion
-//#region src/VestRuntime.d.ts
-/**
- * The state reference type for the Vest runtime.
- * Holds all mutable state for the runtime instance.
- */
+type CTXType = StateRefType & {
+    historyNode: Nullable<TIsolate>;
+    runtimeNode: Nullable<TIsolate>;
+    runtimeRoot: Nullable<TIsolate>;
+    stateRef: StateRefType;
+};
 type StateRefType = {
-  Bus: BusType<RuntimeEvents>;
-  appData: Record<string, any>;
-  historyRoot: TinyState<Nullable<TIsolate>>;
-  Reconciler: IReconciler;
-  implicitOnlyNodes: Set<TIsolate>;
+    Bus: BusType;
+    appData: Record<string, any>;
+    historyRoot: TinyState<Nullable<TIsolate>>;
+    Reconciler: IRecociler;
+};
+declare const RuntimeApi: {
+    Run: <R>(value: Partial<CTXType>, fn: () => R) => R;
+    createRef: typeof createRef;
+    persist: typeof persist;
+    reset: typeof reset;
+    useAvailableRoot: typeof useAvailableRoot;
+    useCurrentCursor: typeof useCurrentCursor;
+    useHistoryRoot: typeof useHistoryRoot;
+    useSetHistoryRoot: typeof useSetHistoryRoot;
+    useSetNextIsolateChild: typeof useSetNextIsolateChild;
+    useXAppData: typeof useXAppData;
 };
-/**
- * Retrieves the current runtime state (e.g., STABLE, PENDING).
- */
-declare function useRuntimeState(): RuntimeState;
-/**
- * Checks if the runtime is currently stable (no pending tests).
- */
-declare function useIsStable(): boolean;
-/**
- * Retrieves the application-specific data stored in the runtime.
- */
 declare function useXAppData<T = object>(): T;
-/**
- * Creates a new state reference for such as the history root, pending isolates, and the current runtime state.
- */
-declare function createRef(Reconciler: IReconciler, setter: DynamicValue<Record<string, any>>): StateRefType;
-/**
- * Dispatches a runtime event to the internal Bus.
- * This is used to trigger state changes and notifications.
- */
-declare function dispatch<T extends keyof RuntimeEvents>(event: RuntimeEvents[T] extends void ? {
-  type: T;
-  payload?: void;
-} : {
-  type: T;
-  payload: RuntimeEvents[T];
-}): void;
-/**
- * Registers an isolate as pending.
- * This is used to track async tests and other async operations.
- */
-declare function registerPending(isolate: TIsolate): void;
-/**
- * Removes an isolate from the pending set.
- * This is used when an async test or operation completes.
- */
-declare function removePending(isolate: TIsolate): void;
-/**
- * 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.
- */
+declare function createRef(Reconciler: IRecociler, setter: DynamicValue<Record<string, any>>): StateRefType;
 declare function persist<T extends (...args: any[]) => any>(cb: T): T;
-/**
- * Retrieves the history root state.
- */
-declare function useHistoryRoot(): any;
-/**
- * Sets the history root for the runtime.
- * This is used to hydrate the runtime with previous results.
- */
+declare function useHistoryRoot(): [
+    value: Nullable<TIsolate<{
+        [x: string]: any;
+    } & {
+        allowReorder?: boolean | undefined;
+        status?: string | undefined;
+    }>>,
+    setValue: (next: Nullable<TIsolate<{
+        [x: string]: any;
+    } & {
+        allowReorder?: boolean | undefined;
+        status?: string | undefined;
+    }>> | import("vest-utils").CB<Nullable<TIsolate<{
+        [x: string]: any;
+    } & {
+        allowReorder?: boolean | undefined;
+        status?: string | undefined;
+    }>>, [
+        prev: Nullable<TIsolate<{
+            [x: string]: any;
+        } & {
+            allowReorder?: boolean | undefined;
+            status?: string | undefined;
+        }>>
+    ]>) => void,
+    resetValue: () => void
+];
 declare function useSetHistoryRoot(history: TIsolate): void;
-/**
- * Retrieves the current cursor position within the active isolate.
- */
 declare function useCurrentCursor(): number;
-/**
- * Adds a child isolate to the current isolate and sets the parent-child relationship.
- */
 declare function useSetNextIsolateChild(child: TIsolate): void;
-/**
- * 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).
- */
 declare function useAvailableRoot<I extends TIsolate = TIsolate>(): I;
-/**
- * Checks whether a specific key is heavily focused out.
- */
-declare function useIsFocusedOut(key?: string): boolean;
-declare function hasImplicitOnly(): boolean;
-/**
- * Resets the history root.
- */
 declare function reset(): void;
-declare const RuntimeApi: {
-  Run: any;
-  createRef: typeof createRef;
-  dispatch: typeof dispatch;
-  hasImplicitOnly: typeof hasImplicitOnly;
-  persist: typeof persist;
-  registerPending: typeof registerPending;
-  removePending: typeof removePending;
-  reset: typeof reset;
-  useAvailableRoot: typeof useAvailableRoot;
-  useCurrentCursor: typeof useCurrentCursor;
-  useHistoryRoot: typeof useHistoryRoot;
-  useIsFocusedOut: typeof useIsFocusedOut;
-  useIsStable: typeof useIsStable;
-  useRuntimeState: typeof useRuntimeState;
-  useSetHistoryRoot: typeof useSetHistoryRoot;
-  useSetNextIsolateChild: typeof useSetNextIsolateChild;
-  useXAppData: typeof useXAppData;
-};
-//#endregion
-//#region src/Isolate/IsolateInspector.d.ts
 declare class IsolateInspector {
-  static at(isolate: Nullable<TIsolate>, at: number): Nullable<TIsolate>;
-  static cursor(isolate: Nullable<TIsolate>): number;
-  static canReorder<I extends TIsolate>(isolate: Nullable<I>): boolean;
-  static allowsReorder<I extends Record<any, any>>(isolate: Nullable<I>): boolean;
-  static usesKey(isolate: Nullable<TIsolate>): boolean;
-  static getChildByKey(isolate: Nullable<TIsolate>, key: string): Nullable<TIsolate>;
-  static getStatus(isolate: Nullable<TIsolate>): IsolateStatus;
-  static statusEquals(isolate: Nullable<TIsolate>, status: IsolateStatus): boolean;
-  static isPending(isolate: Nullable<TIsolate>): boolean;
-  static isHasPending(isolate: Nullable<TIsolate>): boolean;
-  static hasPending(isolate: Nullable<TIsolate>): boolean;
-  static hasActiveChildren(isolate: Nullable<TIsolate>): boolean;
-  static getParent(isolate: Nullable<TIsolate>): Nullable<TIsolate>;
+    static at(isolate: Nullable<TIsolate>, at: number): Nullable<TIsolate>;
+    static cursor(isolate: Nullable<TIsolate>): number;
+    static canReorder<I extends TIsolate>(isolate: Nullable<I>): boolean;
+    static allowsReorder<I extends Record<any, any>>(isolate: Nullable<I>): boolean;
+    static usesKey(isolate: Nullable<TIsolate>): boolean;
+    static getChildByKey(isolate: Nullable<TIsolate>, key: string): Nullable<TIsolate>;
 }
-//#endregion
-//#region src/Isolate/IsolateMutator.d.ts
 declare class IsolateMutator {
-  static setParent(isolate: TIsolate, parent: Nullable<TIsolate>): TIsolate;
-  static saveOutput(isolate: TIsolate, output: any): TIsolate;
-  static setKey(isolate: TIsolate, key: Nullable<string>): TIsolate;
-  static addChild(isolate: TIsolate, child: TIsolate): void;
-  static removeChild(isolate: TIsolate, node: TIsolate): void;
-  static addChildKey(isolate: TIsolate, key: string, node: TIsolate): void;
-  static slice(isolate: TIsolate, at: number): void;
-  static setData(isolate: TIsolate, data: any): void;
-  static abort(isolate: TIsolate, reason?: string): void;
-  static setStatus(isolate: TIsolate, status: IsolateStatus, payload?: any): Result<IsolateStatus, string>;
-  static setPending(isolate: TIsolate): void;
-  static setHasPending(isolate: TIsolate): Result<IsolateStatus, string>;
-  static setDone(isolate: TIsolate): void;
-}
-declare namespace Bus_d_exports {
-  export { useBus, useEmit, usePrepareEmitter };
+    static setParent(isolate: TIsolate, parent: Nullable<TIsolate>): TIsolate;
+    static saveOutput(isolate: TIsolate, output: any): TIsolate;
+    static setKey(isolate: TIsolate, key: Nullable<string>): TIsolate;
+    static addChild(isolate: TIsolate, child: TIsolate): void;
+    static removeChild(isolate: TIsolate, node: TIsolate): void;
+    static addChildKey(isolate: TIsolate, key: string, node: TIsolate): void;
+    static slice(isolate: TIsolate, at: number): void;
+    static setData(isolate: TIsolate, data: any): void;
+    static abort(isolate: TIsolate, reason?: string): void;
 }
-declare function useBus<E extends Record<string, any> = RuntimeEvents>(): BusType<E>;
-declare function useEmit<E extends Record<string, any> = RuntimeEvents, T extends keyof E = keyof E>(event: T, ...args: E[T] extends void ? [payload?: E[T]] : [payload: E[T]]): void;
-declare function useEmit<_E extends Record<string, any> = RuntimeEvents>(): (event: string, data?: any) => void;
-declare function usePrepareEmitter<E extends Record<string, any> = RuntimeEvents, T extends keyof E = keyof E>(event: T): (arg: E[T]) => void;
-declare namespace IsolateSelectors_d_exports {
-  export { isIsolateType, isSameIsolateIdentity, isSameIsolateType };
+declare namespace Bus {
+    function useBus(): import("vest-utils").BusType;
+    /*
+    Returns an emitter, but it also has a shortcut for emitting an event immediately
+    by passing an event name.
+    */
+    function useEmit(event?: string, data?: any): (event: string, data?: any) => void;
+    function usePrepareEmitter<T = void>(event: string): (arg: T) => void;
 }
-declare function isIsolateType<I extends TIsolate>(node: Maybe<TIsolate>, type: string): node is I;
-declare function isSameIsolateType<A extends TIsolate, B extends TIsolate>(a: A, b: B): boolean;
-declare function isSameIsolateIdentity<A extends TIsolate, B extends TIsolate>(a: A, b: B): boolean;
-//#endregion
-//#region src/Isolate/IsolateStateMachine.d.ts
-declare const IsolateStateMachine: any;
-declare namespace IsolateRegistry_d_exports {
-  export { RegistryCategoryConfig, RegistryIndex, useClearRegistry, useGetFromRegistry, useHasFromRegistry, useRemoveFieldFromRegistry, useUpdateRegistry };
+declare namespace IsolateSelectors {
+    enum IsolateKeys {
+        Type = "$type",
+        Keys = "keys",
+        Key = "key",
+        Parent = "parent",
+        Data = "data",
+        AllowReorder = "allowReorder",
+        Status = "status",
+        AbortController = "abortController",
+        Children = "children"
+    }
+    const ExcludedFromDump: Set<IsolateKeys>;
+    type IsolateKey = Nullable<string>;
+    type TIsolate<P extends IsolatePayload = IsolatePayload> = {
+        [IsolateKeys.AllowReorder]?: boolean;
+        [IsolateKeys.Parent]: Nullable<TIsolate>;
+        [IsolateKeys.Type]: string;
+        [IsolateKeys.Keys]: Nullable<Record<string, TIsolate>>;
+        [IsolateKeys.Data]: DataOnly<P>;
+        [IsolateKeys.Status]?: string;
+        [IsolateKeys.AbortController]: AbortController;
+        children: Nullable<TIsolate[]>;
+        key: IsolateKey;
+        output: any;
+    } & UsedFeaturesOnly<P>;
+    type DataOnly<P extends IsolatePayload> = Omit<P, keyof IsolateFeatures>;
+    type UsedFeaturesOnly<P extends IsolatePayload> = Pick<P, keyof IsolateFeatures>;
+    class Isolate {
+        // eslint-disable-next-line max-statements
+        static create<Payload extends IsolatePayload>(type: string, callback: CB, payload?: Maybe<Payload>, key?: IsolateKey): TIsolate<Payload>;
+        static isIsolate(node: any): node is TIsolate;
+    }
+    type IsolateData = Record<string, any>;
+    type IsolatePayload = IsolateData & IsolateFeatures;
+    type IsolateFeatures = {
+        [IsolateKeys.AllowReorder]?: boolean;
+        [IsolateKeys.Status]?: string;
+    };
+    function isIsolateType<I extends TIsolate>(node: Maybe<TIsolate>, type: string): node is I;
+    function isSameIsolateType<A extends TIsolate, B extends TIsolate>(a: A, b: B): boolean;
+    function isSameIsolateIdentity<A extends TIsolate, B extends TIsolate>(a: A, b: B): boolean;
 }
-/**
- * A registry index, mapping group keys (like field names) to sets of isolates.
- */
-type RegistryIndex = Map<string, Set<TIsolate>>;
-/**
- * Configuration for a registry category.
- */
-type RegistryCategoryConfig = {
-  predicate: (isolate: TIsolate) => boolean;
-  getKey: (isolate: TIsolate) => string;
-};
-/**
- * Updates the registration of an isolate in all relevant indices based on provided predicates.
- *
- * @param isolate - The isolate node to update.
- * @param predicates - A record of category keys and their corresponding predicate configurations.
- */
-declare function useUpdateRegistry(isolate: TIsolate, predicates: Record<string, RegistryCategoryConfig>): void;
-/**
- * Retrieves isolates from the registry based on a category and an optional key.
- */
-declare function useGetFromRegistry(category: string, key?: string): Set<TIsolate>;
-/**
- * Checks if the registry contains any isolates for a given category and optional key.
- */
-declare function useHasFromRegistry(category: string, key?: string): boolean;
-/**
- * Removes all entries for a specific key from the registry.
- */
-declare function useRemoveFieldFromRegistry(key: string): void;
-/**
- * Clears all registry entries from the root isolate.
- */
-declare function useClearRegistry(root: TIsolate): void;
-//#endregion
-//#region src/Isolate/IsolateReorderable.d.ts
-declare function IsolateReorderable(callback: CB, type?: string, payload?: Record<string, any>): TIsolate<IsolatePayload<Record<string, any>>>;
-//#endregion
-//#region src/Isolate/IsolateTransient.d.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.
- */
-declare function IsolateTransient<Payload extends IsolatePayload>(callback: CB, type?: string, payload?: Payload): TIsolate<Payload>;
-//#endregion
-//#region src/Isolate/IsolateFocused.d.ts
-declare enum FocusModes {
-  SKIP = "skip",
-  ONLY = "only",
-}
-type FocusMatchExclusion = Maybe<OneOrMoreOf<string>>;
-type TIsolateFocused = TIsolate<IsolateFocusedPayload>;
-type IsolateFocusedPayload = {
-  focusMode: FocusModes;
-  match: FocusMatchExclusion;
-  matchAll: boolean;
-};
-/**
- * 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.
- */
-declare function IsolateFocused(focusMode: FocusModes, match?: true | FocusMatchExclusion): TIsolateFocused | undefined;
-declare class FocusSelectors {
-  static isSkipFocused(focus: Nullish<TIsolateFocused>, fieldName?: string): boolean;
-  static isOnlyFocused(focus: Nullish<TIsolateFocused>, fieldName?: string): boolean;
-  static isIsolateFocused(isolate: TIsolate): isolate is TIsolateFocused;
+declare class IsolateSerializer {
+    // eslint-disable-next-line max-statements, complexity, max-lines-per-function
+    static deserialize(node: Record<string, any> | TIsolate | string): TIsolate;
+    static serialize(isolate: Nullable<TIsolate>, replacer: (value: any, key: string) => any): string;
+    static validateIsolate(node: Record<string, any> | TIsolate): asserts node is TIsolate;
 }
-//#endregion
-export { Bus_d_exports as Bus, FocusModes, FocusSelectors, type IReconciler, Isolate, IsolateFocused, IsolateInspector, type IsolateKey, IsolateKeys, IsolateMutator, IsolateRegistry_d_exports as IsolateRegistry, IsolateReorderable, IsolateSelectors_d_exports as IsolateSelectors, IsolateSerializer, IsolateStateMachine, IsolateStatus, IsolateTransient, Reconciler, type RegistryCategoryConfig, type RegistryIndex, type RuntimeEvents, type TIsolate, type TIsolateFocused, RuntimeApi as VestRuntime, IsolateWalker_d_exports as Walker };
-//# sourceMappingURL=vestjs-runtime.d.cts.map
+export { RuntimeEvents, IsolateKey, TIsolate, Isolate, Reconciler, IRecociler, Walker, RuntimeApi as VestRuntime, IsolateInspector, IsolateMutator, Bus, IsolateSelectors, IsolateSerializer };
+//# sourceMappingURL=vestjs-runtime.d.ts.map

package/types/vestjs-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vestjs-runtime.d.ts","sourceRoot":"","sources":["../src/vestjs-runtime.ts","../src/RuntimeEvents.ts","../src/errors/ErrorStrings.ts","../src/Isolate/IsolateInspector.ts","../src/Isolate/IsolateMutator.ts","../src/Isolate/IsolateKeys.ts","../src/Isolate/IsolateSelectors.ts","../src/Reconciler.ts","../src/VestRuntime.ts","../src/Bus.ts","../src/Isolate/Isolate.ts","../src/IsolateWalker.ts","../src/exports/IsolateSerializer.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,uLAAiB,CAAsB"}