vest 5.0.0-dev-9c596e → 5.0.0-dev-ec989a

package/dist/es/vest.development.js

@@ -1,29 +1,53 @@
 export { enforce } from 'n4s';
-import { isNullish, optionalFunctionValue, invariant, isNotNullish, bindNot, either, assign, tinyState, cache, defaultTo, isPositive, asArray, isStringValue, hasOwnProperty, deferThrow, text, isUndefined, seq, isPromise, isArray, callEach, bus, isNull, isFunction, numberEquals } from 'vest-utils';
+import { VestRuntime, Isolate, Reconciler, Walker } from 'vest-runtime';
+import { isArray, isStringValue, asArray, cache, tinyState, seq, bindNot, defaultTo, assign, isPositive, optionalFunctionValue, hasOwnProperty, isNullish, deferThrow, text, StateMachine, isUndefined, isPromise, invariant, either, isEmpty, callEach, isNull, isFunction, numberEquals } from 'vest-utils';
 import { createCascade } from 'context';
 
 var OptionalFieldTypes;
 (function (OptionalFieldTypes) {
-    OptionalFieldTypes[OptionalFieldTypes["Immediate"] = 0] = "Immediate";
-    OptionalFieldTypes[OptionalFieldTypes["Delayed"] = 1] = "Delayed";
+    OptionalFieldTypes[OptionalFieldTypes["CUSTOM_LOGIC"] = 0] = "CUSTOM_LOGIC";
+    OptionalFieldTypes[OptionalFieldTypes["AUTO"] = 1] = "AUTO";
 })(OptionalFieldTypes || (OptionalFieldTypes = {}));
 
-var ErrorStrings;
-(function (ErrorStrings) {
-    ErrorStrings["HOOK_CALLED_OUTSIDE"] = "hook called outside of a running suite.";
-    ErrorStrings["EXPECTED_VEST_TEST"] = "Expected value to be an instance of IsolateTest";
-    ErrorStrings["FIELD_NAME_REQUIRED"] = "Field name must be passed";
-    ErrorStrings["SUITE_MUST_BE_INITIALIZED_WITH_FUNCTION"] = "Suite must be initialized with a function";
-    ErrorStrings["NO_ACTIVE_ISOLATE"] = "Not within an active isolate";
-    ErrorStrings["PROMISIFY_REQUIRE_FUNCTION"] = "Vest.Promisify must be called with a function";
-    ErrorStrings["PARSER_EXPECT_RESULT_OBJECT"] = "Vest parser: expected argument at position 0 to be Vest's result object.";
-    ErrorStrings["WARN_MUST_BE_CALLED_FROM_TEST"] = "Warn must be called from within the body of a test function";
-    ErrorStrings["EACH_CALLBACK_MUST_BE_A_FUNCTION"] = "Each must be called with a function";
-    ErrorStrings["INVALID_PARAM_PASSED_TO_FUNCTION"] = "Incompatible params passed to {fn_name} function. \"{param}\" must be of type {expected}";
-    ErrorStrings["ENCOUNTERED_THE_SAME_KEY_TWICE"] = "Encountered the same test key \"{key}\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted.";
-    ErrorStrings["TESTS_CALLED_IN_DIFFERENT_ORDER"] = "Vest Critical Error: Tests called in different order than previous run.\n    expected: {fieldName}\n    received: {prevName}\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.";
-    ErrorStrings["UNEXPECTED_TEST_REGISTRATION_ERROR"] = "Unexpected error encountered during test registration.\n      Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.\n      Error: {error}.";
-})(ErrorStrings || (ErrorStrings = {}));
+// @vx-allow use-use
+function optional(optionals) {
+    const suiteRoot = VestRuntime.useAvailableRoot();
+    // There are two types of optional field declarations:
+    // 1 AUTO: Vest will automatically determine whether the field should be omitted
+    // Based on the current run. Vest will ommit "auto" added fields without any
+    // configuration if their tests did not run at all in the suite.
+    //
+    // 2 Custom logic: Vest will determine whether they should fail based on the custom
+    // logic supplied by the user.
+    // AUTO case (field name)
+    if (isArray(optionals) || isStringValue(optionals)) {
+        asArray(optionals).forEach(optionalField => {
+            suiteRoot.setOptionalField(optionalField, () => ({
+                type: OptionalFieldTypes.AUTO,
+                applied: false,
+                rule: null,
+            }));
+        });
+    }
+    else {
+        // CUSTOM_LOGIC case (function or boolean)
+        for (const field in optionals) {
+            const value = optionals[field];
+            suiteRoot.setOptionalField(field, () => ({
+                type: OptionalFieldTypes.CUSTOM_LOGIC,
+                rule: value,
+                applied: value === true,
+            }));
+        }
+    }
+}
+function useIsOptionalFiedApplied(fieldName) {
+    var _a, _b, _c;
+    if (!fieldName) {
+        return false;
+    }
+    return ((_c = (_b = (_a = VestRuntime.useAvailableRoot()) === null || _a === void 0 ? void 0 : _a.getOptionalField(fieldName)) === null || _b === void 0 ? void 0 : _b.applied) !== null && _c !== void 0 ? _c : false);
+}
 
 var Events;
 (function (Events) {
@@ -34,250 +58,74 @@ var Events;
     Events["RESET_FIELD"] = "reset_field";
     Events["RESET_SUITE"] = "reset_suite";
     Events["SUITE_RUN_STARTED"] = "suite_run_started";
+    Events["SUITE_CALLBACK_RUN_FINISHED"] = "SUITE_CALLBACK_RUN_FINISHED";
+    Events["DONE_TEST_OMISSION_PASS"] = "DONE_TEST_OMISSION_PASS";
 })(Events || (Events = {}));
 
