vest 5.2.9 → 5.2.10

package/dist/es/vest.development.js

@@ -1,6 +1,6 @@
 import { enforce } from 'n4s';
 export { enforce } from 'n4s';
-import { assign, tinyState, cache, isArray, isStringValue, asArray, hasOwnProperty, seq, StateMachine, invariant, isPromise, optionalFunctionValue, Predicates, isNullish, isEmpty, callEach, bindNot, either, isPositive, greaterThan, defaultTo, noop, isNotEmpty, isNotNullish, deferThrow, text, isUndefined, isNull, isFunction, numberEquals } from 'vest-utils';
+import { assign, tinyState, cache, isArray, isStringValue, asArray, hasOwnProperty, noop, isNotEmpty, seq, isPositive, greaterThan, StateMachine, invariant, isPromise, optionalFunctionValue, Predicates, isNullish, bindNot, either, defaultTo, isNotNullish, isUndefined, deferThrow, text, isNull, isFunction, isEmpty, callEach, numberEquals } from 'vest-utils';
 import { Isolate, VestRuntime, IsolateSelectors, IsolateMutator, Walker, Bus, RuntimeEvents, IsolateInspector, Reconciler } from 'vestjs-runtime';
 import { createCascade } from 'context';
 
@@ -139,18 +139,85 @@ function useIsOptionalFieldApplied(fieldName) {
     return ((_b = (_a = SuiteOptionalFields.getOptionalField(root, fieldName)) === null || _a === void 0 ? void 0 : _a.applied) !== null && _b !== void 0 ? _b : false);
 }
 
-var Events;
-(function (Events) {
-    Events["TEST_RUN_STARTED"] = "test_run_started";
-    Events["TEST_COMPLETED"] = "test_completed";
-    Events["ALL_RUNNING_TESTS_FINISHED"] = "all_running_tests_finished";
-    Events["REMOVE_FIELD"] = "remove_field";
-    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 = {}));
+var FocusModes;
+(function (FocusModes) {
+    FocusModes[FocusModes["ONLY"] = 0] = "ONLY";
+    FocusModes[FocusModes["SKIP"] = 1] = "SKIP";
+})(FocusModes || (FocusModes = {}));
+
+function IsolateFocused(focusMode, match) {
+    return Isolate.create(VestIsolateType.Focused, noop, {
+        focusMode,
+        match: asArray(match).filter(isStringValue),
+        matchAll: match === true,
+    });
+}
+class FocusSelectors {
+    static isSkipFocused(focus, fieldName) {
+        return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.SKIP &&
+            (hasFocus(focus, fieldName) || focus.data.matchAll === true));
+    }
+    static isOnlyFocused(focus, fieldName) {
+        return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.ONLY && hasFocus(focus, fieldName));
+    }
+    static isIsolateFocused(isolate) {
+        return IsolateSelectors.isIsolateType(isolate, VestIsolateType.Focused);
+    }
+}
+/**
+ * Adds a field or a list of fields into the inclusion list
+ *
+ * @example
+ *
+ * only('username');
+ */
+// @vx-allow use-use
+function only(match) {
+    return IsolateFocused(FocusModes.ONLY, defaultMatch(match));
+}
+/**
+ * Adds a field or a list of fields into the exclusion list
+ *
+ * @example
+ *
+ * skip('username');
+ */
+// @vx-allow use-use
+function skip(match) {
+    return IsolateFocused(FocusModes.SKIP, defaultMatch(match));
+}
+function defaultMatch(match) {
+    return match === false ? [] : match;
+}
+function hasFocus(focus, fieldName) {
+    var _a, _b;
+    return (isNotEmpty(focus === null || focus === void 0 ? void 0 : focus.data.match) &&
+        (fieldName ? (_b = (_a = focus === null || focus === void 0 ? void 0 : focus.data.match) === null || _a === void 0 ? void 0 : _a.includes(fieldName)) !== null && _b !== void 0 ? _b : true : true));
+}
+
+function group(...args) {
+    const [callback, groupName] = args.reverse();
+    return Isolate.create(VestIsolateType.Group, () => {
+        return SuiteContext.run(Object.assign({}, (groupName && { groupName })), callback);
+    });
+}
+
+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["INCLUDE_SELF"] = "Trying to call include.when on the same field.";
+})(ErrorStrings || (ErrorStrings = {}));
 
 const suiteResultCache = cache();
 function useCreateVestState({ suiteName, VestReconciler, }) {
@@ -201,124 +268,6 @@ function useLoadSuite(rootNode) {
     useExpireSuiteResultCache();
 }
 
-const CommonStates = {
-    PENDING: 'PENDING',
-    INITIAL: 'INITIAL',
-};
-const State = {
-    [CommonStates.PENDING]: CommonStates.PENDING,
-    [CommonStates.INITIAL]: CommonStates.INITIAL,
-    DONE: 'DONE',
-};
-const machine$1 = {
-    initial: State.INITIAL,
-    states: {
-        [State.DONE]: {},
-        [State.INITIAL]: {
-            [State.PENDING]: State.PENDING,
-            [State.DONE]: State.DONE,
-        },
-        [State.PENDING]: {
-            [State.DONE]: State.DONE,
-        },
-    },
-};
-function transition(from, to) {
-    return CommonStateMachine.staticTransition(from !== null && from !== void 0 ? from : State.INITIAL, to);
-}
-function setDone(isolate) {
-    isolate.status = transition(isolate.status, State.DONE);
-}
-function setPending(isolate) {
-    isolate.status = transition(isolate.status, State.PENDING);
-}
-const CommonStateMachine = StateMachine(machine$1);
-
-class VestIsolate {
-    static getStatus(isolate) {
-        var _a;
-        return (_a = isolate.status) !== null && _a !== void 0 ? _a : CommonStates.INITIAL;
-    }
-    static setStatus(isolate, status, payload) {
-        isolate.status = this.stateMachine.staticTransition(VestIsolate.getStatus(isolate), status, payload);
-    }
-    static statusEquals(isolate, status) {
-        return VestIsolate.getStatus(isolate) === status;
-    }
-    static setPending(isolate) {
-        this.setStatus(isolate, CommonStates.PENDING);
-    }
-    static isPending(isolate) {
-        return VestIsolate.statusEquals(isolate, CommonStates.PENDING);
-    }
-}
-VestIsolate.stateMachine = CommonStateMachine;
-
-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["INCLUDE_SELF"] = "Trying to call include.when on the same field.";
-})(ErrorStrings || (ErrorStrings = {}));
-
-const TestStatus = {
-    [CommonStates.PENDING]: CommonStates.PENDING,
-    CANCELED: 'CANCELED',
-    FAILED: 'FAILED',
-    OMITTED: 'OMITTED',
-    PASSING: 'PASSING',
-    SKIPPED: 'SKIPPED',
-    UNTESTED: 'UNTESTED',
-    WARNING: 'WARNING',
-};
-const TestAction = {
-    RESET: 'RESET',
-};
-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.PASSING]: TestStatus.PASSING,
-            [TestStatus.PENDING]: TestStatus.PENDING,
-            [TestStatus.SKIPPED]: TestStatus.SKIPPED,
-            [TestStatus.WARNING]: TestStatus.WARNING,
-        },
-        [TestStatus.PENDING]: {
-            [TestStatus.CANCELED]: TestStatus.CANCELED,
-            [TestStatus.FAILED]: TestStatus.FAILED,
-            [TestStatus.PASSING]: TestStatus.PASSING,
-            [TestStatus.SKIPPED]: [
-                TestStatus.SKIPPED,
-                (force) => force === true,
-            ],
-            [TestStatus.WARNING]: TestStatus.WARNING,
-        },
-        [TestStatus.SKIPPED]: {},
-        [TestStatus.FAILED]: {},
-        [TestStatus.WARNING]: {},
-        [TestStatus.PASSING]: {},
-        [TestStatus.CANCELED]: {},
-        [TestStatus.OMITTED]: {},
-    },
-};
-const IsolateTestStateMachine = StateMachine(machine);
-
 var Severity;
 (function (Severity) {
     Severity["WARNINGS"] = "warnings";
@@ -340,161 +289,449 @@ var TestSeverity;
     TestSeverity["Warning"] = "warning";
 })(TestSeverity || (TestSeverity = {}));
 