-// eslint-disable-next-line complexity, max-statements
-function walk(startNode, callback, visitOnly) {
-    if (isNullish(startNode.children)) {
-        return;
-    }
-    let broke = false;
-    for (const isolate of startNode.children) {
-        if (broke) {
-            return;
-        }
-        if (isNullish(visitOnly) || optionalFunctionValue(visitOnly, isolate)) {
-            callback(isolate, breakout);
-        }
-        if (broke) {
-            return;
-        }
-        walk(isolate, (child, innerBreakout) => {
-            callback(child, () => {
-                innerBreakout();
-                breakout();
-            });
-        }, visitOnly);
-    }
-    function breakout() {
-        broke = true;
-    }
-}
-function some(startNode, predicate, visitOnly) {
-    let hasMatch = false;
-    walk(startNode, (node, breakout) => {
-        if (predicate(node)) {
-            breakout();
-            hasMatch = true;
-        }
-    }, visitOnly);
-    return hasMatch;
-}
-function has(startNode, match) {
-    return some(startNode, () => true, match);
-}
-function every(startNode, predicate, visitOnly) {
-    let hasMatch = true;
-    walk(startNode, (node, breakout) => {
-        if (!predicate(node)) {
-            breakout();
-            hasMatch = false;
-        }
-    }, visitOnly);
-    return hasMatch;
-}
-function pluck(startNode, predicate, visitOnly) {
-    walk(startNode, node => {
-        if (predicate(node) && node.parent) {
-            node.parent.removeChild(node);
-        }
-    }, visitOnly);
-}
-function closest(startNode, predicate) {
-    let current = startNode;
-    while (current.parent) {
-        if (predicate(current)) {
-            return current;
-        }
-        current = current.parent;
+class IsolateSuite extends Isolate {
+    constructor() {
+        super(...arguments);
+        this.optional = {};
     }
-    return null;
-}
-function closestExists(startNode, predicate) {
-    return !!closest(startNode, predicate);
-}
-
-class Reconciler {
-    static reconciler(currentNode, historicNode) {
-        if (isNullish(historicNode)) {
-            return currentNode;
-        }
-        return currentNode;
+    setOptionalField(fieldName, setter) {
+        const current = this.optional;
+        const currentField = current[fieldName];
+        Object.assign(current, {
+            [fieldName]: Object.assign({}, currentField, setter(currentField)),
+        });
     }
-    static reconcile(node, callback) {
+    getOptionalField(fieldName) {
         var _a;
-        const parent = useIsolate();
-        const historyNode = useHistoryNode();
-        let localHistoryNode = historyNode;
-        if (parent) {
-            // If we have a parent, we need to get the history node from the parent's children
-            // We take the history node from the cursor of the active node's children
-            localHistoryNode = (_a = historyNode === null || historyNode === void 0 ? void 0 : historyNode.at(useCurrentCursor())) !== null && _a !== void 0 ? _a : null;
-        }
-        const nextNode = this.reconciler(node, localHistoryNode);
-        invariant(nextNode);
-        if (Object.is(nextNode, node)) {
-            return [node, useRunAsNew(localHistoryNode, node, callback)];
-        }
-        return [nextNode, nextNode.output];
+        return (_a = this.optional[fieldName]) !== null && _a !== void 0 ? _a : {};
     }
-    static removeAllNextNodesInIsolate() {
-        const testIsolate = useIsolate();
-        const historyNode = useHistoryNode();
-        if (!historyNode || !testIsolate) {
-            return;
-        }
-        historyNode.slice(useCurrentCursor());
+    getOptionalFields() {
+        return this.optional;
     }
-    static handleCollision(newNode, prevNode) {
-        // we should base our calculation on the key property
-        if (newNode.usesKey()) {
-            return this.handleIsolateNodeWithKey(newNode);
-        }
-        if (this.nodeReorderDetected(newNode, prevNode)) {
-            this.onNodeReorder(newNode, prevNode);
-        }
-        return prevNode ? prevNode : newNode;
-    }
-    static nodeReorderDetected(newNode, prevNode) {
-        // This is a dummy return just to satisfy the linter. Overrides will supply the real implementation.
-        return !(newNode !== null && newNode !== void 0 ? newNode : prevNode);
-    }
-    static onNodeReorder(newNode, prevNode) {
-        this.removeAllNextNodesInIsolate();
-        // This is a dummy return just to satisfy the linter. Overrides will supply the real implementation.
-        return newNode !== null && newNode !== void 0 ? newNode : prevNode;
-    }
-    static handleIsolateNodeWithKey(node) {
-        invariant(node.usesKey());
-        const prevNodeByKey = useHistoryKey(node.key);
-        let nextNode = node;
-        if (!isNullish(prevNodeByKey)) {
-            nextNode = prevNodeByKey;
-        }
-        useSetIsolateKey(node.key, node);
-        return nextNode;
-    }
-}
-function useRunAsNew(localHistoryNode, current, callback) {
-    const runtimeRoot = useRuntimeRoot();
-    // We're creating a new child isolate context where the local history node
-    // is the current history node, thus advancing the history cursor.
-    const output = PersistedContext.run(Object.assign({ historyNode: localHistoryNode, runtimeNode: current }, (!runtimeRoot && { runtimeRoot: current })), () => callback(current));
-    current.output = output;
-    return output;
 }
 
-class Isolate {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-empty-function
-    constructor(_data) {
-        this.children = [];
-        this.keys = {};
-        this.parent = null;
-        this.key = null;
-        this.allowReorder = false;
-    }
-    setParent(parent) {
-        this.parent = parent;
-        return this;
-    }
-    saveOutput(output) {
-        this.output = output;
-        return this;
-    }
-    setKey(key) {
-        this.key = key;
-        return this;
-    }
-    usesKey() {
-        return isNotNullish(this.key);
-    }
-    addChild(child) {
-        invariant(this.children);
-        this.children.push(child);
-    }
-    removeChild(node) {
-        var _a, _b;
-        this.children = (_b = (_a = this.children) === null || _a === void 0 ? void 0 : _a.filter(child => child !== node)) !== null && _b !== void 0 ? _b : null;
-    }
-    slice(at) {
-        if (isNullish(this.children)) {
-            return;
-        }
-        this.children.length = at;
-    }
-    at(at) {
-        var _a, _b;
-        return (_b = (_a = this.children) === null || _a === void 0 ? void 0 : _a[at]) !== null && _b !== void 0 ? _b : null;
-    }
-    cursor() {
-        var _a, _b;
-        return (_b = (_a = this.children) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-    }
-    shouldAllowReorder() {
-        var _a;
-        return (_a = closestExists(this, node => node.allowReorder)) !== null && _a !== void 0 ? _a : false;
-    }
-    get rootNode() {
-        var _a;
-        return (_a = closest(this, node => isNullish(node.parent))) !== null && _a !== void 0 ? _a : this;
-    }
-    static create(callback, data) {
-        return this.createImplementation(callback, data);
-    }
-    static createImplementation(callback, data) {
-        const parent = useIsolate();
-        const newCreatedNode = new this(data).setParent(parent);
-        const [nextIsolateChild, output] = this.reconciler.reconcile(newCreatedNode, callback);
-        nextIsolateChild.saveOutput(output);
-        this.setNode(nextIsolateChild);
-        return nextIsolateChild;
-    }
-    static setNode(node) {
-        const parent = useIsolate();
-        if (parent) {
-            useSetNextIsolateChild(node);
-        }
-        else {
-            useSetHistory(node);
-        }
-        node.setParent(parent);
-    }
-    static is(node) {
-        return node instanceof Isolate;
-    }
+const suiteResultCache = cache();
+function useCreateVestState({ suiteName, } = {}) {
+    const stateRef = {
+        doneCallbacks: tinyState.createTinyState(() => []),
+        fieldCallbacks: tinyState.createTinyState(() => ({})),
+        suiteId: seq(),
+        suiteName,
+        suiteResultCache,
+    };
+    return VestRuntime.createRef(stateRef);
 }
-Isolate.reconciler = Reconciler;
-
-function nonMatchingFieldName(WithFieldName, fieldName) {
-    return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
+function useX() {
+    return VestRuntime.useXAppData();
 }
-function matchingFieldName(WithFieldName, fieldName) {
-    return !!(fieldName && WithFieldName.fieldName === fieldName);
+function useDoneCallbacks() {
+    return useX().doneCallbacks();
 }
-
-function isSameProfileTest(testObject1, testObject2) {
-    return (matchingFieldName(testObject1, testObject2.fieldName) &&
-        testObject1.groupName === testObject2.groupName &&
-        testObject1.key === testObject2.key);
+function useFieldCallbacks() {
+    return useX().fieldCallbacks();
 }
-
-function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
-    if (currentRunTestObject !== prevRunTestObject &&
-        isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
-        prevRunTestObject.isPending()) {
-        prevRunTestObject.cancel();
-    }
+function useSuiteName() {
+    return useX().suiteName;
+}
+function useSuiteId() {
+    return useX().suiteId;
+}
+function useSuiteResultCache(action) {
+    const suiteResultCache = useX().suiteResultCache;
+    return suiteResultCache([useSuiteId()], action);
+}
+function useExpireSuiteResultCache() {
+    const suiteResultCache = useX().suiteResultCache;
+    suiteResultCache.invalidate([useSuiteId()]);
+}
+function useResetCallbacks() {
+    const [, , resetDoneCallbacks] = useDoneCallbacks();
+    const [, , resetFieldCallbacks] = useFieldCallbacks();
+    resetDoneCallbacks();
+    resetFieldCallbacks();
+}
+function useResetSuite() {
+    useResetCallbacks();
+    VestRuntime.reset();
 }
 
 var Severity;
@@ -295,135 +143,47 @@ function countKeyBySeverity(severity) {
         ? SeverityCount.ERROR_COUNT
         : SeverityCount.WARN_COUNT;
 }
+var TestSeverity;
+(function (TestSeverity) {
+    TestSeverity["Error"] = "error";
+    TestSeverity["Warning"] = "warning";
+})(TestSeverity || (TestSeverity = {}));
 
-const nonMatchingGroupName = bindNot(matchingGroupName);
-function matchingGroupName(testObject, groupName) {
-    return testObject.groupName === groupName;
-}
-
-/**
- * Checks that a given test object matches the currently specified severity level
- */
-function nonMatchingSeverityProfile(severity, testObject) {
-    return either(severity === Severity.WARNINGS, testObject.warns());
-}
+var ErrorStrings;
+(function (ErrorStrings) {
+    ErrorStrings["HOOK_CALLED_OUTSIDE"] = "hook called outside of a running suite.";
+    ErrorStrings["EXPECTED_VEST_TEST"] = "Expected value to be an instance of IsolateTest";
+    ErrorStrings["FIELD_NAME_REQUIRED"] = "Field name must be passed";
+    ErrorStrings["SUITE_MUST_BE_INITIALIZED_WITH_FUNCTION"] = "Suite must be initialized with a function";
+    ErrorStrings["PROMISIFY_REQUIRE_FUNCTION"] = "Vest.Promisify must be called with a function";
+    ErrorStrings["PARSER_EXPECT_RESULT_OBJECT"] = "Vest parser: expected argument at position 0 to be Vest's result object.";
+    ErrorStrings["WARN_MUST_BE_CALLED_FROM_TEST"] = "Warn must be called from within the body of a test function";
+    ErrorStrings["EACH_CALLBACK_MUST_BE_A_FUNCTION"] = "Each must be called with a function";
+    ErrorStrings["INVALID_PARAM_PASSED_TO_FUNCTION"] = "Incompatible params passed to {fn_name} function. \"{param}\" must be of type {expected}";
+    ErrorStrings["TESTS_CALLED_IN_DIFFERENT_ORDER"] = "Vest Critical Error: Tests called in different order than previous run.\n    expected: {fieldName}\n    received: {prevName}\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.";
+    ErrorStrings["UNEXPECTED_TEST_REGISTRATION_ERROR"] = "Unexpected error encountered during test registration.\n      Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.\n      Error: {error}.";
+    ErrorStrings["UNEXPECTED_TEST_RUN_ERROR"] = "Unexpected error encountered during test run. Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.";
+})(ErrorStrings || (ErrorStrings = {}));
 
-/**
- * The difference between this file and hasFailures is that hasFailures uses the static
- * summary object, while this one uses the actual validation state
- */
-function hasErrorsByTestObjects(fieldName) {
-    return hasFailuresByTestObjects(Severity.ERRORS, fieldName);
-}
-function hasFailuresByTestObjects(severityKey, fieldName) {
-    return TestWalker.someTests(testObject => {
-        return hasFailuresByTestObject(testObject, severityKey, fieldName);
-    });
-}
-function hasGroupFailuresByTestObjects(severityKey, groupName, fieldName) {
-    return TestWalker.someTests(testObject => {
-        if (nonMatchingGroupName(testObject, groupName)) {
-            return false;
-        }
-        return hasFailuresByTestObject(testObject, severityKey, fieldName);
-    });
+function nonMatchingFieldName(WithFieldName, fieldName) {
+    return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
 }
-/**
- * Determines whether a certain test profile has failures.
- */
-function hasFailuresByTestObject(testObject, severityKey, fieldName) {
-    if (!testObject.hasFailures()) {
-        return false;
-    }
-    if (nonMatchingFieldName(testObject, fieldName)) {
-        return false;
-    }
-    if (nonMatchingSeverityProfile(severityKey, testObject)) {
-        return false;
-    }
-    return true;
+function matchingFieldName(WithFieldName, fieldName) {
+    return !!(fieldName && WithFieldName.fieldName === fieldName);
 }
 
-var Modes;
-(function (Modes) {
-    Modes["ALL"] = "ALL";
-    Modes["EAGER"] = "EAGER";
-})(Modes || (Modes = {}));
-/**
- * Sets the suite to "eager" (fail fast) mode.
- * Eager mode will skip running subsequent tests of a failing fields.
- *
- * @example
- *  // in the following example, the second test of username will not run
- *  // if the first test of username failed.
- * const suite = create((data) => {
- *  eager();
- *
- *  test('username', 'username is required', () => {
- *   enforce(data.username).isNotBlank();
- *  });
- *
- *  test('username', 'username is too short', () => {
- *   enforce(data.username).longerThan(2);
- *  });
- * });
- */
-// @vx-allow use-use
-function mode(mode) {
-    const [, setMode] = useMode();
-    setMode(mode);
-}
-function useIsMode(mode) {
-    const [currentMode] = useMode();
-    return currentMode === mode;
-}
-function useIsEager() {
-    return useIsMode(Modes.EAGER);
-}
-function useShouldSkipBasedOnMode(testObject) {
-    return useIsEager() && hasErrorsByTestObjects(testObject.fieldName);
+function isSameProfileTest(testObject1, testObject2) {
+    return (matchingFieldName(testObject1, testObject2.fieldName) &&
+        testObject1.groupName === testObject2.groupName &&
+        testObject1.key === testObject2.key);
 }
 
-const SuiteContext = createCascade((ctxRef, parentContext) => {
-    if (parentContext) {
-        return null;
+function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
+    if (currentRunTestObject !== prevRunTestObject &&
+        isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
+        prevRunTestObject.isPending()) {
+        prevRunTestObject.cancel();
     }
-    return assign({
-        exclusion: {
-            tests: {},
-            groups: {},
-        },
-        inclusion: {},
-        mode: tinyState.createTinyState(Modes.EAGER),
-        testMemoCache,
-    }, ctxRef);
-});
-function useCurrentTest(msg) {
-    return SuiteContext.useX(msg).currentTest;
-}
-function useGroupName() {
-    return SuiteContext.useX().groupName;
-}
-function useExclusion(hookError) {
-    return SuiteContext.useX(hookError).exclusion;
-}
-function useInclusion() {
-    return SuiteContext.useX().inclusion;
-}
-function useMode() {
-    return SuiteContext.useX().mode();
-}
-function useSkipped() {
-    var _a;
-    return (_a = SuiteContext.useX().skipped) !== null && _a !== void 0 ? _a : false;
-}
-function useOmitted() {
-    var _a;
-    return (_a = SuiteContext.useX().omitted) !== null && _a !== void 0 ? _a : false;
-}
-const testMemoCache = cache(10);
-function useTestMemoCache() {
-    return SuiteContext.useX().testMemoCache;
 }
 
 var _a, _b;
@@ -446,6 +206,25 @@ class SuiteSummary extends SummaryBase {
 }
 _a = Severity.ERRORS, _b = Severity.WARNINGS;
 
+class SummaryFailure {
+    constructor(fieldName, message, groupName) {
+        this.fieldName = fieldName;
+        this.message = message;
+        this.groupName = groupName;
+    }
+    static fromTestObject(testObject) {
+        return new SummaryFailure(testObject.fieldName, testObject.message, testObject.groupName);
+    }
+    toString() {
+        return this.message || '';
+    }
+}
+
+const nonMatchingGroupName = bindNot(matchingGroupName);
+function matchingGroupName(testObject, groupName) {
+    return testObject.groupName === groupName;
+}
+
 function useShouldAddValidProperty(fieldName) {
     // Is the field optional, and the optional condition is applied
     if (useIsOptionalFiedApplied(fieldName)) {
@@ -482,7 +261,10 @@ function useShouldAddValidPropertyInGroup(groupName, fieldName) {
 // Does the given field have any pending tests that are not optional?
 function useHasNonOptionalIncomplete(fieldName) {
     return TestWalker.someIncompleteTests(testObject => {
-        return useIsTestObjectOptional(testObject, fieldName);
+        if (nonMatchingFieldName(testObject, fieldName)) {
+            return false;
+        }
+        return !useIsOptionalFiedApplied(fieldName);
     });
 }
 // Do the given group/field have any pending tests that are not optional?
@@ -491,15 +273,12 @@ function useHasNonOptionalIncompleteByGroup(groupName, fieldName) {
         if (nonMatchingGroupName(testObject, groupName)) {
             return false;
         }
-        return useIsTestObjectOptional(testObject, fieldName);
+        if (nonMatchingFieldName(testObject, fieldName)) {
+            return false;
+        }
+        return !useIsOptionalFiedApplied(fieldName);
     });
 }
-function useIsTestObjectOptional(testObject, fieldName) {
-    if (nonMatchingFieldName(testObject, fieldName)) {
-        return false;
-    }
-    return useIsOptionalFiedApplied(fieldName);
-}
 // Did all of the tests for the provided field run/omit?
 // This makes sure that the fields are not skipped or pending.
 function useNoMissingTests(fieldName) {
@@ -529,16 +308,15 @@ function useNoMissingTestsLogic(testObject, fieldName) {
      * or if it is marked as optional, even if the optional check did not apply yet -
      * but the test did not reach its final state.
      */
-    return (useOptionalTestAwaitsResolution(testObject) ||
+    return (testObject.isOmitted() ||
         testObject.isTested() ||
-        testObject.isOmitted());
+        useOptionalTestAwaitsResolution(testObject));
 }
 function useOptionalTestAwaitsResolution(testObject) {
     // Does the test belong to an optional field,
     // and the test itself is still in an indeterminate state?
     var _a;
-    return (((_a = useAvailableSuiteRoot()) === null || _a === void 0 ? void 0 : _a.getOptionalField(testObject.fieldName).type) ===
-        OptionalFieldTypes.Delayed && testObject.awaitsResolution());
+    return (((_a = VestRuntime.useAvailableRoot()) === null || _a === void 0 ? void 0 : _a.getOptionalField(testObject.fieldName).type) === OptionalFieldTypes.AUTO && testObject.awaitsResolution());
 }
 
 function useProduceSuiteSummary() {
@@ -553,13 +331,12 @@ function useProduceSuiteSummary() {
     return countFailures(summary);
 }
 function appendFailures(key, failures, testObject) {
+    if (testObject.isOmitted()) {
+        return failures;
+    }
     const shouldAppend = key === Severity.WARNINGS ? testObject.isWarning() : testObject.isFailing();
     if (shouldAppend) {
-        return failures.concat({
-            fieldName: testObject.fieldName,
-            groupName: testObject.groupName,
-            message: testObject.message,
-        });
+        return failures.concat(SummaryFailure.fromTestObject(testObject));
     }
     return failures;
 }
@@ -659,6 +436,22 @@ function collectAll(testGroup, severityKey) {
     return output;
 }
 
+function bindSuiteSelectors(get) {
+    return {
+        getError: (...args) => get().getError(...args),
+        getErrors: (...args) => get().getErrors(...args),
+        getErrorsByGroup: (...args) => get().getErrorsByGroup(...args),
+        getWarning: (...args) => get().getWarning(...args),
+        getWarnings: (...args) => get().getWarnings(...args),
+        getWarningsByGroup: (...args) => get().getWarningsByGroup(...args),
+        hasErrors: (...args) => get().hasErrors(...args),
+        hasErrorsByGroup: (...args) => get().hasErrorsByGroup(...args),
+        hasWarnings: (...args) => get().hasWarnings(...args),
+        hasWarningsByGroup: (...args) => get().hasWarningsByGroup(...args),
+        isValid: (...args) => get().isValid(...args),
+        isValidByGroup: (...args) => get().isValidByGroup(...args),
+    };
+}
 // eslint-disable-next-line max-lines-per-function, max-statements
 function suiteSelectors(summary) {
     const selectors = {
@@ -777,11 +570,15 @@ function getFailure(severity, summary, fieldName) {
 }
 
 function useCreateSuiteResult() {
-    const summary = useProduceSuiteSummary();
-    const suiteName = useSuiteName();
-    return useSuiteResultCache(() => assign(summary, suiteSelectors(summary), {
-        suiteName,
-    }));
+    return useSuiteResultCache(() => {
+        // eslint-disable-next-line vest-internal/use-use
+        const summary = useProduceSuiteSummary();
+        // eslint-disable-next-line vest-internal/use-use
+        const suiteName = useSuiteName();
+        return Object.freeze(assign(summary, suiteSelectors(summary), {
+            suiteName,
+        }));
+    });
 }
 
 /**
@@ -877,8 +674,6 @@ function useIsExcluded(testObject) {
     // If there is _ANY_ `only`ed test (and we already know this one isn't) return true
     if (hasIncludedTests(keyTests)) {
         // Check if inclusion rules for this field (`include` hook)
-        // TODO: Check if this may need to be moved outside of the condition.
-        // What if there are no included tests? This shouldn't run then?
         return !optionalFunctionValue(inclusion[fieldName]);
     }
     // We're done here. This field is not excluded
@@ -999,49 +794,64 @@ function useForceSkipIfInSkipWhen(testNode) {
     return testNode;
 }
 
-class IsolateTestReconciler extends Reconciler {
-    static reconciler(currentNode, historyNode) {
-        // Start by verifying params
-        if (!IsolateTest.is(currentNode)) {
-            return currentNode;
-        }
-        if (isNullish(historyNode)) {
-            return this.handleNoHistoryNode(currentNode);
-        }
-        if (!IsolateTest.is(historyNode)) {
-            return currentNode;
-        }
-        const reconcilerOutput = this.pickNode(historyNode, currentNode);
-        cancelOverriddenPendingTestOnTestReRun(reconcilerOutput, currentNode, historyNode);
-        return reconcilerOutput;
+// @vx-allow use-use
+function IsolateTestReconciler(currentNode, historyNode) {
+    // Start by verifying params
+    if (!IsolateTest.is(currentNode)) {
+        // This is unreachable, since this function should only be called with IsolateTest nodes
+        return currentNode;
     }
-    static nodeReorderDetected(newNode, prevNode) {
-        return !!IsolateTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
+    if (isNullish(historyNode)) {
+        return handleNoHistoryNode(currentNode);
     }
-    static handleCollision(newNode, prevNode) {
-        if (newNode.usesKey()) {
-            return IsolateTest.cast(this.handleIsolateNodeWithKey(newNode));
-        }
-        if (this.nodeReorderDetected(newNode, prevNode)) {
-            return this.onNodeReorder(newNode, prevNode);
-        }
-        return IsolateTest.cast(prevNode ? prevNode : newNode);
+    if (!IsolateTest.is(historyNode)) {
+        return currentNode;
+    }
+    const reconcilerOutput = usePickNode(historyNode, currentNode);
+    cancelOverriddenPendingTestOnTestReRun(reconcilerOutput, currentNode, historyNode);
+    return reconcilerOutput;
+}
+// eslint-disable-next-line max-statements
+function nodeReorderDetected(newNode, prevNode) {
+    return !!IsolateTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
+}
+function handleCollision(newNode, prevNode) {
+    if (newNode.usesKey()) {
+        return IsolateTest.cast(Reconciler.handleIsolateNodeWithKey(newNode));
     }
-    static onNodeReorder(newNode, prevNode) {
-        throwTestOrderError(newNode, prevNode);
-        this.removeAllNextNodesInIsolate();
+    if (nodeReorderDetected(newNode, prevNode)) {
+        return onNodeReorder(newNode, prevNode);
+    }
+    if (!IsolateTest.is(prevNode)) {
+        // I believe we cannot actually reach this point.
+        // Because it should already be handled by nodeReorderDetected.
         return newNode;
     }
-    static pickNode(historyNode, currentNode) {
-        const collisionResult = this.handleCollision(currentNode, historyNode);
-        return useVerifyTestRun(currentNode, collisionResult);
+    // FIXME: May-13-2023
+    // This may not be the most ideal solution.
+    // In short: if the node was omitted in the previous run,
+    // we want to re-evaluate it. The reason is that we may incorrectly
+    // identify it is "optional" because it was omitted in the previous run.
+    // There may be a better way to handle this. Need to revisit this.
+    if (prevNode.isOmitted()) {
+        return newNode;
     }
-    static handleNoHistoryNode(testNode) {
-        if (testNode.usesKey()) {
-            return IsolateTest.cast(this.handleIsolateNodeWithKey(testNode));
-        }
-        return testNode;
+    return prevNode;
+}
+function onNodeReorder(newNode, prevNode) {
+    throwTestOrderError(newNode, prevNode);
+    Reconciler.removeAllNextNodesInIsolate();
+    return newNode;
+}
+function usePickNode(historyNode, currentNode) {
+    const collisionResult = handleCollision(currentNode, historyNode);
+    return useVerifyTestRun(currentNode, collisionResult);
+}
+function handleNoHistoryNode(testNode) {
+    if (testNode.usesKey()) {
+        return IsolateTest.cast(Reconciler.handleIsolateNodeWithKey(testNode));
     }
+    return testNode;
 }
 function cancelOverriddenPendingTestOnTestReRun(nextNode, currentNode, prevTestObject) {
     if (nextNode === currentNode && IsolateTest.is(currentNode)) {
@@ -1058,30 +868,6 @@ function throwTestOrderError(newNode, prevNode) {
     }));
 }
 
-function StateMachine(machine) {
-    let state = machine.initial;
-    const api = { getState, transition };
-    return api;
-    function getState() {
-        return state;
-    }
-    function transition(action, payload) {
-        const transitionTo = machine.states[state][action];
-        let target = transitionTo;
-        if (Array.isArray(target)) {
-            const [, conditional] = target;
-            if (!conditional(payload)) {
-                return;
-            }
-            target = target[0];
-        }
-        if (!target || target === state) {
-            return;
-        }
-        state = target;
-    }
-}
-
 var TestStatus;
 (function (TestStatus) {
     TestStatus["UNTESTED"] = "UNTESTED";
@@ -1104,32 +890,21 @@ function createTestStateMachine() {
 const machine = {
     initial: TestStatus.UNTESTED,
     states: {
+        '*': {
+            [TestStatus.OMITTED]: TestStatus.OMITTED,
+            [TestAction.RESET]: TestStatus.UNTESTED,
+        },
         [TestStatus.UNTESTED]: {
             [TestStatus.CANCELED]: TestStatus.CANCELED,
             [TestStatus.FAILED]: TestStatus.FAILED,
-            [TestStatus.OMITTED]: TestStatus.OMITTED,
             [TestStatus.PASSING]: TestStatus.PASSING,
             [TestStatus.PENDING]: TestStatus.PENDING,
             [TestStatus.SKIPPED]: TestStatus.SKIPPED,
             [TestStatus.WARNING]: TestStatus.WARNING,
         },
-        [TestStatus.SKIPPED]: {
-            [TestAction.RESET]: TestStatus.UNTESTED,
-        },
-        [TestStatus.FAILED]: {
-            [TestAction.RESET]: TestStatus.UNTESTED,
-        },
-        [TestStatus.WARNING]: {
-            [TestAction.RESET]: TestStatus.UNTESTED,
-        },
-        [TestStatus.PASSING]: {
-            [TestAction.RESET]: TestStatus.UNTESTED,
-        },
         [TestStatus.PENDING]: {
-            [TestAction.RESET]: TestStatus.UNTESTED,
             [TestStatus.CANCELED]: TestStatus.CANCELED,
             [TestStatus.FAILED]: TestStatus.FAILED,
-            [TestStatus.OMITTED]: TestStatus.OMITTED,
             [TestStatus.PASSING]: TestStatus.PASSING,
             [TestStatus.SKIPPED]: [
                 TestStatus.SKIPPED,
@@ -1137,12 +912,12 @@ const machine = {
             ],
             [TestStatus.WARNING]: TestStatus.WARNING,
         },
-        [TestStatus.CANCELED]: {
-            [TestAction.RESET]: TestStatus.UNTESTED,
-        },
-        [TestStatus.OMITTED]: {
-            [TestAction.RESET]: TestStatus.UNTESTED,
-        },
+        [TestStatus.SKIPPED]: {},
+        [TestStatus.FAILED]: {},
+        [TestStatus.WARNING]: {},
+        [TestStatus.PASSING]: {},
+        [TestStatus.CANCELED]: {},
+        [TestStatus.OMITTED]: {},
     },
 };
 /* eslint-enable sort-keys */
@@ -1292,79 +1067,262 @@ class IsolateTest extends Isolate {
     }
 }
 IsolateTest.reconciler = IsolateTestReconciler;
-var TestSeverity;
-(function (TestSeverity) {
-    TestSeverity["Error"] = "error";
-    TestSeverity["Warning"] = "warning";
-})(TestSeverity || (TestSeverity = {}));
 
 class TestWalker {
     static defaultRoot() {
-        return useAvailableSuiteRoot();
+        return VestRuntime.useAvailableRoot();
     }
     static hasNoTests(root = TestWalker.defaultRoot()) {
         if (!root)
             return true;
-        return !has(root, IsolateTest.is);
+        return !Walker.has(root, IsolateTest.is);
+    }
+    static someIncompleteTests(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return Walker.some(root, isolate => {
+            IsolateTest.isX(isolate);
+            return isolate.isPending() && predicate(isolate);
+        }, IsolateTest.is);
+    }
+    static someTests(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return Walker.some(root, isolate => {
+            IsolateTest.isX(isolate);
+            return predicate(isolate);
+        }, IsolateTest.is);
+    }
+    static everyTest(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return Walker.every(root, isolate => {
+            IsolateTest.isX(isolate);
+            return predicate(isolate);
+        }, IsolateTest.is);
+    }
+    static walkTests(callback, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return;
+        Walker.walk(root, (isolate, breakout) => {
+            callback(IsolateTest.cast(isolate), breakout);
+        }, IsolateTest.is);
+    }
+    static hasRemainingTests(fieldName) {
+        return TestWalker.someIncompleteTests(testObject => {
+            if (fieldName) {
+                return matchingFieldName(testObject, fieldName);
+            }
+            return true;
+        });
+    }
+    static pluckTests(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return;
+        Walker.pluck(root, isolate => {
+            IsolateTest.isX(isolate);
+            return predicate(isolate);
+        }, IsolateTest.is);
+    }
+    static resetField(fieldName) {
+        TestWalker.walkTests(testObject => {
+            if (matchingFieldName(testObject, fieldName)) {
+                testObject.reset();
+            }
+        }, TestWalker.defaultRoot());
+    }
+    static removeTestByFieldName(fieldName, root = TestWalker.defaultRoot()) {
+        TestWalker.pluckTests(testObject => {
+            return matchingFieldName(testObject, fieldName);
+        }, root);
+    }
+}
+
+/**
+ * Checks that a given test object matches the currently specified severity level
+ */
+function nonMatchingSeverityProfile(severity, testObject) {
+    return either(severity === Severity.WARNINGS, testObject.warns());
+}
+
+/**
+ * The difference between this file and hasFailures is that hasFailures uses the static
+ * summary object, while this one uses the actual validation state
+ */
+function hasErrorsByTestObjects(fieldName) {
+    return hasFailuresByTestObjects(Severity.ERRORS, fieldName);
+}
+function hasFailuresByTestObjects(severityKey, fieldName) {
+    return TestWalker.someTests(testObject => {
+        return hasFailuresByTestObject(testObject, severityKey, fieldName);
+    });
+}
+function hasGroupFailuresByTestObjects(severityKey, groupName, fieldName) {
+    return TestWalker.someTests(testObject => {
+        if (nonMatchingGroupName(testObject, groupName)) {
+            return false;
+        }
+        return hasFailuresByTestObject(testObject, severityKey, fieldName);
+    });
+}
+/**
+ * Determines whether a certain test profile has failures.
+ */
+function hasFailuresByTestObject(testObject, severityKey, fieldName) {
+    if (!testObject.hasFailures()) {
+        return false;
+    }
+    if (nonMatchingFieldName(testObject, fieldName)) {
+        return false;
+    }
+    if (nonMatchingSeverityProfile(severityKey, testObject)) {
+        return false;
+    }
+    return true;
+}
+
+var Modes;
+(function (Modes) {
+    Modes["EAGER"] = "EAGER";
+    Modes["ALL"] = "ALL";
+    Modes["ONE"] = "ONE";
+})(Modes || (Modes = {}));
+/**
+ * Sets the current execution mode for the current suite.
+ *
+ * Supported modes:
+ * - `EAGER` - (default) Runs all tests, but stops on first failure for each given field.
+ * - `ALL` - Runs all tests, regardless of failures.
+ * - `ONE` - Stops suite execution on first failure of any field.
+ *
+ * @example
+ * ```js
+ * import {Modes, create} from 'vest';
+ *
+ * const suite = create('suite_name', () => {
+ *  vest.mode(Modes.ALL);
+ *
+ *  // ...
+ * });
+ * ```
+ * @param 'ALL' | 'EAGER' | 'ONE' mode - The mode to set.
+ */
+// @vx-allow use-use
+function mode(mode) {
+    const [, setMode] = useMode();
+    setMode(mode);
+}
+function useIsMode(mode) {
+    const [currentMode] = useMode();
+    return currentMode === mode;
+}
+function useIsEager() {
+    return useIsMode(Modes.EAGER);
+}
+function useIsOne() {
+    return useIsMode(Modes.ONE);
+}
+function useShouldSkipBasedOnMode(testObject) {
+    if (useIsOne()) {
+        return hasErrorsByTestObjects();
     }
-    static someIncompleteTests(predicate, root = TestWalker.defaultRoot()) {
-        if (!root)
-            return false;
-        return some(root, isolate => {
-            IsolateTest.isX(isolate);
-            return isolate.isPending() && predicate(isolate);
-        }, IsolateTest.is);
+    if (useIsEager()) {
+        return hasErrorsByTestObjects(testObject.fieldName);
     }
-    static someTests(predicate, root = TestWalker.defaultRoot()) {
-        if (!root)
-            return false;
-        return some(root, isolate => {
-            IsolateTest.isX(isolate);
-            return predicate(isolate);
-        }, IsolateTest.is);
+    return false;
+}
+
+const SuiteContext = createCascade((ctxRef, parentContext) => {
+    if (parentContext) {
+        return null;
     }
-    static everyTest(predicate, root = TestWalker.defaultRoot()) {
-        if (!root)
-            return false;
-        return every(root, isolate => {
-            IsolateTest.isX(isolate);
-            return predicate(isolate);
-        }, IsolateTest.is);
+    return assign({
+        exclusion: {
+            tests: {},
+            groups: {},
+        },
+        inclusion: {},
+        mode: tinyState.createTinyState(Modes.EAGER),
+        testMemoCache,
+    }, ctxRef);
+});
+function useCurrentTest(msg) {
+    return SuiteContext.useX(msg).currentTest;
+}
+function useGroupName() {
+    return SuiteContext.useX().groupName;
+}
+function useExclusion(hookError) {
+    return SuiteContext.useX(hookError).exclusion;
+}
+function useInclusion() {
+    return SuiteContext.useX().inclusion;
+}
+function useMode() {
+    return SuiteContext.useX().mode();
+}
+function useSkipped() {
+    var _a;
+    return (_a = SuiteContext.useX().skipped) !== null && _a !== void 0 ? _a : false;
+}
+function useOmitted() {
+    var _a;
+    return (_a = SuiteContext.useX().omitted) !== null && _a !== void 0 ? _a : false;
+}
+const testMemoCache = cache(10);
+function useTestMemoCache() {
+    return SuiteContext.useX().testMemoCache;
+}
+
+/**
+ * This module gets triggered once the suite is done running its sync tests.
+ *
+ * It goes over all the tests in the state, and checks if they need to be omitted.
+ */
+function useOmitOptionalFields() {
+    const root = VestRuntime.useAvailableRoot();
+    const emit = VestRuntime.useEmit();
+    const optionalFields = root === null || root === void 0 ? void 0 : root.getOptionalFields();
+    // If there are no optional fields, we don't need to do anything
+    if (isEmpty(optionalFields)) {
+        return;
     }
-    static walkTests(callback, root = TestWalker.defaultRoot()) {
-        if (!root)
+    // Create an object to store the fields that need to be omitted
+    const shouldOmit = new Set();
+    // iterate over each of the tests in the state
+    TestWalker.walkTests(testObject => {
+        if (testObject.isPending()) {
             return;
-        walk(root, (isolate, breakout) => {
-            callback(IsolateTest.cast(isolate), breakout);
-        }, IsolateTest.is);
-    }
-    static hasRemainingTests(fieldName) {
-        return TestWalker.someIncompleteTests(testObject => {
-            if (fieldName) {
-                return matchingFieldName(testObject, fieldName);
-            }
-            return true;
-        });
+        }
+        // If we already added the current field (not this test specifically)
+        // no need for further checks, go and omit the test
+        if (hasOwnProperty(shouldOmit, testObject.fieldName)) {
+            verifyAndOmit(testObject);
+        }
+        else {
+            // check if the field has an optional function
+            // if so, run it and verify/omit the test
+            runOptionalConfig(testObject);
+        }
+    });
+    emit(Events.DONE_TEST_OMISSION_PASS);
+    function verifyAndOmit(testObject) {
+        if (shouldOmit.has(testObject.fieldName)) {
+            testObject.omit();
+            root === null || root === void 0 ? void 0 : root.setOptionalField(testObject.fieldName, current => (Object.assign(Object.assign({}, current), { applied: true })));
+        }
     }
-    static pluckTests(predicate, root = TestWalker.defaultRoot()) {
-        if (!root)
+    function runOptionalConfig(testObject) {
+        // Ge the optional configuration for the given field
+        const optionalConfig = root === null || root === void 0 ? void 0 : root.getOptionalField(testObject.fieldName);
+        if (isNullish(optionalConfig)) {
             return;
-        pluck(root, isolate => {
-            IsolateTest.isX(isolate);
-            return predicate(isolate);
-        }, IsolateTest.is);
-    }
-    static resetField(fieldName) {
-        TestWalker.walkTests(testObject => {
-            if (matchingFieldName(testObject, fieldName)) {
-                testObject.reset();
-            }
-        }, TestWalker.defaultRoot());
-    }
-    static removeTestByFieldName(fieldName, root = TestWalker.defaultRoot()) {
-        TestWalker.pluckTests(testObject => {
-            return matchingFieldName(testObject, fieldName);
-        }, root);
+        }
+        // If the optional was set to a function or a boolean, run it and verify/omit the test
+        if (optionalFunctionValue(optionalConfig.rule) === true) {
+            shouldOmit.add(testObject.fieldName);
+        }
+        verifyAndOmit(testObject);
     }
 }
 
@@ -1387,8 +1345,9 @@ function useRunDoneCallbacks() {
     callEach(doneCallbacks);
 }
 
+// eslint-disable-next-line max-statements
 function useInitVestBus() {
-    const VestBus = bus.createBus();
+    const VestBus = VestRuntime.useBus();
     // Report a the completion of a test. There may be other tests with the same
     // name that are still running, or not yet started.
     on(Events.TEST_COMPLETED, (testObject) => {
@@ -1404,8 +1363,18 @@ function useInitVestBus() {
     on(Events.TEST_RUN_STARTED, () => {
         /* Let's just invalidate the suite cache for now */
     });
+    on(Events.DONE_TEST_OMISSION_PASS, () => {
+        /* We NEED to refresh the cache here. Don't ask */
+    });
     // Called when all the tests, including async, are done running
     on(Events.ALL_RUNNING_TESTS_FINISHED, () => {
+        // Small optimization. We don't need to run this if there are no async tests
+        // The reason is that we run this function immediately after the suite callback
+        // is run, so if the suite is only comprised of sync tests, we don't need to
+        // run this function twice since we know for a fact the state is up to date
+        if (TestWalker.someTests(test => test.isAsyncTest())) {
+            useOmitOptionalFields();
+        }
         useRunDoneCallbacks();
     });
     on(Events.RESET_FIELD, (fieldName) => {
@@ -1414,6 +1383,9 @@ function useInitVestBus() {
     on(Events.SUITE_RUN_STARTED, () => {
         useResetCallbacks();
     });
+    on(Events.SUITE_CALLBACK_RUN_FINISHED, () => {
+        useOmitOptionalFields();
+    });
     on(Events.REMOVE_FIELD, (fieldName) => {
         TestWalker.removeTestByFieldName(fieldName);
     });
@@ -1431,202 +1403,24 @@ function useInitVestBus() {
     }
 }
 
-const suiteResultCache = cache();
-const PersistedContext = createCascade((vestState, parentContext) => {
-    if (parentContext) {
-        return null;
-    }
-    invariant(vestState.historyRoot);
-    const [historyRootNode] = vestState.historyRoot();
-    const ctxRef = {};
-    assign(ctxRef, {
-        historyNode: historyRootNode,
-        runtimeNode: null,
-        runtimeRoot: null,
-    }, vestState);
-    return ctxRef;
-});
-function useCreateVestState({ suiteName, } = {}) {
-    const stateRef = {
-        VestBus: useInitVestBus(),
-        doneCallbacks: tinyState.createTinyState(() => []),
-        fieldCallbacks: tinyState.createTinyState(() => ({})),
-        historyRoot: tinyState.createTinyState(null),
-        suiteId: seq(),
-        suiteName,
-        suiteResultCache,
-    };
-    return stateRef;
-}
-function persist(cb) {
-    const prev = PersistedContext.useX();
-    return function persisted(...args) {
-        var _a;
-        const ctxToUse = (_a = PersistedContext.use()) !== null && _a !== void 0 ? _a : prev;
-        return PersistedContext.run(ctxToUse, () => cb(...args));
-    };
-}
-function useSuiteResultCache(action) {
-    const suiteResultCache = useX().suiteResultCache;
-    return suiteResultCache([useSuiteId()], action);
-}
-function useExpireSuiteResultCache() {
-    const suiteResultCache = useX().suiteResultCache;
-    suiteResultCache.invalidate([useSuiteId()]);
-}
-function useResetCallbacks() {
-    const [, , resetDoneCallbacks] = useDoneCallbacks();
-    const [, , resetFieldCallbacks] = useFieldCallbacks();
-    resetDoneCallbacks();
-    resetFieldCallbacks();
-}
-function useResetSuite() {
-    useResetCallbacks();
-    const [, , resetHistoryRoot] = useHistoryRoot();
-    resetHistoryRoot();
-}
-function useX() {
-    return PersistedContext.useX();
-}
-function useVestBus() {
-    return useX().VestBus;
-}
-/*
-  Returns an emitter, but it also has a shortcut for emitting an event immediately
-  by passing an event name.
-*/
-function useEmit() {
-    return persist(useVestBus().emit);
-}
-function usePrepareEmitter(event) {
-    const emit = useEmit();
-    return (arg) => emit(event, arg);
-}
-function useDoneCallbacks() {
-    return useX().doneCallbacks();
-}
-function useFieldCallbacks() {
-    return useX().fieldCallbacks();
-}
-function useHistoryRoot() {
-    return useX().historyRoot();
-}
-function useHistoryNode() {
-    return useX().historyNode;
-}
-function useSuiteName() {
-    return useX().suiteName;
-}
-function useSuiteId() {
-    return useX().suiteId;
-}
-function useSetHistory(history) {
-    const context = PersistedContext.useX();
-    const [, setHistoryRoot] = context.historyRoot();
-    setHistoryRoot(history);
-}
-function useHistoryKey(key) {
-    var _a;
-    if (isNullish(key)) {
-        return null;
-    }
-    const historyNode = useX().historyNode;
-    return (_a = historyNode === null || historyNode === void 0 ? void 0 : historyNode.keys[key]) !== null && _a !== void 0 ? _a : null;
-}
-function useIsolate() {
-    var _a;
-    return (_a = useX().runtimeNode) !== null && _a !== void 0 ? _a : null;
-}
-function useCurrentCursor() {
-    var _a, _b;
-    return (_b = (_a = useIsolate()) === null || _a === void 0 ? void 0 : _a.cursor()) !== null && _b !== void 0 ? _b : 0;
-}
-function useRuntimeRoot() {
-    return useX().runtimeRoot;
-}
-function useSetNextIsolateChild(child) {
-    const currentIsolate = useIsolate();
-    invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
-    currentIsolate.addChild(child);
-}
-function useSetIsolateKey(key, value) {
-    if (!key) {
-        return;
-    }
-    const currentIsolate = useIsolate();
-    invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
-    if (isNullish(currentIsolate.keys[key])) {
-        currentIsolate.keys[key] = value;
-        return;
-    }
-    deferThrow(text(ErrorStrings.ENCOUNTERED_THE_SAME_KEY_TWICE, { key }));
-}
-function useAvailableSuiteRoot() {
-    const root = useRuntimeRoot();
-    if (root) {
-        return root;
-    }
-    const [historyRoot] = useHistoryRoot();
-    return historyRoot;
-}
-
-// @vx-allow use-use
-function optional(optionals) {
-    const suiteRoot = useRuntimeRoot();
-    // There are two types of optional field declarations:
-    // 1. Delayed: A string, which is the name of the field to be optional.
-    // We will only determine whether to omit the test after the suite is done running
-    //
-    // 2. Immediate: Either a boolean or a function, which is used to determine
-    // if the field should be optional.
-    // Delayed case (field name)
-    if (isArray(optionals) || isStringValue(optionals)) {
-        asArray(optionals).forEach(optionalField => {
-            suiteRoot.setOptionalField(optionalField, () => ({
-                type: OptionalFieldTypes.Delayed,
-                applied: false,
-                rule: null,
-            }));
-        });
-    }
-    else {
-        // Immediately case (function or boolean)
-        for (const field in optionals) {
-            const value = optionals[field];
-            suiteRoot.setOptionalField(field, () => ({
-                type: OptionalFieldTypes.Immediate,
-                rule: value,
-                applied: optionalFunctionValue(value),
-            }));
-        }
-    }
-}
-function useIsOptionalFiedApplied(fieldName) {
-    var _a, _b, _c;
-    if (!fieldName) {
-        return false;
-    }
-    return (_c = (_b = (_a = useAvailableSuiteRoot()) === null || _a === void 0 ? void 0 : _a.getOptionalField(fieldName)) === null || _b === void 0 ? void 0 : _b.applied) !== null && _c !== void 0 ? _c : false;
-}
-
-class IsolateSuite extends Isolate {
-    constructor() {
-        super(...arguments);
-        this.optional = {};
-    }
-    setOptionalField(fieldName, setter) {
-        const current = this.optional;
-        const currentField = current[fieldName];
-        Object.assign(current, {
-            [fieldName]: Object.assign({}, currentField, setter(currentField)),
-        });
-    }
-    getOptionalField(fieldName) {
-        var _a;
-        return (_a = this.optional[fieldName]) !== null && _a !== void 0 ? _a : {};
-    }
-}
-
+/**
+ * Conditionally includes a field for testing, based on specified criteria.
+ *
+ * @param {string} fieldName - The name of the field to include for testing.
+ *
+ * @example
+ * include('confirm').when('password');
+ * // Includes the "confirm" field for testing when the "password" field is included
+ *
+ * include('confirm').when(someValue);
+ * // Includes the "confirm" field for testing when the value of `someValue` is true
+ *
+ * include('confirm').when(() => someValue);
+ * // Includes the "confirm" field for testing when the callback function returns true
+ *
+ * include('username').when(result => result.hasErrors('username'));
+ * // Includes the "username" field for testing when there are errors associated with it in the current suite result
+ */
 // @vx-allow use-use
 function include(fieldName) {
     const inclusion = useInclusion();
@@ -1634,6 +1428,9 @@ function include(fieldName) {
     invariant(isStringValue(fieldName));
     inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
     return { when };
+    /**
+     * Specifies the inclusion criteria for the field in `include` function.
+     */
     function when(condition) {
         const inclusion = useInclusion();
         const exclusion = useExclusion();
@@ -1653,18 +1450,16 @@ function include(fieldName) {
     }
 }
 
-function useAttemptRunTestObjectByTier(testObject) {
+// eslint-disable-next-line max-statements
+function useAttemptRunTest(testObject) {
     useVerifyTestRun(testObject);
-    if (testObject.isNonActionable()) {
-        // TODO: Need to test that this works as expected
-        return;
-    }
     if (testObject.isUntested()) {
-        useRunTest(testObject);
+        return useRunTest(testObject);
     }
-    else if (testObject.isAsyncTest()) {
-        testObject.setPending();
-        useRunAsyncTest(testObject);
+    if (!testObject.isNonActionable()) {
+        deferThrow(text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
+            testObject: JSON.stringify(testObject),
+        }));
     }
 }
 function runSyncTest(testObject) {
@@ -1674,7 +1469,7 @@ function runSyncTest(testObject) {
  * runs test, if async - adds to pending array
  */
 function useRunTest(testObject) {
-    const VestBus = useVestBus();
+    const VestBus = VestRuntime.useBus();
     // Run test callback.
     // If a promise is returned, set as async and
     // Move to pending list.
@@ -1684,7 +1479,6 @@ function useRunTest(testObject) {
         // in case object is an enforce chain
         if (isPromise(result)) {
             testObject.asyncTest = result;
-            testObject.setPending();
             useRunAsyncTest(testObject);
         }
         else {
@@ -1705,11 +1499,12 @@ function useRunAsyncTest(testObject) {
     const { asyncTest, message } = testObject;
     if (!isPromise(asyncTest))
         return;
-    const VestBus = useVestBus();
-    const done = persist(() => {
+    testObject.setPending();
+    const VestBus = VestRuntime.useBus();
+    const done = VestRuntime.persist(() => {
         onTestCompleted(VestBus, testObject);
     });
-    const fail = persist((rejectionMessage) => {
+    const fail = VestRuntime.persist((rejectionMessage) => {
         if (testObject.isCanceled()) {
             return;
         }
@@ -1733,7 +1528,11 @@ function wrapTestMemo(test) {
     function memo(fieldName, ...args) {
         const [deps, testFn, msg] = args.reverse();
         // Implicit dependency for better specificity
-        const dependencies = [useSuiteId(), fieldName, useCurrentCursor()].concat(deps);
+        const dependencies = [
+            useSuiteId(),
+            fieldName,
+            VestRuntime.useCurrentCursor(),
+        ].concat(deps);
         return useGetTestFromCache(dependencies, cacheAction);
         function cacheAction() {
             return test(fieldName, msg, testFn);
@@ -1763,11 +1562,11 @@ function vestTest(fieldName, ...args) {
     const [message, testFn, key] = (isFunction(args[1]) ? args : [undefined, ...args]);
     validateTestParams(fieldName, testFn);
     const groupName = useGroupName();
-    const emit = useEmit();
+    const emit = VestRuntime.useEmit();
     const testObjectInput = { fieldName, groupName, key, message, testFn };
     // This invalidates the suite cache.
     emit(Events.TEST_RUN_STARTED);
-    return IsolateTest.create(useAttemptRunTestObjectByTier, testObjectInput);
+    return IsolateTest.create(useAttemptRunTest, testObjectInput);
 }
 const test = assign(vestTest, {
     memo: wrapTestMemo(vestTest),
@@ -1822,9 +1621,9 @@ function shouldSkipDoneRegistration(callback, fieldName, output) {
 }
 
 function useSuiteRunResult() {
-    return assign({}, useCreateSuiteResult(), {
-        done: persist(done),
-    });
+    return Object.freeze(assign({
+        done: VestRuntime.persist(done),
+    }, useCreateSuiteResult()));
 }
 /**
  * Registers done callbacks.
@@ -1860,24 +1659,27 @@ function createSuite(...args) {
     function suite(...args) {
         return SuiteContext.run({}, () => {
             // eslint-disable-next-line vest-internal/use-use
-            const emit = useEmit();
+            const emit = VestRuntime.useEmit();
             emit(Events.SUITE_RUN_STARTED);
             return IsolateSuite.create(useRunSuiteCallback(suiteCallback, ...args));
         }).output;
     }
     // Assign methods to the suite
-    // We do this within the PersistedContext so that the suite methods
+    // We do this within the VestRuntime so that the suite methods
     // will be bound to the suite's stateRef and be able to access it.
-    return PersistedContext.run(stateRef, () => {
+    return VestRuntime.Run(stateRef, () => {
+        useInitVestBus();
         return assign(
         // We're also binding the suite to the stateRef, so that the suite
         // can access the stateRef when it's called.
-        PersistedContext.bind(stateRef, suite), Object.assign({ get: persist(useCreateSuiteResult), remove: usePrepareEmitter(Events.REMOVE_FIELD), reset: usePrepareEmitter(Events.RESET_SUITE), resetField: usePrepareEmitter(Events.RESET_FIELD) }, getTypedMethods()));
+        VestRuntime.persist(suite), Object.assign(Object.assign({ get: VestRuntime.persist(useCreateSuiteResult), remove: VestRuntime.usePrepareEmitter(Events.REMOVE_FIELD), reset: VestRuntime.usePrepareEmitter(Events.RESET_SUITE), resetField: VestRuntime.usePrepareEmitter(Events.RESET_FIELD) }, bindSuiteSelectors(VestRuntime.persist(useCreateSuiteResult))), getTypedMethods()));
     });
 }
 function useRunSuiteCallback(suiteCallback, ...args) {
+    const emit = VestRuntime.useEmit();
     return () => {
         suiteCallback(...args);
+        emit(Events.SUITE_CALLBACK_RUN_FINISHED);
         return useSuiteRunResult();
     };
 }
@@ -1917,13 +1719,45 @@ function group(groupName, callback) {
     });
 }
 
+/**
+ * Creates a static suite for server-side validation.
+ *
+ * @param {Function} validationFn - The validation function that defines the suite's tests.
+ * @returns {Function} - A function that runs the validations defined in the suite.
+ *
+ * @example
+ * import { staticSuite, test, enforce } from 'vest';
+ *
+ * const suite = staticSuite(data => {
+ *   test('username', 'username is required', () => {
+ *     enforce(data.username).isNotEmpty();
+ *   });
+ * });
+ *
+ * suite(data);
+ */
 function staticSuite(suiteCallback) {
     return assign((...args) => createSuite(suiteCallback)(...args), Object.assign({}, getTypedMethods()));
 }
 
 const ERROR_OUTSIDE_OF_TEST = ErrorStrings.WARN_MUST_BE_CALLED_FROM_TEST;
 /**
- * Sets a running test to warn only mode.
+ * Sets the severity level of a test to `warn`, allowing it to fail without marking the suite as invalid.
+ * Use this function within the body of a test to create warn-only tests.
+ *
+ * @returns {void}
+ *
+ * @example
+ *   test('password', 'Your password strength is: WEAK', () => {
+ *     warn();
+ *
+ *     enforce(data.password).matches(/0-9/);
+ *   });
+ *
+ * @limitations
+ * - The `warn` function should only be used within the body of a `test` function.
+ * - When using `warn()` in an async test, it should be called in the synchronous portion of the test, not after an `await` call or in the Promise body.
+ * - It is recommended to call `warn()` at the top of the test function.
  */
 // @vx-allow use-use
 function warn() {