-class VestTest extends VestIsolate {
-    // Read
-    static getData(test) {
-        invariant(test.data);
-        return test.data;
-    }
-    static is(isolate) {
-        return IsolateSelectors.isIsolateType(isolate, VestIsolateType.Test);
-    }
-    static isX(isolate) {
-        invariant(VestTest.is(isolate), ErrorStrings.EXPECTED_VEST_TEST);
+// calls collectAll or getByFieldName depending on whether fieldName is provided
+function gatherFailures(testGroup, severityKey, fieldName) {
+    return fieldName
+        ? getByFieldName(testGroup, severityKey, fieldName)
+        : collectAll(testGroup, severityKey);
+}
+function getByFieldName(testGroup, severityKey, fieldName) {
+    var _a;
+    return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
+}
+function collectAll(testGroup, severityKey) {
+    const output = {};
+    const countKey = countKeyBySeverity(severityKey);
+    for (const field in testGroup) {
+        if (isPositive(testGroup[field][countKey])) {
+            // We will probably never get to the fallback array
+            // leaving it just in case the implementation changes
+            output[field] = testGroup[field][severityKey] || [];
+        }
     }
-    static cast(isolate) {
-        VestTest.isX(isolate);
-        return isolate;
+    return output;
+}
+
+function nonMatchingFieldName(WithFieldName, fieldName) {
+    return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
+}
+function matchingFieldName(WithFieldName, fieldName) {
+    return !!(fieldName && WithFieldName.fieldName === fieldName);
+}
+function matchesOrHasNoFieldName(WithFieldName, fieldName) {
+    if (fieldName) {
+        return matchingFieldName(WithFieldName, fieldName);
     }
-    static warns(test) {
-        return VestTest.getData(test).severity === TestSeverity.Warning;
-    }
-    static isOmitted(test) {
-        return VestTest.statusEquals(test, TestStatus.OMITTED);
-    }
-    static isUntested(test) {
-        return VestTest.statusEquals(test, TestStatus.UNTESTED);
-    }
-    static isFailing(test) {
-        return VestTest.statusEquals(test, TestStatus.FAILED);
-    }
-    static isCanceled(test) {
-        return VestTest.statusEquals(test, TestStatus.CANCELED);
-    }
-    static isSkipped(test) {
-        return VestTest.statusEquals(test, TestStatus.SKIPPED);
-    }
-    static isPassing(test) {
-        return VestTest.statusEquals(test, TestStatus.PASSING);
-    }
-    static isWarning(test) {
-        return VestTest.statusEquals(test, TestStatus.WARNING);
+    return true;
+}
+
+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),
+        isPending: (...args) => {
+            return get().isPending(...args);
+        },
+        isTested: (...args) => get().isTested(...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 = {
+        getError,
+        getErrors,
+        getErrorsByGroup,
+        getWarning,
+        getWarnings,
+        getWarningsByGroup,
+        hasErrors,
+        hasErrorsByGroup,
+        hasWarnings,
+        hasWarningsByGroup,
+        isPending,
+        isTested,
+        isValid,
+        isValidByGroup,
+    };
+    return selectors;
+    // Booleans
+    function isValid(fieldName) {
+        var _a;
+        return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
     }
-    static hasFailures(test) {
-        return VestTest.isFailing(test) || VestTest.isWarning(test);
+    function isValidByGroup(groupName, fieldName) {
+        const group = summary.groups[groupName];
+        if (!group) {
+            return false;
+        }
+        if (fieldName) {
+            return isFieldValid(group, fieldName);
+        }
+        for (const fieldName in group) {
+            if (!isFieldValid(group, fieldName)) {
+                return false;
+            }
+        }
+        return true;
     }
-    static isNonActionable(test) {
-        return (VestTest.isSkipped(test) ||
-            VestTest.isOmitted(test) ||
-            VestTest.isCanceled(test));
+    function hasWarnings(fieldName) {
+        return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
     }
-    static isTested(test) {
-        return VestTest.hasFailures(test) || VestTest.isPassing(test);
+    function hasErrors(fieldName) {
+        return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
     }
-    static awaitsResolution(test) {
-        // Is the test in a state where it can still be run, or complete running
-        // and its final status is indeterminate?
-        return (VestTest.isSkipped(test) ||
-            VestTest.isUntested(test) ||
-            VestTest.isPending(test));
+    function isTested(fieldName) {
+        var _a;
+        return isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount);
     }
-    static isAsyncTest(test) {
-        return isPromise(VestTest.getData(test).asyncTest);
+    function hasWarningsByGroup(groupName, fieldName) {
+        return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
     }
-    // Mutate
-    // static setPending(test: TIsolateTest) {
-    //   this.setStatus(test, TestStatus.PENDING);
-    // }
-    static fail(test) {
-        VestTest.setStatus(test, VestTest.warns(test) ? TestStatus.WARNING : TestStatus.FAILED);
+    function hasErrorsByGroup(groupName, fieldName) {
+        return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
     }
-    static pass(test) {
-        VestTest.setStatus(test, TestStatus.PASSING);
+    function getWarnings(fieldName) {
+        return getFailures(summary, Severity.WARNINGS, fieldName);
     }
-    static warn(test) {
-        VestTest.setData(test, current => (Object.assign(Object.assign({}, current), { severity: TestSeverity.Warning })));
+    function getWarning(fieldName) {
+        return getFailure(Severity.WARNINGS, summary, fieldName);
     }
-    static setData(test, setter) {
-        test.data = optionalFunctionValue(setter, VestTest.getData(test));
+    function getErrors(fieldName) {
+        return getFailures(summary, Severity.ERRORS, fieldName);
     }
-    static skip(test, force) {
-        // Without this force flag, the test will be marked as skipped even if it is pending.
-        // This means that it will not be counted in "allIncomplete" and its done callbacks
-        // will not be called, or will be called prematurely.
-        // What this mostly say is that when we have a pending test for one field, and we then
-        // start typing in a different field - the pending test will be canceled, which
-        // is usually an unwanted behavior.
-        // The only scenario in which we DO want to cancel the async test regardless
-        // is when we specifically skip a test with `skipWhen`, which is handled by the
-        // "force" boolean flag.
-        // I am not a fan of this flag, but it gets the job done.
-        VestTest.setStatus(test, TestStatus.SKIPPED, force);
+    function getError(fieldName) {
+        return getFailure(Severity.ERRORS, summary, fieldName);
     }
-    static cancel(test) {
-        VestTest.setStatus(test, TestStatus.CANCELED);
-        IsolateMutator.abort(test, TestStatus.CANCELED);
+    function getErrorsByGroup(groupName, fieldName) {
+        return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
     }
-    static omit(test) {
-        VestTest.setStatus(test, TestStatus.OMITTED);
+    function getWarningsByGroup(groupName, fieldName) {
+        return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
     }
-    static reset(test) {
-        VestTest.setStatus(test, TestAction.RESET);
+    function isPending(fieldName) {
+        var _a;
+        return fieldName
+            ? greaterThan((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.pendingCount, 0)
+            : greaterThan(summary.pendingCount, 0);
     }
 }
-VestTest.stateMachine = IsolateTestStateMachine;
-
-function nonMatchingFieldName(WithFieldName, fieldName) {
-    return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
+function getFailures(summary, severityKey, fieldName) {
+    return gatherFailures(summary.tests, severityKey, fieldName);
 }
-function matchingFieldName(WithFieldName, fieldName) {
-    return !!(fieldName && WithFieldName.fieldName === fieldName);
+// Gathers all failures of a given severity within a group
+// With a fieldName, it will only gather failures for that field
+function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
+    return gatherFailures(summary.groups[groupName], severityKey, fieldName);
 }
-function matchesOrHasNoFieldName(WithFieldName, fieldName) {
+// Checks if a field is valid within a container object - can be within a group or top level
+function isFieldValid(testContainer, fieldName) {
+    var _a;
+    return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
+}
+// Checks if a there are any failures of a given severity within a group
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
+    var _a, _b;
+    const group = summary.groups[groupName];
+    if (!group) {
+        return false;
+    }
     if (fieldName) {
-        return matchingFieldName(WithFieldName, fieldName);
+        return isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
     }
-    return true;
-}
-
-class SuiteWalker {
-    static hasPending(predicate) {
-        const root = SuiteWalker.defaultRoot();
-        if (!root) {
-            return false;
+    for (const field in group) {
+        if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
+            return true;
         }
-        return Walker.some(root, Predicates.all(VestIsolate.isPending, predicate !== null && predicate !== void 0 ? predicate : true));
     }
-    // Checks whether there are pending isolates in the tree.
-    // If a fieldname is provided, will only check tests with a matching fieldname.
-    static hasRemainingWithTestNameMatching(fieldName) {
-        return SuiteWalker.hasPending(Predicates.any(isNullish(fieldName), Predicates.all(VestTest.is, (testObject) => {
-            return matchesOrHasNoFieldName(VestTest.getData(testObject), fieldName);
-        })));
+    return false;
+}
+// Checks if there are any failures of a given severity
+// If a fieldName is provided, it will only check for failures within that field
+function hasFailures(summary, countKey, fieldName) {
+    var _a;
+    const failureCount = fieldName
+        ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
+        : summary[countKey] || 0;
+    return isPositive(failureCount);
+}
+function getFailure(severity, summary, fieldName) {
+    var _a;
+    const summaryKey = summary[severity];
+    if (!fieldName) {
+        return summaryKey[0];
     }
+    return (_a = summaryKey.find((summaryFailure) => matchingFieldName(summaryFailure, fieldName))) === null || _a === void 0 ? void 0 : _a.message;
 }
-SuiteWalker.defaultRoot = VestRuntime.useAvailableRoot;
 
-class TestWalker {
-    static hasNoTests(root = TestWalker.defaultRoot()) {
-        if (!root)
-            return true;
-        return !Walker.has(root, VestTest.is);
-    }
-    static someTests(predicate, root = TestWalker.defaultRoot()) {
-        if (!root)
-            return false;
-        return Walker.some(root, isolate => {
-            VestTest.isX(isolate);
-            return predicate(isolate);
-        }, VestTest.is);
+var _a, _b;
+class SummaryBase {
+    constructor() {
+        this.errorCount = 0;
+        this.warnCount = 0;
+        this.testCount = 0;
+        this.pendingCount = 0;
     }
-    static everyTest(predicate, root = TestWalker.defaultRoot()) {
-        if (!root)
-            return false;
-        return Walker.every(root, isolate => {
-            VestTest.isX(isolate);
-            return predicate(isolate);
-        }, VestTest.is);
+}
+class SuiteSummary extends SummaryBase {
+    constructor() {
+        super(...arguments);
+        this[_a] = [];
+        this[_b] = [];
+        this.groups = {};
+        this.tests = {};
+        this.valid = false;
+    }
+}
+_a = Severity.ERRORS, _b = Severity.WARNINGS;
+
+const CommonStates = {
+    PENDING: 'PENDING',
+    INITIAL: 'INITIAL',
+};
+const State = {
+    [CommonStates.PENDING]: CommonStates.PENDING,
+    [CommonStates.INITIAL]: CommonStates.INITIAL,
+    DONE: 'DONE',
+};
+const machine$1 = {
+    initial: State.INITIAL,
+    states: {
+        [State.DONE]: {},
+        [State.INITIAL]: {
+            [State.PENDING]: State.PENDING,
+            [State.DONE]: State.DONE,
+        },
+        [State.PENDING]: {
+            [State.DONE]: State.DONE,
+        },
+    },
+};
+function transition(from, to) {
+    return CommonStateMachine.staticTransition(from !== null && from !== void 0 ? from : State.INITIAL, to);
+}
+function setDone(isolate) {
+    isolate.status = transition(isolate.status, State.DONE);
+}
+function setPending(isolate) {
+    isolate.status = transition(isolate.status, State.PENDING);
+}
+const CommonStateMachine = StateMachine(machine$1);
+
+const TestStatus = {
+    [CommonStates.PENDING]: CommonStates.PENDING,
+    CANCELED: 'CANCELED',
+    FAILED: 'FAILED',
+    OMITTED: 'OMITTED',
+    PASSING: 'PASSING',
+    SKIPPED: 'SKIPPED',
+    UNTESTED: 'UNTESTED',
+    WARNING: 'WARNING',
+};
+const TestAction = {
+    RESET: 'RESET',
+};
+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.PASSING]: TestStatus.PASSING,
+            [TestStatus.PENDING]: TestStatus.PENDING,
+            [TestStatus.SKIPPED]: TestStatus.SKIPPED,
+            [TestStatus.WARNING]: TestStatus.WARNING,
+        },
+        [TestStatus.PENDING]: {
+            [TestStatus.CANCELED]: TestStatus.CANCELED,
+            [TestStatus.FAILED]: TestStatus.FAILED,
+            [TestStatus.PASSING]: TestStatus.PASSING,
+            [TestStatus.SKIPPED]: [
+                TestStatus.SKIPPED,
+                (force) => force === true,
+            ],
+            [TestStatus.WARNING]: TestStatus.WARNING,
+        },
+        [TestStatus.SKIPPED]: {},
+        [TestStatus.FAILED]: {},
+        [TestStatus.WARNING]: {},
+        [TestStatus.PASSING]: {},
+        [TestStatus.CANCELED]: {},
+        [TestStatus.OMITTED]: {},
+    },
+};
+const IsolateTestStateMachine = StateMachine(machine);
+
+class VestIsolate {
+    static getStatus(isolate) {
+        var _a;
+        return (_a = isolate.status) !== null && _a !== void 0 ? _a : CommonStates.INITIAL;
+    }
+    static setStatus(isolate, status, payload) {
+        isolate.status = this.stateMachine.staticTransition(VestIsolate.getStatus(isolate), status, payload);
+    }
+    static statusEquals(isolate, status) {
+        return VestIsolate.getStatus(isolate) === status;
+    }
+    static setPending(isolate) {
+        this.setStatus(isolate, CommonStates.PENDING);
+    }
+    static isPending(isolate) {
+        return VestIsolate.statusEquals(isolate, CommonStates.PENDING);
+    }
+}
+VestIsolate.stateMachine = CommonStateMachine;
+
+class VestTest extends VestIsolate {
+    // Read
+    static getData(test) {
+        invariant(test.data);
+        return test.data;
+    }
+    static is(isolate) {
+        return IsolateSelectors.isIsolateType(isolate, VestIsolateType.Test);
+    }
+    static isX(isolate) {
+        invariant(VestTest.is(isolate), ErrorStrings.EXPECTED_VEST_TEST);
+    }
+    static cast(isolate) {
+        VestTest.isX(isolate);
+        return isolate;
+    }
+    static warns(test) {
+        return VestTest.getData(test).severity === TestSeverity.Warning;
+    }
+    static isOmitted(test) {
+        return VestTest.statusEquals(test, TestStatus.OMITTED);
+    }
+    static isUntested(test) {
+        return VestTest.statusEquals(test, TestStatus.UNTESTED);
+    }
+    static isFailing(test) {
+        return VestTest.statusEquals(test, TestStatus.FAILED);
+    }
+    static isCanceled(test) {
+        return VestTest.statusEquals(test, TestStatus.CANCELED);
+    }
+    static isSkipped(test) {
+        return VestTest.statusEquals(test, TestStatus.SKIPPED);
+    }
+    static isPassing(test) {
+        return VestTest.statusEquals(test, TestStatus.PASSING);
+    }
+    static isWarning(test) {
+        return VestTest.statusEquals(test, TestStatus.WARNING);
+    }
+    static hasFailures(test) {
+        return VestTest.isFailing(test) || VestTest.isWarning(test);
+    }
+    static isNonActionable(test) {
+        return (VestTest.isSkipped(test) ||
+            VestTest.isOmitted(test) ||
+            VestTest.isCanceled(test));
+    }
+    static isTested(test) {
+        return VestTest.hasFailures(test) || VestTest.isPassing(test);
+    }
+    static awaitsResolution(test) {
+        // Is the test in a state where it can still be run, or complete running
+        // and its final status is indeterminate?
+        return (VestTest.isSkipped(test) ||
+            VestTest.isUntested(test) ||
+            VestTest.isPending(test));
+    }
+    static isAsyncTest(test) {
+        return isPromise(VestTest.getData(test).asyncTest);
+    }
+    // Mutate
+    // static setPending(test: TIsolateTest) {
+    //   this.setStatus(test, TestStatus.PENDING);
+    // }
+    static fail(test) {
+        VestTest.setStatus(test, VestTest.warns(test) ? TestStatus.WARNING : TestStatus.FAILED);
+    }
+    static pass(test) {
+        VestTest.setStatus(test, TestStatus.PASSING);
+    }
+    static warn(test) {
+        VestTest.setData(test, current => (Object.assign(Object.assign({}, current), { severity: TestSeverity.Warning })));
+    }
+    static setData(test, setter) {
+        test.data = optionalFunctionValue(setter, VestTest.getData(test));
+    }
+    static skip(test, force) {
+        // Without this force flag, the test will be marked as skipped even if it is pending.
+        // This means that it will not be counted in "allIncomplete" and its done callbacks
+        // will not be called, or will be called prematurely.
+        // What this mostly say is that when we have a pending test for one field, and we then
+        // start typing in a different field - the pending test will be canceled, which
+        // is usually an unwanted behavior.
+        // The only scenario in which we DO want to cancel the async test regardless
+        // is when we specifically skip a test with `skipWhen`, which is handled by the
+        // "force" boolean flag.
+        // I am not a fan of this flag, but it gets the job done.
+        VestTest.setStatus(test, TestStatus.SKIPPED, force);
+    }
+    static cancel(test) {
+        VestTest.setStatus(test, TestStatus.CANCELED);
+        IsolateMutator.abort(test, TestStatus.CANCELED);
+    }
+    static omit(test) {
+        VestTest.setStatus(test, TestStatus.OMITTED);
+    }
+    static reset(test) {
+        VestTest.setStatus(test, TestAction.RESET);
+    }
+}
+VestTest.stateMachine = IsolateTestStateMachine;
+
+class SummaryFailure {
+    constructor(fieldName, message, groupName) {
+        this.fieldName = fieldName;
+        this.message = message;
+        this.groupName = groupName;
+    }
+    static fromTestObject(testObject) {
+        const { fieldName, message, groupName } = VestTest.getData(testObject);
+        return new SummaryFailure(fieldName, message, groupName);
+    }
+}
+
+class TestWalker {
+    static hasNoTests(root = TestWalker.defaultRoot()) {
+        if (!root)
+            return true;
+        return !Walker.has(root, VestTest.is);
+    }
+    static someTests(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return Walker.some(root, isolate => {
+            VestTest.isX(isolate);
+            return predicate(isolate);
+        }, VestTest.is);
+    }
+    static everyTest(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return Walker.every(root, isolate => {
+            VestTest.isX(isolate);
+            return predicate(isolate);
+        }, VestTest.is);
     }
     static walkTests(callback, root = TestWalker.defaultRoot()) {
         if (!root)
@@ -526,180 +763,23 @@ class TestWalker {
 }
 TestWalker.defaultRoot = VestRuntime.useAvailableRoot;
 
-/**
- * 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 optionalFields = SuiteOptionalFields.getOptionalFields(root);
-    // If there are no optional fields, we don't need to do anything
-    if (isEmpty(optionalFields)) {
-        return;
-    }
-    // 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 (VestTest.isPending(testObject)) {
-            return;
-        }
-        const { fieldName } = VestTest.getData(testObject);
-        // If we already added the current field (not this test specifically)
-        // no need for further checks, go and omit the test
-        if (shouldOmit.has(fieldName)) {
-            verifyAndOmit(testObject);
-        }
-        else {
-            // check if the field has an optional function
-            // if so, run it and verify/omit the test
-            runOptionalConfig(testObject);
-        }
-    });
-    Bus.useEmit(Events.DONE_TEST_OMISSION_PASS);
-    function verifyAndOmit(testObject) {
-        const { fieldName } = VestTest.getData(testObject);
-        if (shouldOmit.has(fieldName)) {
-            VestTest.omit(testObject);
-            SuiteOptionalFields.setOptionalField(root, fieldName, current => (Object.assign(Object.assign({}, current), { applied: true })));
-        }
-    }
-    function runOptionalConfig(testObject) {
-        const { fieldName } = VestTest.getData(testObject);
-        // Ge the optional configuration for the given field
-        const optionalConfig = SuiteOptionalFields.getOptionalField(root, fieldName);
-        // 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(fieldName);
-        }
-        verifyAndOmit(testObject);
-    }
-}
-
-/**
- * Runs done callback per field when async tests are finished running.
- */
-function useRunFieldCallbacks(fieldName) {
-    const [fieldCallbacks] = useFieldCallbacks();
-    if (fieldName &&
-        !SuiteWalker.hasRemainingWithTestNameMatching(fieldName) &&
-        isArray(fieldCallbacks[fieldName])) {
-        callEach(fieldCallbacks[fieldName]);
-    }
-}
-/**
- * Runs unlabelled done callback when async tests are finished running.
- */
-function useRunDoneCallbacks() {
-    const [doneCallbacks] = useDoneCallbacks();
-    callEach(doneCallbacks);
-}
-
-// eslint-disable-next-line max-statements, max-lines-per-function
-function useInitVestBus() {
-    const VestBus = Bus.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) => {
-        if (VestTest.isCanceled(testObject)) {
-            return;
-        }
-        const { fieldName } = VestTest.getData(testObject);
-        useRunFieldCallbacks(fieldName);
-    });
-    on(Events.TEST_RUN_STARTED, () => {
-        /* Let's just invalidate the suite cache for now */
-    });
-    on(RuntimeEvents.ISOLATE_PENDING, (isolate) => {
-        if (VestTest.is(isolate)) {
-            VestTest.setPending(isolate);
-        }
-        setPending(isolate);
-    });
-    on(RuntimeEvents.ISOLATE_DONE, (isolate) => {
-        if (VestTest.is(isolate)) {
-            VestBus.emit(Events.TEST_COMPLETED, isolate);
-        }
-        setDone(isolate);
-        if (!SuiteWalker.hasPending()) {
-            // When no more tests are running, emit the done event
-            VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
-        }
-    });
-    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(VestTest.isAsyncTest)) {
-            useOmitOptionalFields();
+class SuiteWalker {
+    static hasPending(predicate) {
+        const root = SuiteWalker.defaultRoot();
+        if (!root) {
+            return false;
         }
-        useRunDoneCallbacks();
-    });
-    on(Events.RESET_FIELD, (fieldName) => {
-        TestWalker.resetField(fieldName);
-    });
-    on(Events.SUITE_RUN_STARTED, () => {
-        useResetCallbacks();
-    });
-    on(Events.SUITE_CALLBACK_RUN_FINISHED, () => {
-        useOmitOptionalFields();
-    });
-    on(Events.REMOVE_FIELD, (fieldName) => {
-        TestWalker.removeTestByFieldName(fieldName);
-    });
-    on(Events.RESET_SUITE, () => {
-        useResetSuite();
-    });
-    return {
-        subscribe,
-    };
-    function subscribe(cb) {
-        return VestBus.on('*', () => {
-            cb();
-        }).off;
-    }
-    function on(event, cb) {
-        VestBus.on(event, (...args) => {
-            // This is more concise, but it might be an overkill
-            // if we're adding events that don't need to invalidate the cache
-            useExpireSuiteResultCache();
-            cb(...args);
-        });
-    }
-}
-
-class IsolateReconciler {
-    static match(_currentNode, _historyNode) {
-        return false;
-    }
-    static reconcile(currentNode, historyNode) {
-        return (currentNode !== null && currentNode !== void 0 ? currentNode : historyNode);
+        return Walker.some(root, Predicates.all(VestIsolate.isPending, predicate !== null && predicate !== void 0 ? predicate : true));
     }
-}
-
-function isSameProfileTest(testObject1, testObject2) {
-    const { groupName: gn1 } = VestTest.getData(testObject1);
-    const { groupName: gn2, fieldName: fn2 } = VestTest.getData(testObject2);
-    return (matchingFieldName(VestTest.getData(testObject1), fn2) &&
-        gn1 === gn2 &&
-        // Specifically using == here. The reason is that when serializing
-        // suite result, empty key gets removed, but it can also be null.
-        testObject1.key == testObject2.key);
-}
-
-function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
-    if (currentRunTestObject !== prevRunTestObject &&
-        isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
-        VestTest.isPending(prevRunTestObject)) {
-        VestTest.cancel(prevRunTestObject);
+    // Checks whether there are pending isolates in the tree.
+    // If a fieldname is provided, will only check tests with a matching fieldname.
+    static hasRemainingWithTestNameMatching(fieldName) {
+        return SuiteWalker.hasPending(Predicates.any(isNullish(fieldName), Predicates.all(VestTest.is, (testObject) => {
+            return matchesOrHasNoFieldName(VestTest.getData(testObject), fieldName);
+        })));
     }
 }
+SuiteWalker.defaultRoot = VestRuntime.useAvailableRoot;
 
 const nonMatchingGroupName = bindNot(matchingGroupName);
 function matchingGroupName(testObject, groupName) {
@@ -749,296 +829,46 @@ function hasFailuresByTestObject(testObject, severityKey, fieldName) {
     return true;
 }
 
-/**
- * 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 useShouldAddValidProperty(fieldName) {
+    // Is the field optional, and the optional condition is applied
+    if (useIsOptionalFieldApplied(fieldName)) {
+        return true;
+    }
+    // Are there no tests?
+    if (TestWalker.hasNoTests()) {
+        return false;
+    }
+    // // Does the field have any tests with errors?
+    if (hasErrorsByTestObjects(fieldName)) {
+        return false;
+    }
+    // Does the given field have any pending tests that are not optional?
+    if (useHasNonOptionalIncomplete(fieldName)) {
+        return false;
+    }
+    // Does the field have no missing tests?
+    return useNoMissingTests(fieldName);
 }
-function useShouldSkipBasedOnMode(testData) {
-    if (useIsOne()) {
-        return hasErrorsByTestObjects();
+function useShouldAddValidPropertyInGroup(groupName, fieldName) {
+    if (useIsOptionalFieldApplied(fieldName)) {
+        return true;
     }
-    if (useIsEager()) {
-        return hasErrorsByTestObjects(testData.fieldName);
+    if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
+        return false;
     }
-    return false;
+    // Do the given group/field have any pending tests that are not optional?
+    if (useHasNonOptionalIncompleteByGroup(groupName, fieldName)) {
+        return false;
+    }
+    return useNoMissingTestsByGroup(groupName, fieldName);
 }
-
-// calls collectAll or getByFieldName depending on whether fieldName is provided
-function gatherFailures(testGroup, severityKey, fieldName) {
-    return fieldName
-        ? getByFieldName(testGroup, severityKey, fieldName)
-        : collectAll(testGroup, severityKey);
+// Does the given field have any pending tests that are not optional?
+function useHasNonOptionalIncomplete(fieldName) {
+    return SuiteWalker.hasPending(Predicates.all(VestTest.is, (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
 }
-function getByFieldName(testGroup, severityKey, fieldName) {
-    var _a;
-    return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
-}
-function collectAll(testGroup, severityKey) {
-    const output = {};
-    const countKey = countKeyBySeverity(severityKey);
-    for (const field in testGroup) {
-        if (isPositive(testGroup[field][countKey])) {
-            // We will probably never get to the fallback array
-            // leaving it just in case the implementation changes
-            output[field] = testGroup[field][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),
-        isPending: (...args) => {
-            return get().isPending(...args);
-        },
-        isTested: (...args) => get().isTested(...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 = {
-        getError,
-        getErrors,
-        getErrorsByGroup,
-        getWarning,
-        getWarnings,
-        getWarningsByGroup,
-        hasErrors,
-        hasErrorsByGroup,
-        hasWarnings,
-        hasWarningsByGroup,
-        isPending,
-        isTested,
-        isValid,
-        isValidByGroup,
-    };
-    return selectors;
-    // Booleans
-    function isValid(fieldName) {
-        var _a;
-        return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
-    }
-    function isValidByGroup(groupName, fieldName) {
-        const group = summary.groups[groupName];
-        if (!group) {
-            return false;
-        }
-        if (fieldName) {
-            return isFieldValid(group, fieldName);
-        }
-        for (const fieldName in group) {
-            if (!isFieldValid(group, fieldName)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    function hasWarnings(fieldName) {
-        return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
-    }
-    function hasErrors(fieldName) {
-        return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
-    }
-    function isTested(fieldName) {
-        var _a;
-        return isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount);
-    }
-    function hasWarningsByGroup(groupName, fieldName) {
-        return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
-    }
-    function hasErrorsByGroup(groupName, fieldName) {
-        return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
-    }
-    function getWarnings(fieldName) {
-        return getFailures(summary, Severity.WARNINGS, fieldName);
-    }
-    function getWarning(fieldName) {
-        return getFailure(Severity.WARNINGS, summary, fieldName);
-    }
-    function getErrors(fieldName) {
-        return getFailures(summary, Severity.ERRORS, fieldName);
-    }
-    function getError(fieldName) {
-        return getFailure(Severity.ERRORS, summary, fieldName);
-    }
-    function getErrorsByGroup(groupName, fieldName) {
-        return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
-    }
-    function getWarningsByGroup(groupName, fieldName) {
-        return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
-    }
-    function isPending(fieldName) {
-        var _a;
-        return fieldName
-            ? greaterThan((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.pendingCount, 0)
-            : greaterThan(summary.pendingCount, 0);
-    }
-}
-function getFailures(summary, severityKey, fieldName) {
-    return gatherFailures(summary.tests, severityKey, fieldName);
-}
-// Gathers all failures of a given severity within a group
-// With a fieldName, it will only gather failures for that field
-function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
-    return gatherFailures(summary.groups[groupName], severityKey, fieldName);
-}
-// Checks if a field is valid within a container object - can be within a group or top level
-function isFieldValid(testContainer, fieldName) {
-    var _a;
-    return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
-}
-// Checks if a there are any failures of a given severity within a group
-// If a fieldName is provided, it will only check for failures within that field
-function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
-    var _a, _b;
-    const group = summary.groups[groupName];
-    if (!group) {
-        return false;
-    }
-    if (fieldName) {
-        return isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
-    }
-    for (const field in group) {
-        if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
-            return true;
-        }
-    }
-    return false;
-}
-// Checks if there are any failures of a given severity
-// If a fieldName is provided, it will only check for failures within that field
-function hasFailures(summary, countKey, fieldName) {
-    var _a;
-    const failureCount = fieldName
-        ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
-        : summary[countKey] || 0;
-    return isPositive(failureCount);
-}
-function getFailure(severity, summary, fieldName) {
-    var _a;
-    const summaryKey = summary[severity];
-    if (!fieldName) {
-        return summaryKey[0];
-    }
-    return (_a = summaryKey.find((summaryFailure) => matchingFieldName(summaryFailure, fieldName))) === null || _a === void 0 ? void 0 : _a.message;
-}
-
-var _a, _b;
-class SummaryBase {
-    constructor() {
-        this.errorCount = 0;
-        this.warnCount = 0;
-        this.testCount = 0;
-        this.pendingCount = 0;
-    }
-}
-class SuiteSummary extends SummaryBase {
-    constructor() {
-        super(...arguments);
-        this[_a] = [];
-        this[_b] = [];
-        this.groups = {};
-        this.tests = {};
-        this.valid = false;
-    }
-}
-_a = Severity.ERRORS, _b = Severity.WARNINGS;
-
-class SummaryFailure {
-    constructor(fieldName, message, groupName) {
-        this.fieldName = fieldName;
-        this.message = message;
-        this.groupName = groupName;
-    }
-    static fromTestObject(testObject) {
-        const { fieldName, message, groupName } = VestTest.getData(testObject);
-        return new SummaryFailure(fieldName, message, groupName);
-    }
-}
-
-function useShouldAddValidProperty(fieldName) {
-    // Is the field optional, and the optional condition is applied
-    if (useIsOptionalFieldApplied(fieldName)) {
-        return true;
-    }
-    // Are there no tests?
-    if (TestWalker.hasNoTests()) {
-        return false;
-    }
-    // // Does the field have any tests with errors?
-    if (hasErrorsByTestObjects(fieldName)) {
-        return false;
-    }
-    // Does the given field have any pending tests that are not optional?
-    if (useHasNonOptionalIncomplete(fieldName)) {
-        return false;
-    }
-    // Does the field have no missing tests?
-    return useNoMissingTests(fieldName);
-}
-function useShouldAddValidPropertyInGroup(groupName, fieldName) {
-    if (useIsOptionalFieldApplied(fieldName)) {
-        return true;
-    }
-    if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
-        return false;
-    }
-    // Do the given group/field have any pending tests that are not optional?
-    if (useHasNonOptionalIncompleteByGroup(groupName, fieldName)) {
-        return false;
-    }
-    return useNoMissingTestsByGroup(groupName, fieldName);
-}
-// Does the given field have any pending tests that are not optional?
-function useHasNonOptionalIncomplete(fieldName) {
-    return SuiteWalker.hasPending(Predicates.all(VestTest.is, (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
-}
-// Do the given group/field have any pending tests that are not optional?
-function useHasNonOptionalIncompleteByGroup(groupName, fieldName) {
-    return SuiteWalker.hasPending(Predicates.all(VestTest.is, (testObject) => !nonMatchingGroupName(testObject, groupName), (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
+// Do the given group/field have any pending tests that are not optional?
+function useHasNonOptionalIncompleteByGroup(groupName, fieldName) {
+    return SuiteWalker.hasPending(Predicates.all(VestTest.is, (testObject) => !nonMatchingGroupName(testObject, groupName), (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
 }
 // Did all of the tests for the provided field run/omit?
 // This makes sure that the fields are not skipped or pending.
@@ -1201,17 +1031,68 @@ function useCreateSuiteResult() {
 }
 
 /**
- * Conditionally omits tests from the suite.
+ * Checks if context has included tests
+ */
+function useHasOnliedTests(testObject, fieldName) {
+    return isNotNullish(Walker.findClosest(testObject, (child) => {
+        if (!FocusSelectors.isIsolateFocused(child))
+            return false;
+        return FocusSelectors.isOnlyFocused(child, fieldName);
+    }));
+}
+
+/**
+ * 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
  *
- * omitWhen(res => res.hasErrors('username'), () => {
- *  test('username', 'User already taken', async () => await doesUserExist(username)
- * });
- */
-// @vx-allow use-use
-function omitWhen(conditional, callback) {
-    Isolate.create(VestIsolateType.OmitWhen, () => {
+ * 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) {
+    invariant(isStringValue(fieldName));
+    const inclusion = useInclusion();
+    inclusion[fieldName] = true;
+    return { when };
+    /**
+     * Specifies the inclusion criteria for the field in `include` function.
+     */
+    function when(condition) {
+        invariant(condition !== fieldName, ErrorStrings.INCLUDE_SELF);
+        const inclusion = useInclusion();
+        // This callback will run as part of the "isExcluded" series of checks
+        inclusion[fieldName] = function isIncluded(currentNode) {
+            if (isStringValue(condition)) {
+                return useHasOnliedTests(currentNode, condition);
+            }
+            return optionalFunctionValue(condition, optionalFunctionValue(useCreateSuiteResult));
+        };
+    }
+}
+
+/**
+ * Conditionally omits tests from the suite.
+ *
+ * @example
+ *
+ * omitWhen(res => res.hasErrors('username'), () => {
+ *  test('username', 'User already taken', async () => await doesUserExist(username)
+ * });
+ */
+// @vx-allow use-use
+function omitWhen(conditional, callback) {
+    Isolate.create(VestIsolateType.OmitWhen, () => {
         SuiteContext.run({
             omitted: useWithinActiveOmitWhen() ||
                 optionalFunctionValue(conditional, optionalFunctionValue(useCreateSuiteResult)),
@@ -1249,71 +1130,85 @@ function useIsExcludedIndividually() {
     return useSkipped();
 }
 
-var FocusModes;
-(function (FocusModes) {
-    FocusModes[FocusModes["ONLY"] = 0] = "ONLY";
-    FocusModes[FocusModes["SKIP"] = 1] = "SKIP";
-})(FocusModes || (FocusModes = {}));
+var Events;
+(function (Events) {
+    Events["TEST_RUN_STARTED"] = "test_run_started";
+    Events["TEST_COMPLETED"] = "test_completed";
+    Events["ALL_RUNNING_TESTS_FINISHED"] = "all_running_tests_finished";
+    Events["REMOVE_FIELD"] = "remove_field";
+    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 = {}));
 
-function IsolateFocused(focusMode, match) {
-    return Isolate.create(VestIsolateType.Focused, noop, {
-        focusMode,
-        match: asArray(match).filter(isStringValue),
-        matchAll: match === true,
-    });
-}
-class FocusSelectors {
-    static isSkipFocused(focus, fieldName) {
-        return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.SKIP &&
-            (hasFocus(focus, fieldName) || focus.data.matchAll === true));
-    }
-    static isOnlyFocused(focus, fieldName) {
-        return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.ONLY && hasFocus(focus, fieldName));
+function IsolateTest(callback, input, key) {
+    const payload = Object.assign(Object.assign({}, IsolateTestBase()), { fieldName: input.fieldName, testFn: input.testFn });
+    if (input.groupName) {
+        payload.groupName = input.groupName;
     }
-    static isIsolateFocused(isolate) {
-        return IsolateSelectors.isIsolateType(isolate, VestIsolateType.Focused);
+    if (input.message) {
+        payload.message = input.message;
     }
+    const isolate = Isolate.create(VestIsolateType.Test, callback, payload, key !== null && key !== void 0 ? key : null);
+    return isolate;
 }
-/**
- * Adds a field or a list of fields into the inclusion list
- *
- * @example
- *
- * only('username');
- */
-// @vx-allow use-use
-function only(match) {
-    return IsolateFocused(FocusModes.ONLY, defaultMatch(match));
+function IsolateTestBase() {
+    return {
+        severity: TestSeverity.Error,
+        status: IsolateTestStateMachine.initial(),
+    };
+}
+
+function shouldUseErrorAsMessage(message, error) {
+    // kind of cheating with this safe guard, but it does the job
+    return isUndefined(message) && isStringValue(error);
 }
+
 /**
- * Adds a field or a list of fields into the exclusion list
+ * 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';
  *
- * skip('username');
+ * const suite = create('suite_name', () => {
+ *  vest.mode(Modes.ALL);
+ *
+ *  // ...
+ * });
+ * ```
+ * @param 'ALL' | 'EAGER' | 'ONE' mode - The mode to set.
  */
 // @vx-allow use-use
-function skip(match) {
-    return IsolateFocused(FocusModes.SKIP, defaultMatch(match));
+function mode(mode) {
+    const [, setMode] = useMode();
+    setMode(mode);
 }
-function defaultMatch(match) {
-    return match === false ? [] : match;
+function useIsMode(mode) {
+    const [currentMode] = useMode();
+    return currentMode === mode;
 }
-function hasFocus(focus, fieldName) {
-    var _a, _b;
-    return (isNotEmpty(focus === null || focus === void 0 ? void 0 : focus.data.match) &&
-        (fieldName ? (_b = (_a = focus === null || focus === void 0 ? void 0 : focus.data.match) === null || _a === void 0 ? void 0 : _a.includes(fieldName)) !== null && _b !== void 0 ? _b : true : true));
+function useIsEager() {
+    return useIsMode(Modes.EAGER);
 }
-
-/**
- * Checks if context has included tests
- */
-function useHasOnliedTests(testObject, fieldName) {
-    return isNotNullish(Walker.findClosest(testObject, (child) => {
-        if (!FocusSelectors.isIsolateFocused(child))
-            return false;
-        return FocusSelectors.isOnlyFocused(child, fieldName);
-    }));
+function useIsOne() {
+    return useIsMode(Modes.ONE);
+}
+function useShouldSkipBasedOnMode(testData) {
+    if (useIsOne()) {
+        return hasErrorsByTestObjects();
+    }
+    if (useIsEager()) {
+        return hasErrorsByTestObjects(testData.fieldName);
+    }
+    return false;
 }
 
 //Checks whether a certain test profile excluded by any of the exclusion groups.
@@ -1382,304 +1277,409 @@ function useForceSkipIfInSkipWhen(testNode) {
     return testNode;
 }
 
-class IsolateTestReconciler extends IsolateReconciler {
-    static match(currentNode, historyNode) {
-        return VestTest.is(currentNode) && VestTest.is(historyNode);
+// eslint-disable-next-line max-statements
+function useAttemptRunTest(testObject) {
+    useVerifyTestRun(testObject);
+    if (VestTest.isUntested(testObject)) {
+        return useRunTest(testObject);
     }
-    static reconcile(currentNode, historyNode) {
-        const reconcilerOutput = usePickNode(historyNode, currentNode);
-        cancelOverriddenPendingTestOnTestReRun(reconcilerOutput, currentNode, historyNode);
-        return reconcilerOutput;
+    if (!VestTest.isNonActionable(testObject)) {
+        // Probably unreachable. If we get here, it means that
+        // something was really wrong and should be reported.
+        /* istanbul ignore next */
+        deferThrow(text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
+            testObject: JSON.stringify(testObject),
+        }));
     }
 }
-function usePickNode(historyNode, currentNode) {
-    const collisionResult = handleCollision(currentNode, historyNode);
-    return useVerifyTestRun(currentNode, collisionResult);
+function runSyncTest(testObject) {
+    return SuiteContext.run({ currentTest: testObject }, () => {
+        let result;
+        const { message, testFn } = VestTest.getData(testObject);
+        try {
+            result = testFn({ signal: testObject.abortController.signal });
+        }
+        catch (error) {
+            if (shouldUseErrorAsMessage(message, error)) {
+                VestTest.getData(testObject).message = error;
+            }
+            result = false;
+        }
+        if (result === false) {
+            VestTest.fail(testObject);
+        }
+        return result;
+    });
 }
-function handleCollision(newNode, prevNode) {
-    if (IsolateInspector.usesKey(newNode)) {
-        return VestTest.cast(Reconciler.handleIsolateNodeWithKey(newNode));
-    }
-    if (Reconciler.dropNextNodesOnReorder(nodeReorderDetected, newNode, prevNode)) {
-        throwTestOrderError(newNode, prevNode);
-        return newNode;
+/**
+ * runs test, if async - adds to pending array
+ */
+function useRunTest(testObject) {
+    // Run test callback.
+    // If a promise is returned, set as async and
+    // Move to pending list.
+    const result = runSyncTest(testObject);
+    try {
+        // try catch for safe property access
+        // in case object is an enforce chain
+        if (isPromise(result)) {
+            VestTest.getData(testObject).asyncTest = result;
+            return useRunAsyncTest(testObject);
+        }
+        onTestCompleted(testObject);
     }
-    if (!VestTest.is(prevNode)) {
-        // I believe we cannot actually reach this point.
-        // Because it should already be handled by nodeReorderDetected.
+    catch (e) {
+        // Probably unreachable. If we get here, it means that
+        // something was really wrong and should be reported.
         /* istanbul ignore next */
-        return newNode;
-    }
-    // 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 (VestTest.isOmitted(prevNode)) {
-        return newNode;
-    }
-    return prevNode;
-}
-function cancelOverriddenPendingTestOnTestReRun(nextNode, currentNode, prevTestObject) {
-    if (nextNode === currentNode && VestTest.is(currentNode)) {
-        cancelOverriddenPendingTest(prevTestObject, currentNode);
+        throw new Error(text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
+            testObject: JSON.stringify(testObject),
+            error: e,
+        }));
     }
 }
-function nodeReorderDetected(newNode, prevNode) {
-    return VestTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
-}
-function throwTestOrderError(newNode, prevNode) {
-    if (IsolateInspector.canReorder(newNode)) {
-        return;
-    }
-    deferThrow(text(ErrorStrings.TESTS_CALLED_IN_DIFFERENT_ORDER, {
-        fieldName: VestTest.getData(newNode).fieldName,
-        prevName: VestTest.is(prevNode)
-            ? VestTest.getData(prevNode).fieldName
-            : undefined,
+/**
+ * Runs async test.
+ */
+function useRunAsyncTest(testObject) {
+    const { asyncTest, message } = VestTest.getData(testObject);
+    if (!isPromise(asyncTest))
+        return;
+    // VestTest.setPending(testObject);
+    const done = VestRuntime.persist(() => {
+        onTestCompleted(testObject);
+    });
+    const fail = VestRuntime.persist((rejectionMessage) => {
+        if (VestTest.isCanceled(testObject)) {
+            return;
+        }
+        VestTest.getData(testObject).message = isStringValue(rejectionMessage)
+            ? rejectionMessage
+            : message;
+        VestTest.fail(testObject);
+        done();
+    });
+    return asyncTest.then(done, fail);
+}
+function onTestCompleted(testObject) {
+    // Attempts passing if the test is not already failed.
+    // or is not canceled/omitted.
+    VestTest.pass(testObject);
+}
+
+// @vx-allow use-use
+function wrapTestMemo(test) {
+    function memo(fieldName, ...args) {
+        const [deps, testFn, msg] = args.reverse();
+        // Implicit dependency for better specificity
+        const dependencies = [
+            useSuiteId(),
+            fieldName,
+            VestRuntime.useCurrentCursor(),
+        ].concat(deps);
+        return useGetTestFromCache(dependencies, cacheAction);
+        function cacheAction() {
+            return test(fieldName, msg, testFn);
+        }
+    }
+    return memo;
+}
+function useGetTestFromCache(dependencies, cacheAction) {
+    const cache = useTestMemoCache();
+    const cached = cache.get(dependencies);
+    if (isNull(cached)) {
+        // cache miss
+        return cache(dependencies, cacheAction);
+    }
+    const [, cachedValue] = cached;
+    if (VestTest.isCanceled(cachedValue)) {
+        // cache hit, but test is canceled
+        cache.invalidate(dependencies);
+        return cache(dependencies, cacheAction);
+    }
+    VestRuntime.addNodeToHistory(cachedValue);
+    return cachedValue;
+}
+
+// @vx-allow use-use
+function vestTest(fieldName, ...args) {
+    const [message, testFn, key] = (isFunction(args[1]) ? args : [undefined, ...args]);
+    validateTestParams(fieldName, testFn);
+    const groupName = useGroupName();
+    const testObjectInput = { fieldName, groupName, message, testFn };
+    // This invalidates the suite cache.
+    Bus.useEmit(Events.TEST_RUN_STARTED);
+    return IsolateTest(useAttemptRunTest, testObjectInput, key);
+}
+const test = assign(vestTest, {
+    memo: wrapTestMemo(vestTest),
+});
+function validateTestParams(fieldName, testFn) {
+    const fnName = 'test';
+    invariant(isStringValue(fieldName), text(ErrorStrings.INVALID_PARAM_PASSED_TO_FUNCTION, {
+        fn_name: fnName,
+        param: 'fieldName',
+        expected: 'string',
+    }));
+    invariant(isFunction(testFn), text(ErrorStrings.INVALID_PARAM_PASSED_TO_FUNCTION, {
+        fn_name: fnName,
+        param: 'callback',
+        expected: 'function',
     }));
 }
 
-function VestReconciler(currentNode, historyNode) {
-    var _a, _b;
-    return ((_b = (_a = [IsolateTestReconciler]
-        .find(reconciler => reconciler.match(currentNode, historyNode))) === null || _a === void 0 ? void 0 : _a.reconcile(currentNode, historyNode)) !== null && _b !== void 0 ? _b : null);
+// import { optional, skipWhen, omitWhen, IsolateTest, group } from 'vest';
+function getTypedMethods() {
+    return {
+        group,
+        include,
+        omitWhen,
+        only,
+        optional,
+        skip,
+        skipWhen,
+        test,
+    };
 }
 
-function group(...args) {
-    const [callback, groupName] = args.reverse();
-    return Isolate.create(VestIsolateType.Group, () => {
-        return SuiteContext.run(Object.assign({}, (groupName && { groupName })), callback);
+/**
+ * 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 optionalFields = SuiteOptionalFields.getOptionalFields(root);
+    // If there are no optional fields, we don't need to do anything
+    if (isEmpty(optionalFields)) {
+        return;
+    }
+    // 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 (VestTest.isPending(testObject)) {
+            return;
+        }
+        const { fieldName } = VestTest.getData(testObject);
+        // If we already added the current field (not this test specifically)
+        // no need for further checks, go and omit the test
+        if (shouldOmit.has(fieldName)) {
+            verifyAndOmit(testObject);
+        }
+        else {
+            // check if the field has an optional function
+            // if so, run it and verify/omit the test
+            runOptionalConfig(testObject);
+        }
     });
+    Bus.useEmit(Events.DONE_TEST_OMISSION_PASS);
+    function verifyAndOmit(testObject) {
+        const { fieldName } = VestTest.getData(testObject);
+        if (shouldOmit.has(fieldName)) {
+            VestTest.omit(testObject);
+            SuiteOptionalFields.setOptionalField(root, fieldName, current => (Object.assign(Object.assign({}, current), { applied: true })));
+        }
+    }
+    function runOptionalConfig(testObject) {
+        const { fieldName } = VestTest.getData(testObject);
+        // Ge the optional configuration for the given field
+        const optionalConfig = SuiteOptionalFields.getOptionalField(root, fieldName);
+        // 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(fieldName);
+        }
+        verifyAndOmit(testObject);
+    }
 }
 
 /**
- * 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
+ * Runs done callback per field when async tests are finished running.
  */
-// @vx-allow use-use
-function include(fieldName) {
-    invariant(isStringValue(fieldName));
-    const inclusion = useInclusion();
-    inclusion[fieldName] = true;
-    return { when };
-    /**
-     * Specifies the inclusion criteria for the field in `include` function.
-     */
-    function when(condition) {
-        invariant(condition !== fieldName, ErrorStrings.INCLUDE_SELF);
-        const inclusion = useInclusion();
-        // This callback will run as part of the "isExcluded" series of checks
-        inclusion[fieldName] = function isIncluded(currentNode) {
-            if (isStringValue(condition)) {
-                return useHasOnliedTests(currentNode, condition);
-            }
-            return optionalFunctionValue(condition, optionalFunctionValue(useCreateSuiteResult));
-        };
+function useRunFieldCallbacks(fieldName) {
+    const [fieldCallbacks] = useFieldCallbacks();
+    if (fieldName &&
+        !SuiteWalker.hasRemainingWithTestNameMatching(fieldName) &&
+        isArray(fieldCallbacks[fieldName])) {
+        callEach(fieldCallbacks[fieldName]);
+    }
+}
+/**
+ * Runs unlabelled done callback when async tests are finished running.
+ */
+function useRunDoneCallbacks() {
+    const [doneCallbacks] = useDoneCallbacks();
+    callEach(doneCallbacks);
+}
+
+// eslint-disable-next-line max-statements, max-lines-per-function
+function useInitVestBus() {
+    const VestBus = Bus.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) => {
+        if (VestTest.isCanceled(testObject)) {
+            return;
+        }
+        const { fieldName } = VestTest.getData(testObject);
+        useRunFieldCallbacks(fieldName);
+    });
+    on(Events.TEST_RUN_STARTED, () => {
+        /* Let's just invalidate the suite cache for now */
+    });
+    on(RuntimeEvents.ISOLATE_PENDING, (isolate) => {
+        if (VestTest.is(isolate)) {
+            VestTest.setPending(isolate);
+        }
+        setPending(isolate);
+    });
+    on(RuntimeEvents.ISOLATE_DONE, (isolate) => {
+        if (VestTest.is(isolate)) {
+            VestBus.emit(Events.TEST_COMPLETED, isolate);
+        }
+        setDone(isolate);
+        if (!SuiteWalker.hasPending()) {
+            // When no more tests are running, emit the done event
+            VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+        }
+    });
+    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(VestTest.isAsyncTest)) {
+            useOmitOptionalFields();
+        }
+        useRunDoneCallbacks();
+    });
+    on(Events.RESET_FIELD, (fieldName) => {
+        TestWalker.resetField(fieldName);
+    });
+    on(Events.SUITE_RUN_STARTED, () => {
+        useResetCallbacks();
+    });
+    on(Events.SUITE_CALLBACK_RUN_FINISHED, () => {
+        useOmitOptionalFields();
+    });
+    on(Events.REMOVE_FIELD, (fieldName) => {
+        TestWalker.removeTestByFieldName(fieldName);
+    });
+    on(Events.RESET_SUITE, () => {
+        useResetSuite();
+    });
+    return {
+        subscribe,
+    };
+    function subscribe(cb) {
+        return VestBus.on('*', () => {
+            cb();
+        }).off;
+    }
+    function on(event, cb) {
+        VestBus.on(event, (...args) => {
+            // This is more concise, but it might be an overkill
+            // if we're adding events that don't need to invalidate the cache
+            useExpireSuiteResultCache();
+            cb(...args);
+        });
     }
 }
 
-function IsolateTest(callback, input, key) {
-    const payload = Object.assign(Object.assign({}, IsolateTestBase()), { fieldName: input.fieldName, testFn: input.testFn });
-    if (input.groupName) {
-        payload.groupName = input.groupName;
+class IsolateReconciler {
+    static match(_currentNode, _historyNode) {
+        return false;
     }
-    if (input.message) {
-        payload.message = input.message;
+    static reconcile(currentNode, historyNode) {
+        return (currentNode !== null && currentNode !== void 0 ? currentNode : historyNode);
     }
-    const isolate = Isolate.create(VestIsolateType.Test, callback, payload, key !== null && key !== void 0 ? key : null);
-    return isolate;
 }
-function IsolateTestBase() {
-    return {
-        severity: TestSeverity.Error,
-        status: IsolateTestStateMachine.initial(),
-    };
+
+function isSameProfileTest(testObject1, testObject2) {
+    const { groupName: gn1 } = VestTest.getData(testObject1);
+    const { groupName: gn2, fieldName: fn2 } = VestTest.getData(testObject2);
+    return (matchingFieldName(VestTest.getData(testObject1), fn2) &&
+        gn1 === gn2 &&
+        // Specifically using == here. The reason is that when serializing
+        // suite result, empty key gets removed, but it can also be null.
+        testObject1.key == testObject2.key);
 }
 
-function shouldUseErrorAsMessage(message, error) {
-    // kind of cheating with this safe guard, but it does the job
-    return isUndefined(message) && isStringValue(error);
+function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
+    if (currentRunTestObject !== prevRunTestObject &&
+        isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
+        VestTest.isPending(prevRunTestObject)) {
+        VestTest.cancel(prevRunTestObject);
+    }
 }
 
-// eslint-disable-next-line max-statements
-function useAttemptRunTest(testObject) {
-    useVerifyTestRun(testObject);
-    if (VestTest.isUntested(testObject)) {
-        return useRunTest(testObject);
+class IsolateTestReconciler extends IsolateReconciler {
+    static match(currentNode, historyNode) {
+        return VestTest.is(currentNode) && VestTest.is(historyNode);
     }
-    if (!VestTest.isNonActionable(testObject)) {
-        // Probably unreachable. If we get here, it means that
-        // something was really wrong and should be reported.
-        /* istanbul ignore next */
-        deferThrow(text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
-            testObject: JSON.stringify(testObject),
-        }));
+    static reconcile(currentNode, historyNode) {
+        const reconcilerOutput = usePickNode(historyNode, currentNode);
+        cancelOverriddenPendingTestOnTestReRun(reconcilerOutput, currentNode, historyNode);
+        return reconcilerOutput;
     }
 }
-function runSyncTest(testObject) {
-    return SuiteContext.run({ currentTest: testObject }, () => {
-        let result;
-        const { message, testFn } = VestTest.getData(testObject);
-        try {
-            result = testFn({ signal: testObject.abortController.signal });
-        }
-        catch (error) {
-            if (shouldUseErrorAsMessage(message, error)) {
-                VestTest.getData(testObject).message = error;
-            }
-            result = false;
-        }
-        if (result === false) {
-            VestTest.fail(testObject);
-        }
-        return result;
-    });
+function usePickNode(historyNode, currentNode) {
+    const collisionResult = handleCollision(currentNode, historyNode);
+    return useVerifyTestRun(currentNode, collisionResult);
 }
-/**
- * runs test, if async - adds to pending array
- */
-function useRunTest(testObject) {
-    // Run test callback.
-    // If a promise is returned, set as async and
-    // Move to pending list.
-    const result = runSyncTest(testObject);
-    try {
-        // try catch for safe property access
-        // in case object is an enforce chain
-        if (isPromise(result)) {
-            VestTest.getData(testObject).asyncTest = result;
-            return useRunAsyncTest(testObject);
-        }
-        onTestCompleted(testObject);
+function handleCollision(newNode, prevNode) {
+    if (IsolateInspector.usesKey(newNode)) {
+        return VestTest.cast(Reconciler.handleIsolateNodeWithKey(newNode, VestTest.isNonActionable));
     }
-    catch (e) {
-        // Probably unreachable. If we get here, it means that
-        // something was really wrong and should be reported.
+    if (Reconciler.dropNextNodesOnReorder(nodeReorderDetected, newNode, prevNode)) {
+        throwTestOrderError(newNode, prevNode);
+        return newNode;
+    }
+    if (!VestTest.is(prevNode)) {
+        // I believe we cannot actually reach this point.
+        // Because it should already be handled by nodeReorderDetected.
         /* istanbul ignore next */
-        throw new Error(text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
-            testObject: JSON.stringify(testObject),
-            error: e,
-        }));
+        return newNode;
     }
-}
-/**
- * Runs async test.
- */
-function useRunAsyncTest(testObject) {
-    const { asyncTest, message } = VestTest.getData(testObject);
-    if (!isPromise(asyncTest))
-        return;
-    // VestTest.setPending(testObject);
-    const done = VestRuntime.persist(() => {
-        onTestCompleted(testObject);
-    });
-    const fail = VestRuntime.persist((rejectionMessage) => {
-        if (VestTest.isCanceled(testObject)) {
-            return;
-        }
-        VestTest.getData(testObject).message = isStringValue(rejectionMessage)
-            ? rejectionMessage
-            : message;
-        VestTest.fail(testObject);
-        done();
-    });
-    return asyncTest.then(done, fail);
-}
-function onTestCompleted(testObject) {
-    // Attempts passing if the test is not already failed.
-    // or is not canceled/omitted.
-    VestTest.pass(testObject);
-}
-
-// @vx-allow use-use
-function wrapTestMemo(test) {
-    function memo(fieldName, ...args) {
-        const [deps, testFn, msg] = args.reverse();
-        // Implicit dependency for better specificity
-        const dependencies = [
-            useSuiteId(),
-            fieldName,
-            VestRuntime.useCurrentCursor(),
-        ].concat(deps);
-        return useGetTestFromCache(dependencies, cacheAction);
-        function cacheAction() {
-            return test(fieldName, msg, testFn);
-        }
+    // 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 (VestTest.isOmitted(prevNode)) {
+        return newNode;
     }
-    return memo;
+    return prevNode;
 }
-function useGetTestFromCache(dependencies, cacheAction) {
-    const cache = useTestMemoCache();
-    const cached = cache.get(dependencies);
-    if (isNull(cached)) {
-        // cache miss
-        return cache(dependencies, cacheAction);
-    }
-    const [, cachedValue] = cached;
-    if (VestTest.isCanceled(cachedValue)) {
-        // cache hit, but test is canceled
-        cache.invalidate(dependencies);
-        return cache(dependencies, cacheAction);
+function cancelOverriddenPendingTestOnTestReRun(nextNode, currentNode, prevTestObject) {
+    if (nextNode === currentNode && VestTest.is(currentNode)) {
+        cancelOverriddenPendingTest(prevTestObject, currentNode);
     }
-    VestRuntime.addNodeToHistory(cachedValue);
-    return cachedValue;
 }
-
-// @vx-allow use-use
-function vestTest(fieldName, ...args) {
-    const [message, testFn, key] = (isFunction(args[1]) ? args : [undefined, ...args]);
-    validateTestParams(fieldName, testFn);
-    const groupName = useGroupName();
-    const testObjectInput = { fieldName, groupName, message, testFn };
-    // This invalidates the suite cache.
-    Bus.useEmit(Events.TEST_RUN_STARTED);
-    return IsolateTest(useAttemptRunTest, testObjectInput, key);
+function nodeReorderDetected(newNode, prevNode) {
+    return VestTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
 }
-const test = assign(vestTest, {
-    memo: wrapTestMemo(vestTest),
-});
-function validateTestParams(fieldName, testFn) {
-    const fnName = 'test';
-    invariant(isStringValue(fieldName), text(ErrorStrings.INVALID_PARAM_PASSED_TO_FUNCTION, {
-        fn_name: fnName,
-        param: 'fieldName',
-        expected: 'string',
-    }));
-    invariant(isFunction(testFn), text(ErrorStrings.INVALID_PARAM_PASSED_TO_FUNCTION, {
-        fn_name: fnName,
-        param: 'callback',
-        expected: 'function',
+function throwTestOrderError(newNode, prevNode) {
+    if (IsolateInspector.canReorder(newNode)) {
+        return;
+    }
+    deferThrow(text(ErrorStrings.TESTS_CALLED_IN_DIFFERENT_ORDER, {
+        fieldName: VestTest.getData(newNode).fieldName,
+        prevName: VestTest.is(prevNode)
+            ? VestTest.getData(prevNode).fieldName
+            : undefined,
     }));
 }
 
-// import { optional, skipWhen, omitWhen, IsolateTest, group } from 'vest';
-function getTypedMethods() {
-    return {
-        group,
-        include,
-        omitWhen,
-        only,
-        optional,
-        skip,
-        skipWhen,
-        test,
-    };
+function VestReconciler(currentNode, historyNode) {
+    var _a, _b;
+    return ((_b = (_a = [IsolateTestReconciler]
+        .find(reconciler => reconciler.match(currentNode, historyNode))) === null || _a === void 0 ? void 0 : _a.reconcile(currentNode, historyNode)) !== null && _b !== void 0 ? _b : null);
 }
 
 function useDeferDoneCallback(doneCallback, fieldName) {
@@ -1734,6 +1734,7 @@ function validateSuiteCallback(suiteCallback) {
 }
 
 // @vx-allow use-use
+// eslint-disable-next-line max-lines-per-function
 function createSuite(...args) {
     const [suiteCallback, suiteName] = args.reverse();
     validateSuiteCallback(suiteCallback);
@@ -1748,6 +1749,7 @@ function createSuite(...args) {
             return IsolateSuite(useRunSuiteCallback(suiteCallback, ...args));
         }).output;
     }
+    const mountedStatic = staticSuite(...args);
     // Assign methods to the suite
     // 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.
@@ -1757,7 +1759,7 @@ function createSuite(...args) {
         return assign(
         // We're also binding the suite to the stateRef, so that the suite
         // can access the stateRef when it's called.
-        VestRuntime.persist(suite), Object.assign(Object.assign({ dump: VestRuntime.persist(() => VestRuntime.useAvailableRoot()), get: VestRuntime.persist(useCreateSuiteResult), remove: Bus.usePrepareEmitter(Events.REMOVE_FIELD), reset: Bus.usePrepareEmitter(Events.RESET_SUITE), resetField: Bus.usePrepareEmitter(Events.RESET_FIELD), resume: VestRuntime.persist(useLoadSuite), subscribe: VestBus.subscribe }, bindSuiteSelectors(VestRuntime.persist(useCreateSuiteResult))), getTypedMethods()));
+        VestRuntime.persist(suite), Object.assign(Object.assign({ dump: VestRuntime.persist(() => VestRuntime.useAvailableRoot()), get: VestRuntime.persist(useCreateSuiteResult), remove: Bus.usePrepareEmitter(Events.REMOVE_FIELD), reset: Bus.usePrepareEmitter(Events.RESET_SUITE), resetField: Bus.usePrepareEmitter(Events.RESET_FIELD), resume: VestRuntime.persist(useLoadSuite), runStatic: (...args) => mountedStatic(...args), subscribe: VestBus.subscribe }, bindSuiteSelectors(VestRuntime.persist(useCreateSuiteResult))), getTypedMethods()));
     });
 }
 function useRunSuiteCallback(suiteCallback, ...args) {
@@ -1768,6 +1770,17 @@ function useRunSuiteCallback(suiteCallback, ...args) {
         return useSuiteRunResult();
     };
 }
+// @vx-allow use-use
+// eslint-disable-next-line max-lines-per-function
+function staticSuite(...createArgs) {
+    return assign((...args) => {
+        const suite = createSuite(...createArgs);
+        const result = suite(...args);
+        return Object.freeze(assign({
+            dump: suite.dump,
+        }, result));
+    }, Object.assign({}, getTypedMethods()));
+}
 
 function IsolateEach(callback) {
     return Isolate.create(VestIsolateType.Each, callback, {
@@ -1797,33 +1810,6 @@ function each(list, 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) => {
-        const suite = createSuite(suiteCallback);
-        const result = suite(...args);
-        return Object.freeze(assign({
-            dump: suite.dump,
-        }, result));
-    }, Object.assign({}, getTypedMethods()));
-}
-
 const ERROR_OUTSIDE_OF_TEST = ErrorStrings.WARN_MUST_BE_CALLED_FROM_TEST;
 /**
  * Sets the severity level of a test to `warn`, allowing it to fail without marking the suite as invalid.