vest 5.0.0-dev-781e21 → 5.0.0-dev-9c596e

package/dist/es/vest.development.js

@@ -1,440 +1,283 @@
 export { enforce } from 'n4s';
-import { isUndefined, isStringValue, assign, cache as cache$2, nestedArray, asArray, seq, optionalFunctionValue, isFunction, isNullish, deferThrow, invariant, bindNot, either, isArray, isEmpty, isNotEmpty, isPositive, numberEquals, hasOwnProperty, callEach, bus, defaultTo, isPromise, isNull } from 'vest-utils';
+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 { createCascade } from 'context';
 
-function shouldUseErrorAsMessage(message, error) {
-    // kind of cheating with this safe guard, but it does the job
-    return isUndefined(message) && isStringValue(error);
-}
+var OptionalFieldTypes;
+(function (OptionalFieldTypes) {
+    OptionalFieldTypes[OptionalFieldTypes["Immediate"] = 0] = "Immediate";
+    OptionalFieldTypes[OptionalFieldTypes["Delayed"] = 1] = "Delayed";
+})(OptionalFieldTypes || (OptionalFieldTypes = {}));
 
-var IsolateTypes;
-(function (IsolateTypes) {
-    IsolateTypes[IsolateTypes["DEFAULT"] = 0] = "DEFAULT";
-    IsolateTypes[IsolateTypes["SUITE"] = 1] = "SUITE";
-    IsolateTypes[IsolateTypes["EACH"] = 2] = "EACH";
-    IsolateTypes[IsolateTypes["SKIP_WHEN"] = 3] = "SKIP_WHEN";
-    IsolateTypes[IsolateTypes["OMIT_WHEN"] = 4] = "OMIT_WHEN";
-    IsolateTypes[IsolateTypes["GROUP"] = 5] = "GROUP";
-})(IsolateTypes || (IsolateTypes = {}));
+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 = {}));
 
-var Modes;
-(function (Modes) {
-    Modes[Modes["ALL"] = 0] = "ALL";
-    Modes[Modes["EAGER"] = 1] = "EAGER";
-})(Modes || (Modes = {}));
+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 || (Events = {}));
 
-function createIsolateCursor() {
-    var cursor = {
-        value: 0
-    };
-    return {
-        current: current,
-        next: next
-    };
-    /**
-     * @returns {number} The current value of the cursor
-     */
-    function current() {
-        return cursor.value;
-    }
-    /**
-     * Moves the isolate cursor forward by 1
-     */
-    function next() {
-        cursor.value++;
+// 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 generateIsolate(type, path) {
-    if (path === void 0) { path = []; }
-    return {
-        cursor: createIsolateCursor(),
-        keys: {
-            current: {},
-            prev: {}
-        },
-        path: path,
-        type: type
-    };
-}
-
-var context = createCascade(function (ctxRef, parentContext) {
-    return parentContext
-        ? null
-        : assign({
-            exclusion: {
-                tests: {},
-                groups: {}
-            },
-            inclusion: {},
-            isolate: generateIsolate(IsolateTypes.DEFAULT),
-            mode: [Modes.ALL]
-        }, ctxRef);
-});
-
-// STATE REF
-function useStateRef() {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return context.useX().stateRef; // I should revisit this
-}
-// STATE KEYS
-function useSuiteId() {
-    return useStateRef().suiteId()[0];
-}
-function useSuiteName() {
-    return useStateRef().suiteName()[0];
-}
-function useTestCallbacks() {
-    return useStateRef().testCallbacks();
-}
-// OPTIONAL FIELDS
-function useOptionalFields() {
-    return useStateRef().optionalFields();
-}
-function useSetOptionalField(fieldName, setter) {
-    var _a = useOptionalFields(), setOptionalFields = _a[1];
-    setOptionalFields(function (prev) {
-        var _a;
-        return assign(prev, (_a = {},
-            _a[fieldName] = assign({}, prev[fieldName], setter(prev[fieldName])),
-            _a));
-    });
-}
-function useOptionalField(fieldName) {
-    var _a;
-    var optionalFields = useOptionalFields()[0];
-    return (_a = optionalFields[fieldName]) !== null && _a !== void 0 ? _a : {};
-}
-function useTestObjects() {
-    return useStateRef().testObjects();
-}
-// STATE ACTIONS
-function useRefreshTestObjects() {
-    useSetTests(function (tests) { return tests; });
-}
-function useSetTests(handler) {
-    var _a = useTestObjects(), testObjects = _a[1];
-    testObjects(function (_a) {
-        var current = _a.current, prev = _a.prev;
-        return ({
-            prev: prev,
-            current: asArray(handler(current))
-        });
-    });
-}
-// Derived state
-function useAllIncomplete() {
-    return useTestsFlat().filter(function (test) { return test.isPending(); });
+function pluck(startNode, predicate, visitOnly) {
+    walk(startNode, node => {
+        if (predicate(node) && node.parent) {
+            node.parent.removeChild(node);
+        }
+    }, visitOnly);
 }
-var flatCache = cache$2();
-function useTestsFlat() {
-    var current = useTestObjects()[0].current;
-    return flatCache([current], function () { return nestedArray.flatten(current); });
+function closest(startNode, predicate) {
+    let current = startNode;
+    while (current.parent) {
+        if (predicate(current)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return null;
 }
-function useEachTestObject(handler) {
-    var testObjects = useTestsFlat();
-    testObjects.forEach(handler);
+function closestExists(startNode, predicate) {
+    return !!closest(startNode, predicate);
 }
 
-var TestSeverity;
-(function (TestSeverity) {
-    TestSeverity["Error"] = "error";
-    TestSeverity["Warning"] = "warning";
-})(TestSeverity || (TestSeverity = {}));
-var VestTest = /** @class */ (function () {
-    function VestTest(fieldName, testFn, _a) {
-        var _b = _a === void 0 ? {} : _a, message = _b.message, groupName = _b.groupName, key = _b.key;
-        this.key = null;
-        this.id = seq();
-        this.severity = TestSeverity.Error;
-        this.status = STATUS_UNTESTED;
-        this.fieldName = fieldName;
-        this.testFn = testFn;
-        if (groupName) {
-            this.groupName = groupName;
+class Reconciler {
+    static reconciler(currentNode, historicNode) {
+        if (isNullish(historicNode)) {
+            return currentNode;
         }
-        if (message) {
-            this.message = message;
+        return currentNode;
+    }
+    static reconcile(node, callback) {
+        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;
         }
-        if (key) {
-            this.key = key;
+        const nextNode = this.reconciler(node, localHistoryNode);
+        invariant(nextNode);
+        if (Object.is(nextNode, node)) {
+            return [node, useRunAsNew(localHistoryNode, node, callback)];
         }
+        return [nextNode, nextNode.output];
     }
-    VestTest.prototype.run = function () {
-        var result;
-        try {
-            result = this.testFn();
-        }
-        catch (error) {
-            if (shouldUseErrorAsMessage(this.message, error)) {
-                this.message = error;
-            }
-            result = false;
+    static removeAllNextNodesInIsolate() {
+        const testIsolate = useIsolate();
+        const historyNode = useHistoryNode();
+        if (!historyNode || !testIsolate) {
+            return;
         }
-        if (result === false) {
-            this.fail();
+        historyNode.slice(useCurrentCursor());
+    }
+    static handleCollision(newNode, prevNode) {
+        // we should base our calculation on the key property
+        if (newNode.usesKey()) {
+            return this.handleIsolateNodeWithKey(newNode);
         }
-        return result;
-    };
-    VestTest.prototype.setStatus = function (status) {
-        if (this.isFinalStatus() && status !== STATUS_OMITTED) {
-            return;
+        if (this.nodeReorderDetected(newNode, prevNode)) {
+            this.onNodeReorder(newNode, prevNode);
         }
-        this.status = status;
-    };
-    VestTest.prototype.warns = function () {
-        return this.severity === TestSeverity.Warning;
-    };
-    VestTest.prototype.setPending = function () {
-        this.setStatus(STATUS_PENDING);
-    };
-    VestTest.prototype.fail = function () {
-        this.setStatus(this.warns() ? STATUS_WARNING : STATUS_FAILED);
-    };
-    VestTest.prototype.done = function () {
-        if (this.isFinalStatus()) {
-            return;
+        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;
         }
-        this.setStatus(STATUS_PASSING);
-    };
-    VestTest.prototype.warn = function () {
-        this.severity = TestSeverity.Warning;
-    };
-    VestTest.prototype.isFinalStatus = function () {
-        return this.hasFailures() || this.isCanceled() || this.isPassing();
-    };
-    VestTest.prototype.skip = function (force) {
-        if (this.isPending() && !force) {
-            // Without this condition, 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.
+        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.setStatus(STATUS_SKIPPED);
-    };
-    VestTest.prototype.cancel = function () {
-        this.setStatus(STATUS_CANCELED);
-        useRefreshTestObjects();
-    };
-    VestTest.prototype.reset = function () {
-        this.status = STATUS_UNTESTED;
-        useRefreshTestObjects();
-    };
-    VestTest.prototype.omit = function () {
-        this.setStatus(STATUS_OMITTED);
-    };
-    VestTest.prototype.valueOf = function () {
-        return !this.isFailing();
-    };
-    VestTest.prototype.isPending = function () {
-        return this.statusEquals(STATUS_PENDING);
-    };
-    VestTest.prototype.isOmitted = function () {
-        return this.statusEquals(STATUS_OMITTED);
-    };
-    VestTest.prototype.isUntested = function () {
-        return this.statusEquals(STATUS_UNTESTED);
-    };
-    VestTest.prototype.isFailing = function () {
-        return this.statusEquals(STATUS_FAILED);
-    };
-    VestTest.prototype.isCanceled = function () {
-        return this.statusEquals(STATUS_CANCELED);
-    };
-    VestTest.prototype.isSkipped = function () {
-        return this.statusEquals(STATUS_SKIPPED);
-    };
-    VestTest.prototype.isPassing = function () {
-        return this.statusEquals(STATUS_PASSING);
-    };
-    VestTest.prototype.isWarning = function () {
-        return this.statusEquals(STATUS_WARNING);
-    };
-    VestTest.prototype.hasFailures = function () {
-        return this.isFailing() || this.isWarning();
-    };
-    VestTest.prototype.isNonActionable = function () {
-        return this.isSkipped() || this.isOmitted() || this.isCanceled();
-    };
-    VestTest.prototype.isTested = function () {
-        return this.hasFailures() || this.isPassing();
-    };
-    VestTest.prototype.awaitsResolution = function () {
-        // Is the test in a state where it can still be run, or complete running
-        // and its final status is indeterminate?
-        return this.isSkipped() || this.isUntested() || this.isPending();
-    };
-    VestTest.prototype.statusEquals = function (status) {
-        return this.status === status;
-    };
-    return VestTest;
-}());
-var STATUS_UNTESTED = 'UNTESTED';
-var STATUS_SKIPPED = 'SKIPPED';
-var STATUS_FAILED = 'FAILED';
-var STATUS_WARNING = 'WARNING';
-var STATUS_PASSING = 'PASSING';
-var STATUS_PENDING = 'PENDING';
-var STATUS_CANCELED = 'CANCELED';
-var STATUS_OMITTED = 'OMITTED';
-
-// eslint-disable-next-line max-lines-per-function
-function createState(onStateChange) {
-    var state = {
-        references: []
-    };
-    var registrations = [];
-    return {
-        registerStateKey: registerStateKey,
-        reset: reset
-    };
-    /**
-     * Registers a new key in the state, takes the initial value (may be a function that returns the initial value), returns a function.
-     *
-     * @example
-     *
-     * const useColor = state.registerStateKey("blue");
-     *
-     * let [color, setColor] = useColor(); // -> ["blue", Function]
-     *
-     * setColor("green");
-     *
-     * useColor()[0]; -> "green"
-     */
-    function registerStateKey(initialState, onUpdate) {
-        var key = registrations.length;
-        registrations.push([initialState, onUpdate]);
-        return initKey(key, initialState);
-    }
-    function reset() {
-        var prev = current();
-        state.references = [];
-        registrations.forEach(function (_a, index) {
-            var initialValue = _a[0];
-            return initKey(index, initialValue, prev[index]);
-        });
+        this.children.length = at;
     }
-    function initKey(key, initialState, prevState) {
-        current().push();
-        set(key, optionalFunctionValue(initialState, prevState));
-        return function useStateKey() {
-            return [
-                current()[key],
-                function (nextState) {
-                    return set(key, optionalFunctionValue(nextState, current()[key]));
-                },
-            ];
-        };
+    at(at) {
+        var _a, _b;
+        return (_b = (_a = this.children) === null || _a === void 0 ? void 0 : _a[at]) !== null && _b !== void 0 ? _b : null;
     }
-    function current() {
-        return state.references;
+    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;
     }
-    function set(index, value) {
-        var prevValue = state.references[index];
-        state.references[index] = value;
-        var _a = registrations[index], onUpdate = _a[1];
-        if (isFunction(onUpdate)) {
-            onUpdate(value, prevValue);
+    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);
         }
-        if (isFunction(onStateChange)) {
-            onStateChange();
+        else {
+            useSetHistory(node);
         }
+        node.setParent(parent);
+    }
+    static is(node) {
+        return node instanceof Isolate;
     }
 }
+Isolate.reconciler = Reconciler;
 
-function createStateRef(state, _a) {
-    var suiteId = _a.suiteId, suiteName = _a.suiteName;
-    return {
-        optionalFields: state.registerStateKey(function () { return ({}); }),
-        suiteId: state.registerStateKey(suiteId),
-        suiteName: state.registerStateKey(suiteName),
-        testCallbacks: state.registerStateKey(function () { return ({
-            fieldCallbacks: {},
-            doneCallbacks: []
-        }); }),
-        testObjects: state.registerStateKey(function (prev) {
-            return {
-                prev: prev ? prev.current : [],
-                current: []
-            };
-        })
-    };
-}
-
-/**
- * @returns {Isolate} The current isolate layer
- */
-function useIsolate() {
-    return context.useX().isolate;
-}
-/**
- * @returns {number[]} The current cursor path of the isolate tree
- */
-function useCurrentPath() {
-    var isolate = useIsolate();
-    return isolate.path.concat(isolate.cursor.current());
+function nonMatchingFieldName(WithFieldName, fieldName) {
+    return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
 }
-/**
- * @returns {IsolateCursor} The cursor object for the current isolate
- */
-function useCursor() {
-    return useIsolate().cursor;
+function matchingFieldName(WithFieldName, fieldName) {
+    return !!(fieldName && WithFieldName.fieldName === fieldName);
 }
 
-function usePrevKeys() {
-    var prev = useTestObjects()[0].prev;
-    return asArray(nestedArray.getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
-        if (!(testObject instanceof VestTest)) {
-            return prevKeys;
-        }
-        if (isNullish(testObject.key)) {
-            return prevKeys;
-        }
-        prevKeys[testObject.key] = testObject;
-        return prevKeys;
-    }, {});
-}
-function usePrevTestByKey(key) {
-    var prev = useIsolate().keys.prev;
-    return prev[key];
-}
-function useRetainTestKey(key, testObject) {
-    var current = useIsolate().keys.current;
-    if (isNullish(current[key])) {
-        current[key] = testObject;
-    }
-    else {
-        deferThrow("Encountered the same test key \"".concat(key, "\" twice. This may lead to tests overriding each other's results, or to tests being unexpectedly omitted."));
-    }
+function isSameProfileTest(testObject1, testObject2) {
+    return (matchingFieldName(testObject1, testObject2.fieldName) &&
+        testObject1.groupName === testObject2.groupName &&
+        testObject1.key === testObject2.key);
 }
 
-function isolate(_a, callback) {
-    var _b = _a.type, type = _b === void 0 ? IsolateTypes.DEFAULT : _b;
-    invariant(isFunction(callback));
-    // Generate a new Isolate layer, with its own cursor
-    var isolate = generateIsolate(type, useCurrentPath());
-    var output = context.run({ isolate: isolate }, function () {
-        isolate.keys.prev = usePrevKeys();
-        useSetTests(function (tests) { return nestedArray.setValueAtPath(tests, isolate.path, []); });
-        var res = callback();
-        return res;
-    });
-    // Move the parent cursor forward once we're done
-    useCursor().next();
-    return output;
-}
-/**
- * @returns {boolean} Whether or not the current isolate allows tests to be reordered
- */
-function shouldAllowReorder() {
-    return useIsolate().type === IsolateTypes.EACH;
+function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
+    if (currentRunTestObject !== prevRunTestObject &&
+        isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
+        prevRunTestObject.isPending()) {
+        prevRunTestObject.cancel();
+    }
 }
 
 var Severity;
@@ -453,14 +296,7 @@ function countKeyBySeverity(severity) {
         : SeverityCount.WARN_COUNT;
 }
 
-function nonMatchingFieldName(testObject, fieldName) {
-    return !!fieldName && !matchingFieldName(testObject, fieldName);
-}
-function matchingFieldName(testObject, fieldName) {
-    return !!(fieldName && testObject.fieldName === fieldName);
-}
-
-var nonMatchingGroupName = bindNot(matchingGroupName);
+const nonMatchingGroupName = bindNot(matchingGroupName);
 function matchingGroupName(testObject, groupName) {
     return testObject.groupName === groupName;
 }
@@ -480,14 +316,12 @@ function hasErrorsByTestObjects(fieldName) {
     return hasFailuresByTestObjects(Severity.ERRORS, fieldName);
 }
 function hasFailuresByTestObjects(severityKey, fieldName) {
-    var testObjects = useTestsFlat();
-    return testObjects.some(function (testObject) {
+    return TestWalker.someTests(testObject => {
         return hasFailuresByTestObject(testObject, severityKey, fieldName);
     });
 }
 function hasGroupFailuresByTestObjects(severityKey, groupName, fieldName) {
-    var testObjects = useTestsFlat();
-    return testObjects.some(function (testObject) {
+    return TestWalker.someTests(testObject => {
         if (nonMatchingGroupName(testObject, groupName)) {
             return false;
         }
@@ -510,137 +344,179 @@ function hasFailuresByTestObject(testObject, severityKey, fieldName) {
     return true;
 }
 
+var Modes;
+(function (Modes) {
+    Modes["ALL"] = "ALL";
+    Modes["EAGER"] = "EAGER";
+})(Modes || (Modes = {}));
 /**
- * Marks a field as optional, either just by name, or by a given condition.
+ * 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();
  *
- * optional('field_name');
+ *  test('username', 'username is required', () => {
+ *   enforce(data.username).isNotBlank();
+ *  });
  *
- * optional({
- *  username: () => allowUsernameEmpty,
+ *  test('username', 'username is too short', () => {
+ *   enforce(data.username).longerThan(2);
+ *  });
  * });
  */
-function optional(optionals) {
-    // 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(function (optionalField) {
-            useSetOptionalField(optionalField, function () { return ({
-                type: OptionalFieldTypes.Delayed,
-                applied: false,
-                rule: null
-            }); });
-        });
-    }
-    else {
-        var _loop_1 = function (field) {
-            var value = optionals[field];
-            useSetOptionalField(field, function () { return ({
-                type: OptionalFieldTypes.Immediate,
-                rule: value,
-                applied: optionalFunctionValue(value)
-            }); });
-        };
-        // Immediately case (function or boolean)
-        for (var field in optionals) {
-            _loop_1(field);
-        }
+// @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);
+}
+
+const SuiteContext = createCascade((ctxRef, parentContext) => {
+    if (parentContext) {
+        return null;
+    }
+    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;
+class SummaryBase {
+    constructor() {
+        this.errorCount = 0;
+        this.warnCount = 0;
+        this.testCount = 0;
     }
 }
-function optionalFiedIsApplied(fieldName) {
-    if (!fieldName) {
-        return false;
+class SuiteSummary extends SummaryBase {
+    constructor() {
+        super(...arguments);
+        this[_a] = [];
+        this[_b] = [];
+        this.groups = {};
+        this.tests = {};
+        this.valid = false;
     }
-    return useOptionalField(fieldName).applied;
 }
-var OptionalFieldTypes;
-(function (OptionalFieldTypes) {
-    OptionalFieldTypes[OptionalFieldTypes["Immediate"] = 0] = "Immediate";
-    OptionalFieldTypes[OptionalFieldTypes["Delayed"] = 1] = "Delayed";
-})(OptionalFieldTypes || (OptionalFieldTypes = {}));
+_a = Severity.ERRORS, _b = Severity.WARNINGS;
 
-// eslint-disable-next-line max-statements, complexity
-function shouldAddValidProperty(fieldName) {
+function useShouldAddValidProperty(fieldName) {
     // Is the field optional, and the optional condition is applied
-    if (optionalFiedIsApplied(fieldName)) {
+    if (useIsOptionalFiedApplied(fieldName)) {
         return true;
     }
-    var testObjects = useTestsFlat();
     // Are there no tests?
-    if (isEmpty(testObjects)) {
+    if (TestWalker.hasNoTests()) {
         return false;
     }
-    // Does the field have any tests with errors?
+    // // 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 (hasNonOptionalIncomplete(fieldName)) {
+    if (useHasNonOptionalIncomplete(fieldName)) {
         return false;
     }
     // Does the field have no missing tests?
-    return noMissingTests(fieldName);
+    return useNoMissingTests(fieldName);
 }
-function shouldAddValidPropertyInGroup(groupName, fieldName) {
-    if (optionalFiedIsApplied(fieldName)) {
+function useShouldAddValidPropertyInGroup(groupName, fieldName) {
+    if (useIsOptionalFiedApplied(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 (hasNonOptionalIncompleteByGroup(groupName, fieldName)) {
+    if (useHasNonOptionalIncompleteByGroup(groupName, fieldName)) {
         return false;
     }
-    return noMissingTestsByGroup(groupName, fieldName);
+    return useNoMissingTestsByGroup(groupName, fieldName);
 }
 // Does the given field have any pending tests that are not optional?
-function hasNonOptionalIncomplete(fieldName) {
-    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
-        return isTestObjectOptional(testObject, fieldName);
-    }));
+function useHasNonOptionalIncomplete(fieldName) {
+    return TestWalker.someIncompleteTests(testObject => {
+        return useIsTestObjectOptional(testObject, fieldName);
+    });
 }
 // Do the given group/field have any pending tests that are not optional?
-function hasNonOptionalIncompleteByGroup(groupName, fieldName) {
-    return isNotEmpty(useAllIncomplete().filter(function (testObject) {
+function useHasNonOptionalIncompleteByGroup(groupName, fieldName) {
+    return TestWalker.someIncompleteTests(testObject => {
         if (nonMatchingGroupName(testObject, groupName)) {
             return false;
         }
-        return isTestObjectOptional(testObject, fieldName);
-    }));
+        return useIsTestObjectOptional(testObject, fieldName);
+    });
 }
-function isTestObjectOptional(testObject, fieldName) {
+function useIsTestObjectOptional(testObject, fieldName) {
     if (nonMatchingFieldName(testObject, fieldName)) {
         return false;
     }
-    return optionalFiedIsApplied(fieldName);
+    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 noMissingTests(fieldName) {
-    var testObjects = useTestsFlat();
-    return testObjects.every(function (testObject) {
-        return noMissingTestsLogic(testObject, fieldName);
+function useNoMissingTests(fieldName) {
+    return TestWalker.everyTest(testObject => {
+        return useNoMissingTestsLogic(testObject, fieldName);
     });
 }
 // Does the group have no missing tests?
-function noMissingTestsByGroup(groupName, fieldName) {
-    var testObjects = useTestsFlat();
-    return testObjects.every(function (testObject) {
+function useNoMissingTestsByGroup(groupName, fieldName) {
+    return TestWalker.everyTest(testObject => {
         if (nonMatchingGroupName(testObject, groupName)) {
             return true;
         }
-        return noMissingTestsLogic(testObject, fieldName);
+        return useNoMissingTestsLogic(testObject, fieldName);
     });
 }
-// Does the object qualify as either tested or omitted (but not skipped!)
-function noMissingTestsLogic(testObject, fieldName) {
+function useNoMissingTestsLogic(testObject, fieldName) {
     if (nonMatchingFieldName(testObject, fieldName)) {
         return true;
     }
@@ -653,102 +529,110 @@ function noMissingTestsLogic(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 (optionalTestAwaitsResolution(testObject) ||
+    return (useOptionalTestAwaitsResolution(testObject) ||
         testObject.isTested() ||
         testObject.isOmitted());
 }
-function optionalTestAwaitsResolution(testObject) {
+function useOptionalTestAwaitsResolution(testObject) {
     // Does the test belong to an optional field,
     // and the test itself is still in an indeterminate state?
-    return (useOptionalField(testObject.fieldName).type ===
+    var _a;
+    return (((_a = useAvailableSuiteRoot()) === null || _a === void 0 ? void 0 : _a.getOptionalField(testObject.fieldName).type) ===
         OptionalFieldTypes.Delayed && testObject.awaitsResolution());
 }
 
-/**
- * Reads the testObjects list and gets full validation result from it.
- */
-function genTestsSummary() {
-    var testObjects = useTestsFlat();
-    var summary = assign(baseStats(), {
-        groups: {},
-        tests: {},
-        valid: false
+function useProduceSuiteSummary() {
+    const summary = new SuiteSummary();
+    TestWalker.walkTests(testObject => {
+        summary.tests = useAppendToTest(summary.tests, testObject);
+        summary.groups = useAppendToGroup(summary.groups, testObject);
+        summary.errors = appendFailures(Severity.ERRORS, summary.errors, testObject);
+        summary.warnings = appendFailures(Severity.WARNINGS, summary.warnings, testObject);
     });
-    testObjects.reduce(function (summary, testObject) {
-        appendToTest(summary.tests, testObject);
-        appendToGroup(summary.groups, testObject);
-        return summary;
-    }, summary);
-    summary.valid = shouldAddValidProperty();
+    summary.valid = useShouldAddValidProperty();
     return countFailures(summary);
 }
-function appendToTest(tests, testObject) {
-    tests[testObject.fieldName] = appendTestObject(tests, testObject);
+function appendFailures(key, failures, testObject) {
+    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;
+}
+function useAppendToTest(tests, testObject) {
+    const { fieldName } = testObject;
+    const newTests = Object.assign({}, tests);
+    newTests[fieldName] = appendTestObject(newTests[fieldName], testObject);
     // If `valid` is false to begin with, keep it that way. Otherwise, assess.
-    tests[testObject.fieldName].valid =
-        tests[testObject.fieldName].valid === false
+    newTests[fieldName].valid =
+        newTests[fieldName].valid === false
             ? false
-            : shouldAddValidProperty(testObject.fieldName);
+            : useShouldAddValidProperty(fieldName);
+    return newTests;
 }
 /**
  * Appends to a group object if within a group
  */
-function appendToGroup(groups, testObject) {
-    var groupName = testObject.groupName;
+function useAppendToGroup(groups, testObject) {
+    const { groupName, fieldName } = testObject;
     if (!groupName) {
-        return;
+        return groups;
     }
-    groups[groupName] = groups[groupName] || {};
-    groups[groupName][testObject.fieldName] = appendTestObject(groups[groupName], testObject);
-    groups[groupName][testObject.fieldName].valid =
-        groups[groupName][testObject.fieldName].valid === false
+    const newGroups = Object.assign({}, groups);
+    newGroups[groupName] = newGroups[groupName] || {};
+    newGroups[groupName][fieldName] = appendTestObject(newGroups[groupName][fieldName], testObject);
+    newGroups[groupName][fieldName].valid =
+        newGroups[groupName][fieldName].valid === false
             ? false
-            : shouldAddValidPropertyInGroup(groupName, testObject.fieldName);
+            : useShouldAddValidPropertyInGroup(groupName, fieldName);
+    return newGroups;
 }
 /**
  * Counts the failed tests and adds global counters
  */
 function countFailures(summary) {
-    for (var test in summary.tests) {
+    for (const test in summary.tests) {
         summary.errorCount += summary.tests[test].errorCount;
         summary.warnCount += summary.tests[test].warnCount;
         summary.testCount += summary.tests[test].testCount;
     }
     return summary;
 }
+/**
+ * Appends the test to a results object.
+ * Overload is only needed to satisfy typescript. No use in breaking it down to multiple
+ * functions as it is really the same, with the difference of "valid" missing in groups
+ */
 function appendTestObject(summaryKey, testObject) {
-    var fieldName = testObject.fieldName, message = testObject.message;
-    summaryKey[fieldName] = summaryKey[fieldName] || baseTestStats();
-    var testKey = summaryKey[fieldName];
+    const { message } = testObject;
+    const nextSummaryKey = defaultTo(summaryKey ? Object.assign({}, summaryKey) : null, baseTestStats);
     if (testObject.isNonActionable())
-        return testKey;
-    summaryKey[fieldName].testCount++;
+        return nextSummaryKey;
+    nextSummaryKey.testCount++;
     if (testObject.isFailing()) {
         incrementFailures(Severity.ERRORS);
     }
     else if (testObject.isWarning()) {
         incrementFailures(Severity.WARNINGS);
     }
-    return testKey;
+    return nextSummaryKey;
     function incrementFailures(severity) {
-        var countKey = countKeyBySeverity(severity);
-        testKey[countKey]++;
+        const countKey = countKeyBySeverity(severity);
+        nextSummaryKey[countKey]++;
         if (message) {
-            testKey[severity] = (testKey[severity] || []).concat(message);
+            nextSummaryKey[severity] = (nextSummaryKey[severity] || []).concat(message);
         }
     }
 }
-function baseStats() {
-    return {
-        errorCount: 0,
-        warnCount: 0,
-        testCount: 0
-    };
-}
 function baseTestStats() {
-    return assign(baseStats(), {
+    return assign(new SummaryBase(), {
         errors: [],
-        warnings: []
+        warnings: [],
+        valid: true,
     });
 }
 
@@ -763,9 +647,9 @@ function getByFieldName(testGroup, severityKey, fieldName) {
     return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
 }
 function collectAll(testGroup, severityKey) {
-    var output = {};
-    var countKey = countKeyBySeverity(severityKey);
-    for (var field in testGroup) {
+    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
@@ -777,17 +661,19 @@ function collectAll(testGroup, severityKey) {
 
 // eslint-disable-next-line max-lines-per-function, max-statements
 function suiteSelectors(summary) {
-    var selectors = {
-        getErrors: getErrors,
-        getErrorsByGroup: getErrorsByGroup,
-        getWarnings: getWarnings,
-        getWarningsByGroup: getWarningsByGroup,
-        hasErrors: hasErrors,
-        hasErrorsByGroup: hasErrorsByGroup,
-        hasWarnings: hasWarnings,
-        hasWarningsByGroup: hasWarningsByGroup,
-        isValid: isValid,
-        isValidByGroup: isValidByGroup
+    const selectors = {
+        getError,
+        getErrors,
+        getErrorsByGroup,
+        getWarning,
+        getWarnings,
+        getWarningsByGroup,
+        hasErrors,
+        hasErrorsByGroup,
+        hasWarnings,
+        hasWarningsByGroup,
+        isValid,
+        isValidByGroup,
     };
     return selectors;
     // Booleans
@@ -796,15 +682,15 @@ function suiteSelectors(summary) {
         return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
     }
     function isValidByGroup(groupName, fieldName) {
-        var group = summary.groups[groupName];
+        const group = summary.groups[groupName];
         if (!group) {
             return false;
         }
         if (fieldName) {
             return isFieldValid(group, fieldName);
         }
-        for (var fieldName_1 in group) {
-            if (!isFieldValid(group, fieldName_1)) {
+        for (const fieldName in group) {
+            if (!isFieldValid(group, fieldName)) {
                 return false;
             }
         }
@@ -825,9 +711,15 @@ function suiteSelectors(summary) {
     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);
     }
@@ -835,8 +727,6 @@ function suiteSelectors(summary) {
         return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
     }
 }
-// Gathers all failures of a given severity
-// With a fieldName, it will only gather failures for that field
 function getFailures(summary, severityKey, fieldName) {
     return gatherFailures(summary.tests, severityKey, fieldName);
 }
@@ -854,14 +744,14 @@ function isFieldValid(testContainer, fieldName) {
 // If a fieldName is provided, it will only check for failures within that field
 function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
     var _a, _b;
-    var group = summary.groups[groupName];
+    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 (var field in group) {
+    for (const field in group) {
         if (isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
             return true;
         }
@@ -872,309 +762,28 @@ function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
 // If a fieldName is provided, it will only check for failures within that field
 function hasFailures(summary, countKey, fieldName) {
     var _a;
-    var failureCount = fieldName
+    const failureCount = fieldName
         ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
         : summary[countKey] || 0;
     return isPositive(failureCount);
 }
-
-var cache$1 = cache$2(1);
-function produceSuiteResult() {
-    var testObjects = useTestsFlat();
-    var ctxRef = { stateRef: useStateRef() };
-    return cache$1([testObjects], context.bind(ctxRef, function () {
-        var summary = genTestsSummary();
-        var suiteName = useSuiteName();
-        return assign(summary, suiteSelectors(summary), {
-            suiteName: suiteName
-        });
-    }));
-}
-
-/**
- * Checks if a given field, or the suite as a whole still have remaining tests.
- */
-function hasRemainingTests(fieldName) {
-    var allIncomplete = useAllIncomplete();
-    if (isEmpty(allIncomplete)) {
-        return false;
-    }
-    if (fieldName) {
-        return allIncomplete.some(function (testObject) {
-            return matchingFieldName(testObject, fieldName);
-        });
-    }
-    return true;
-}
-
-var cache = cache$2(20);
-function produceFullResult() {
-    var testObjects = useTestsFlat();
-    var ctxRef = { stateRef: useStateRef() };
-    return cache([testObjects], context.bind(ctxRef, function () {
-        return assign({}, produceSuiteResult(), {
-            done: context.bind(ctxRef, done)
-        });
-    }));
-}
-/**
- * DONE is here and not in its own module to prevent circular dependency issues.
- */
-function shouldSkipDoneRegistration(callback, fieldName, output) {
+function getFailure(severity, summary, fieldName) {
     var _a;
-    // If we do not have any test runs for the current field
-    return !!(!isFunction(callback) ||
-        (fieldName && numberEquals((_a = output.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount, 0)));
-}
-function shouldRunDoneCallback(fieldName) {
-    // is suite finished || field name exists, and test is finished;
-    return !!(!hasRemainingTests() ||
-        (fieldName && !hasRemainingTests(fieldName)));
-}
-/**
- * Registers done callbacks.
- * @register {Object} Vest output object.
- */
-var done = function done() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var _a = args.reverse(), callback = _a[0], fieldName = _a[1];
-    var output = produceFullResult();
-    if (shouldSkipDoneRegistration(callback, fieldName, output)) {
-        return output;
-    }
-    var doneCallback = function () { return callback(produceSuiteResult()); };
-    if (shouldRunDoneCallback(fieldName)) {
-        doneCallback();
-        return output;
-    }
-    deferDoneCallback(doneCallback, fieldName);
-    return output;
-};
-function deferDoneCallback(doneCallback, fieldName) {
-    var _a = useTestCallbacks(), setTestCallbacks = _a[1];
-    setTestCallbacks(function (current) {
-        if (fieldName) {
-            current.fieldCallbacks[fieldName] = (current.fieldCallbacks[fieldName] || []).concat(doneCallback);
-        }
-        else {
-            current.doneCallbacks.push(doneCallback);
-        }
-        return current;
-    });
-}
-
-/**
- * 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 omitOptionalFields() {
-    var optionalFields = useOptionalFields()[0];
-    // 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
-    var shouldOmit = {};
-    // iterate over each of the tests in the state
-    useTestsFlat().forEach(function (testObject) {
-        // 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);
-        }
-    });
-    // refresh the tests in the state so that the omitted fields are applied
-    useRefreshTestObjects();
-    function verifyAndOmit(testObject) {
-        if (shouldOmit[testObject.fieldName]) {
-            testObject.omit();
-            useSetOptionalField(testObject.fieldName, function () { return ({
-                applied: true
-            }); });
-        }
-    }
-    function runOptionalConfig(testObject) {
-        // Ge the optional configuration for the given field
-        var optionalConfig = useOptionalField(testObject.fieldName);
-        // If the optional was set to a function or a boolean, run it and verify/omit the test
-        if (optionalConfig.type === OptionalFieldTypes.Immediate) {
-            shouldOmit[testObject.fieldName] = optionalFunctionValue(optionalConfig.rule);
-            verifyAndOmit(testObject);
-        }
-    }
-}
-
-/**
- * Removes test object from suite state
- */
-function removeTestFromState (testObject) {
-    useSetTests(function (tests) {
-        return nestedArray.transform(tests, function (test) { return (testObject !== test ? test : null); });
-    });
-}
-
-/**
- * Runs done callback per field when async tests are finished running.
- */
-function runFieldCallbacks(fieldName) {
-    var fieldCallbacks = useTestCallbacks()[0].fieldCallbacks;
-    if (fieldName &&
-        !hasRemainingTests(fieldName) &&
-        isArray(fieldCallbacks[fieldName])) {
-        callEach(fieldCallbacks[fieldName]);
+    const summaryKey = summary[severity];
+    if (!fieldName) {
+        return summaryKey[0];
     }
-}
-/**
- * Runs unlabelled done callback when async tests are finished running.
- */
-function runDoneCallbacks() {
-    var doneCallbacks = useTestCallbacks()[0].doneCallbacks;
-    callEach(doneCallbacks);
-}
-
-// eslint-disable-next-line max-lines-per-function
-function initBus() {
-    var vestBus = bus.createBus();
-    // Report a the completion of a test. There may be other tests with the same
-    // name that are still running, or not yet started.
-    vestBus.on(Events.TEST_COMPLETED, function (testObject) {
-        if (testObject.isCanceled()) {
-            return;
-        }
-        testObject.done();
-        runFieldCallbacks(testObject.fieldName);
-        if (!hasRemainingTests()) {
-            // When no more tests are running, emit the done event
-            vestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
-        }
-    });
-    // Report that the suite completed its synchronous test run.
-    // Async operations may still be running.
-    vestBus.on(Events.SUITE_CALLBACK_DONE_RUNNING, function () {
-        // Remove tests that are optional and need to be omitted
-        omitOptionalFields();
-    });
-    // Called when all the tests, including async, are done running
-    vestBus.on(Events.ALL_RUNNING_TESTS_FINISHED, function () {
-        runDoneCallbacks();
-    });
-    // Removes a certain field from the state.
-    vestBus.on(Events.REMOVE_FIELD, function (fieldName) {
-        useEachTestObject(function (testObject) {
-            if (matchingFieldName(testObject, fieldName)) {
-                testObject.cancel();
-                removeTestFromState(testObject);
-            }
-        });
-    });
-    // Resets a certain field in the state.
-    vestBus.on(Events.RESET_FIELD, function (fieldName) {
-        useEachTestObject(function (testObject) {
-            if (matchingFieldName(testObject, fieldName)) {
-                testObject.reset();
-            }
-        });
-    });
-    return vestBus;
-}
-function useBus() {
-    var context$1 = context.useX();
-    invariant(context$1.bus);
-    return context$1.bus;
-}
-var Events;
-(function (Events) {
-    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["SUITE_CALLBACK_DONE_RUNNING"] = "suite_callback_done_running";
-})(Events || (Events = {}));
-
-// eslint-disable-next-line max-lines-per-function
-function create() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var _a = args.reverse(), suiteCallback = _a[0], suiteName = _a[1];
-    invariant(isFunction(suiteCallback), 'vest.create: Expected callback to be a function.');
-    // Event bus initialization
-    var bus = initBus();
-    // State initialization
-    var state = createState();
-    // State reference - this holds the actual state values
-    var stateRef = createStateRef(state, { suiteId: seq(), suiteName: suiteName });
-    // Create base context reference. All hooks will derive their data from this
-    var ctxRef = { stateRef: stateRef, bus: bus };
-    var suite = assign(
-    // Bind the suite body to the context
-    context.bind(ctxRef, function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        // Reset the state. Migrates current test objects to `prev` array.
-        state.reset();
-        // Create a top level isolate
-        isolate({ type: IsolateTypes.SUITE }, function () {
-            // Run the consumer's callback
-            suiteCallback.apply(void 0, args);
-        });
-        // Report the suite is done registering tests
-        // Async tests may still be running
-        bus.emit(Events.SUITE_CALLBACK_DONE_RUNNING);
-        // Return the result
-        return produceFullResult();
-    }), {
-        get: context.bind(ctxRef, produceSuiteResult),
-        remove: context.bind(ctxRef, function (fieldName) {
-            bus.emit(Events.REMOVE_FIELD, fieldName);
-        }),
-        reset: state.reset,
-        resetField: context.bind(ctxRef, function (fieldName) {
-            bus.emit(Events.RESET_FIELD, fieldName);
-        })
-    });
-    return suite;
+    return (_a = summaryKey.find((summaryFailure) => matchingFieldName(summaryFailure, fieldName))) === null || _a === void 0 ? void 0 : _a.message;
 }
 
-/**
- * Iterates over an array of items, allowing to run tests individually per item.
- *
- * Requires setting a "key" property on each item tested.
- *
- * @example
- *
- * each(itemsArray, (item) => {
- *  test(item.name, 'Item value must not be empty', () => {
- *    enforce(item.value).isNotEmpty();
- *  }, item.id)
- * })
- */
-function each(list, callback) {
-    invariant(isFunction(callback), 'each callback must be a function');
-    isolate({ type: IsolateTypes.EACH }, function () {
-        list.forEach(function (arg, index) {
-            callback(arg, index);
-        });
-    });
+function useCreateSuiteResult() {
+    const summary = useProduceSuiteSummary();
+    const suiteName = useSuiteName();
+    return useSuiteResultCache(() => assign(summary, suiteSelectors(summary), {
+        suiteName,
+    }));
 }
 
-/**
- * Error message to display when a hook was called outside of context.
- */
-var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
-
 /**
  * Conditionally skips running tests within the callback.
  *
@@ -1184,20 +793,21 @@ var ERROR_HOOK_CALLED_OUTSIDE = 'hook called outside of a running suite.';
  *  test('username', 'User already taken', async () => await doesUserExist(username)
  * });
  */
-function skipWhen(conditional, callback) {
-    isolate({ type: IsolateTypes.SKIP_WHEN }, function () {
-        context.run({
+// @vx-allow use-use
+function skipWhen(condition, callback) {
+    Isolate.create(() => {
+        SuiteContext.run({
             skipped: 
             // Checking for nested conditional. If we're in a nested skipWhen,
             // we should skip the test if the parent conditional is true.
-            isExcludedIndividually() ||
+            useIsExcludedIndividually() ||
                 // Otherwise, we should skip the test if the conditional is true.
-                optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
-        }, function () { return callback(); });
+                optionalFunctionValue(condition, optionalFunctionValue(useCreateSuiteResult)),
+        }, callback);
     });
 }
-function isExcludedIndividually() {
-    return !!context.useX().skipped;
+function useIsExcludedIndividually() {
+    return useSkipped();
 }
 
 /**
@@ -1207,11 +817,12 @@ function isExcludedIndividually() {
  *
  * only('username');
  */
+// @vx-allow use-use
 function only(item) {
-    return addTo(0 /* ExclusionGroup.ONLY */, 'tests', item);
+    return useAddTo(0 /* ExclusionGroup.ONLY */, 'tests', item);
 }
-only.group = function (item) {
-    return addTo(0 /* ExclusionGroup.ONLY */, 'groups', item);
+only.group = function group(item) {
+    return useAddTo(0 /* ExclusionGroup.ONLY */, 'groups', item);
 };
 /**
  * Adds a field or a list of fields into the exclusion list
@@ -1220,31 +831,31 @@ only.group = function (item) {
  *
  * skip('username');
  */
+// @vx-allow use-use
 function skip(item) {
-    return addTo(1 /* ExclusionGroup.SKIP */, 'tests', item);
+    return useAddTo(1 /* ExclusionGroup.SKIP */, 'tests', item);
 }
-skip.group = function (item) {
-    return addTo(1 /* ExclusionGroup.SKIP */, 'groups', item);
+skip.group = function group(item) {
+    return useAddTo(1 /* ExclusionGroup.SKIP */, 'groups', item);
 };
 //Checks whether a certain test profile excluded by any of the exclusion groups.
 // eslint-disable-next-line complexity, max-statements
-function isExcluded(testObject) {
-    var fieldName = testObject.fieldName, groupName = testObject.groupName;
-    if (isExcludedIndividually())
+function useIsExcluded(testObject) {
+    const { fieldName, groupName } = testObject;
+    if (useIsExcludedIndividually())
         return true;
-    var context$1 = context.useX();
-    var exclusion = context$1.exclusion;
-    var inclusion = context$1.inclusion;
-    var keyTests = exclusion.tests;
-    var testValue = keyTests[fieldName];
+    const exclusion = useExclusion();
+    const inclusion = useInclusion();
+    const keyTests = exclusion.tests;
+    const testValue = keyTests[fieldName];
     // if test is skipped
     // no need to proceed
     if (testValue === false)
         return true;
-    var isTestIncluded = testValue === true;
+    const isTestIncluded = testValue === true;
     // If inside a group
     if (groupName) {
-        if (isGroupExcluded(groupName)) {
+        if (useIsGroupExcluded(groupName)) {
             return true; // field excluded by group
             // if group is `only`ed
         }
@@ -1257,7 +868,7 @@ function isExcluded(testObject) {
             return keyTests[fieldName] === false;
         }
     }
-    if (isTopLevelWhenThereIsAnIncludedGroup(groupName)) {
+    if (useIsTopLevelWhenThereIsAnIncludedGroup(groupName)) {
         return true;
     }
     // if field is only'ed
@@ -1276,11 +887,10 @@ function isExcluded(testObject) {
 /**
  * Checks whether a given group is excluded from running.
  */
-function isGroupExcluded(groupName) {
-    var context$1 = context.useX();
-    var exclusion = context$1.exclusion;
-    var keyGroups = exclusion.groups;
-    var groupPresent = hasOwnProperty(keyGroups, groupName);
+function useIsGroupExcluded(groupName) {
+    const exclusion = useExclusion();
+    const keyGroups = exclusion.groups;
+    const groupPresent = hasOwnProperty(keyGroups, groupName);
     // When group is either only'ed or skipped
     if (groupPresent) {
         // Return true if group is skipped and false if only'ed
@@ -1288,29 +898,28 @@ function isGroupExcluded(groupName) {
     }
     // Group is not present
     // Return whether other groups are included
-    return hasIncludedGroups();
+    return useHasIncludedGroups();
 }
 /**
  * Adds fields to a specified exclusion group.
  */
-function addTo(exclusionGroup, itemType, item) {
-    var context$1 = context.useX(ERROR_HOOK_CALLED_OUTSIDE);
+function useAddTo(exclusionGroup, itemType, item) {
+    const exclusion = useExclusion(ErrorStrings.HOOK_CALLED_OUTSIDE);
     if (!item) {
         return;
     }
-    asArray(item).forEach(function (itemName) {
+    asArray(item).forEach((itemName) => {
         if (!isStringValue(itemName)) {
             return;
         }
-        context$1.exclusion[itemType][itemName] =
-            exclusionGroup === 0 /* ExclusionGroup.ONLY */;
+        exclusion[itemType][itemName] = exclusionGroup === 0 /* ExclusionGroup.ONLY */;
     });
 }
 /**
  * Checks if context has included tests
  */
 function hasIncludedTests(keyTests) {
-    for (var test in keyTests) {
+    for (const test in keyTests) {
         if (keyTests[test] === true) {
             return true; // excluded implicitly
         }
@@ -1318,17 +927,16 @@ function hasIncludedTests(keyTests) {
     return false;
 }
 // are we not in a group and there is an included group?
-function isTopLevelWhenThereIsAnIncludedGroup(groupName) {
-    if (!hasIncludedGroups()) {
+function useIsTopLevelWhenThereIsAnIncludedGroup(groupName) {
+    if (!useHasIncludedGroups()) {
         return false;
     }
     // Return whether there's an included group, and we're not inside a group
     return !groupName;
 }
-function hasIncludedGroups() {
-    var context$1 = context.useX();
-    var exclusion = context$1.exclusion;
-    for (var group in exclusion.groups) {
+function useHasIncludedGroups() {
+    const exclusion = useExclusion();
+    for (const group in exclusion.groups) {
         if (exclusion.groups[group]) {
             return true;
         }
@@ -1337,398 +945,991 @@ function hasIncludedGroups() {
 }
 
 /**
- * Runs tests within a group so that they can be controlled or queried separately.
+ * Conditionally omits tests from the suite.
  *
  * @example
  *
- * group('group_name', () => {
- *  // Tests go here
+ * omitWhen(res => res.hasErrors('username'), () => {
+ *  test('username', 'User already taken', async () => await doesUserExist(username)
  * });
  */
-function group(groupName, tests) {
-    invariant(isStringValue(groupName), groupErrorMsg('name must be a string'));
-    invariant(isFunction(tests), groupErrorMsg('callback must be a function'));
-    // Running with the context applied
-    isolate({ type: IsolateTypes.GROUP }, function () {
-        context.run({ groupName: groupName }, tests);
+// @vx-allow use-use
+function omitWhen(conditional, callback) {
+    Isolate.create(() => {
+        SuiteContext.run({
+            omitted: useWithinActiveOmitWhen() ||
+                optionalFunctionValue(conditional, optionalFunctionValue(useCreateSuiteResult)),
+        }, callback);
     });
 }
-function groupErrorMsg(error) {
-    return "Wrong arguments passed to group. Group ".concat(error, ".");
+// Checks that we're currently in an active omitWhen block
+function useWithinActiveOmitWhen() {
+    return useOmitted();
 }
 
-function include(fieldName) {
-    var context$1 = context.useX();
-    var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
-    invariant(isStringValue(fieldName));
-    inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
-    return { when: when };
-    function when(condition) {
-        var context$1 = context.useX();
-        var inclusion = context$1.inclusion, exclusion = context$1.exclusion;
-        // This callback will run as part of the "isExcluded" series of checks
-        inclusion[fieldName] = function () {
-            if (hasOwnProperty(exclusion.tests, fieldName)) {
-                // I suspect this code is technically unreachable because
-                // if there are any skip/only rules applied to the current
-                // field, the "isExcluded" function will have already bailed
-                return defaultTo(exclusion.tests[fieldName], true);
-            }
-            if (isStringValue(condition)) {
-                return Boolean(exclusion.tests[condition]);
-            }
-            return optionalFunctionValue(condition, optionalFunctionValue(produceSuiteResult));
-        };
+function useVerifyTestRun(testObject, collisionResult = testObject) {
+    if (useShouldSkipBasedOnMode(testObject)) {
+        return skipTestAndReturn(testObject);
     }
+    if (useShouldOmit(testObject)) {
+        return omitTestAndReturn(testObject);
+    }
+    if (useIsExcluded(testObject)) {
+        return useForceSkipIfInSkipWhen(collisionResult);
+    }
+    return testObject;
 }
-
-/**
- * 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);
- *  });
- * });
- */
-function eager() {
-    setMode(Modes.EAGER);
-}
-function shouldSkipBasedOnMode(testObject) {
-    return isEager() && hasErrorsByTestObjects(testObject.fieldName);
-}
-function isEager() {
-    return isMode(Modes.EAGER);
-}
-function isMode(mode) {
-    var currentMode = context.useX().mode;
-    return currentMode[0] === mode;
+function useShouldOmit(testObject) {
+    return (useWithinActiveOmitWhen() || useIsOptionalFiedApplied(testObject.fieldName));
 }
-function setMode(nextMode) {
-    var mode = context.useX().mode;
-    mode[0] = nextMode;
+function skipTestAndReturn(testNode) {
+    testNode.skip();
+    return testNode;
 }
-
-/**
- * Conditionally omits tests from the suite.
- *
- * @example
- *
- * omitWhen(res => res.hasErrors('username'), () => {
- *  test('username', 'User already taken', async () => await doesUserExist(username)
- * });
- */
-function omitWhen(conditional, callback) {
-    isolate({ type: IsolateTypes.OMIT_WHEN }, function () {
-        context.run({
-            omitted: inActiveOmitWhen() ||
-                optionalFunctionValue(conditional, optionalFunctionValue(produceSuiteResult))
-        }, function () { return callback(); });
-    });
+function omitTestAndReturn(testNode) {
+    testNode.omit();
+    return testNode;
 }
-// Checks that we're currently in an active omitWhen block
-function inActiveOmitWhen() {
-    return !!context.useX().omitted;
+function useForceSkipIfInSkipWhen(testNode) {
+    // We're forcing skipping the pending test
+    // if we're directly within a skipWhen block
+    // This mostly means that we're probably giving
+    // up on this async test intentionally.
+    testNode.skip(useIsExcludedIndividually());
+    return testNode;
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __spreadArray(to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
+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;
+    }
+    static nodeReorderDetected(newNode, prevNode) {
+        return !!IsolateTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
+    }
+    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);
+    }
+    static onNodeReorder(newNode, prevNode) {
+        throwTestOrderError(newNode, prevNode);
+        this.removeAllNextNodesInIsolate();
+        return newNode;
+    }
+    static pickNode(historyNode, currentNode) {
+        const collisionResult = this.handleCollision(currentNode, historyNode);
+        return useVerifyTestRun(currentNode, collisionResult);
+    }
+    static handleNoHistoryNode(testNode) {
+        if (testNode.usesKey()) {
+            return IsolateTest.cast(this.handleIsolateNodeWithKey(testNode));
+        }
+        return testNode;
+    }
 }
-
-function isSameProfileTest(testObject1, testObject2) {
-    return (testObject1.fieldName === testObject2.fieldName &&
-        testObject1.groupName === testObject2.groupName);
+function cancelOverriddenPendingTestOnTestReRun(nextNode, currentNode, prevTestObject) {
+    if (nextNode === currentNode && IsolateTest.is(currentNode)) {
+        cancelOverriddenPendingTest(prevTestObject, currentNode);
+    }
 }
-
-function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
-    if (currentRunTestObject !== prevRunTestObject &&
-        isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
-        prevRunTestObject.isPending()) {
-        prevRunTestObject.cancel();
+function throwTestOrderError(newNode, prevNode) {
+    if (newNode.shouldAllowReorder()) {
+        return;
     }
+    deferThrow(text(ErrorStrings.TESTS_CALLED_IN_DIFFERENT_ORDER, {
+        fieldName: newNode.fieldName,
+        prevName: IsolateTest.is(prevNode) ? prevNode.fieldName : undefined,
+    }));
 }
 
-/**
- * Runs async test.
- */
-function runAsyncTest(testObject) {
-    var asyncTest = testObject.asyncTest, message = testObject.message;
-    if (!isPromise(asyncTest))
-        return;
-    var emit = useBus().emit;
-    var stateRef = useStateRef();
-    var done = context.bind({ stateRef: stateRef }, function () {
-        // invalidating the "produce" cache
-        useRefreshTestObjects();
-        emit(Events.TEST_COMPLETED, testObject);
-    });
-    var fail = context.bind({ stateRef: stateRef }, function (rejectionMessage) {
-        if (testObject.isCanceled()) {
+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;
         }
-        testObject.message = isStringValue(rejectionMessage)
-            ? rejectionMessage
-            : message;
-        testObject.fail();
-        done();
-    });
-    try {
-        asyncTest.then(done, fail);
+        state = target;
     }
-    catch (e) {
-        // We will probably never get here, unless the consumer uses a buggy custom Promise
-        // implementation that behaves differently than the native one, or if they for some
-        fail();
-    }
-}
-
-/**
- * Runs sync tests - or extracts promise.
- */
-function runSyncTest(testObject) {
-    return context.run({ currentTest: testObject }, function () { return testObject.run(); });
 }
 
-/**
- * Registers test, if async - adds to pending array
+var TestStatus;
+(function (TestStatus) {
+    TestStatus["UNTESTED"] = "UNTESTED";
+    TestStatus["SKIPPED"] = "SKIPPED";
+    TestStatus["FAILED"] = "FAILED";
+    TestStatus["WARNING"] = "WARNING";
+    TestStatus["PASSING"] = "PASSING";
+    TestStatus["PENDING"] = "PENDING";
+    TestStatus["CANCELED"] = "CANCELED";
+    TestStatus["OMITTED"] = "OMITTED";
+})(TestStatus || (TestStatus = {}));
+var TestAction;
+(function (TestAction) {
+    TestAction["RESET"] = "RESET";
+})(TestAction || (TestAction = {}));
+function createTestStateMachine() {
+    return StateMachine(machine);
+}
+/* eslint-disable sort-keys */
+const machine = {
+    initial: TestStatus.UNTESTED,
+    states: {
+        [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,
+                (force) => force === true,
+            ],
+            [TestStatus.WARNING]: TestStatus.WARNING,
+        },
+        [TestStatus.CANCELED]: {
+            [TestAction.RESET]: TestStatus.UNTESTED,
+        },
+        [TestStatus.OMITTED]: {
+            [TestAction.RESET]: TestStatus.UNTESTED,
+        },
+    },
+};
+/* eslint-enable sort-keys */
+
+function shouldUseErrorAsMessage(message, error) {
+    // kind of cheating with this safe guard, but it does the job
+    return isUndefined(message) && isStringValue(error);
+}
+
+class IsolateTest extends Isolate {
+    constructor({ fieldName, testFn, message, groupName, key = null, }) {
+        super();
+        this.children = null;
+        this.id = seq();
+        this.severity = TestSeverity.Error;
+        this.stateMachine = createTestStateMachine();
+        this.fieldName = fieldName;
+        this.testFn = testFn;
+        if (groupName) {
+            this.groupName = groupName;
+        }
+        if (message) {
+            this.message = message;
+        }
+        this.setKey(key);
+    }
+    static create(callback, data) {
+        return IsolateTest.cast(super.create(callback, data));
+    }
+    static cast(isolate) {
+        IsolateTest.isX(isolate);
+        return isolate;
+    }
+    get status() {
+        return this.stateMachine.getState();
+    }
+    setStatus(status, payload) {
+        this.stateMachine.transition(status, payload);
+    }
+    run() {
+        let result;
+        try {
+            result = this.testFn();
+        }
+        catch (error) {
+            if (shouldUseErrorAsMessage(this.message, error)) {
+                this.message = error;
+            }
+            result = false;
+        }
+        if (result === false) {
+            this.fail();
+        }
+        return result;
+    }
+    // Selectors
+    warns() {
+        return this.severity === TestSeverity.Warning;
+    }
+    isPending() {
+        return this.statusEquals(TestStatus.PENDING);
+    }
+    isOmitted() {
+        return this.statusEquals(TestStatus.OMITTED);
+    }
+    isUntested() {
+        return this.statusEquals(TestStatus.UNTESTED);
+    }
+    isFailing() {
+        return this.statusEquals(TestStatus.FAILED);
+    }
+    isCanceled() {
+        return this.statusEquals(TestStatus.CANCELED);
+    }
+    isSkipped() {
+        return this.statusEquals(TestStatus.SKIPPED);
+    }
+    isPassing() {
+        return this.statusEquals(TestStatus.PASSING);
+    }
+    isWarning() {
+        return this.statusEquals(TestStatus.WARNING);
+    }
+    hasFailures() {
+        return this.isFailing() || this.isWarning();
+    }
+    isNonActionable() {
+        return this.isSkipped() || this.isOmitted() || this.isCanceled();
+    }
+    isTested() {
+        return this.hasFailures() || this.isPassing();
+    }
+    awaitsResolution() {
+        // Is the test in a state where it can still be run, or complete running
+        // and its final status is indeterminate?
+        return this.isSkipped() || this.isUntested() || this.isPending();
+    }
+    statusEquals(status) {
+        return this.status === status;
+    }
+    // State modifiers
+    setPending() {
+        this.setStatus(TestStatus.PENDING);
+    }
+    fail() {
+        this.setStatus(this.warns() ? TestStatus.WARNING : TestStatus.FAILED);
+    }
+    pass() {
+        this.setStatus(TestStatus.PASSING);
+    }
+    warn() {
+        this.severity = TestSeverity.Warning;
+    }
+    skip(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.
+        this.setStatus(TestStatus.SKIPPED, force);
+    }
+    cancel() {
+        this.setStatus(TestStatus.CANCELED);
+    }
+    reset() {
+        this.stateMachine.transition(TestAction.RESET);
+    }
+    omit() {
+        this.setStatus(TestStatus.OMITTED);
+    }
+    valueOf() {
+        return !this.isFailing();
+    }
+    isAsyncTest() {
+        return isPromise(this.asyncTest);
+    }
+    static is(value) {
+        return value instanceof IsolateTest;
+    }
+    static isX(value) {
+        invariant(this.is(value));
+    }
+}
+IsolateTest.reconciler = IsolateTestReconciler;
+var TestSeverity;
+(function (TestSeverity) {
+    TestSeverity["Error"] = "error";
+    TestSeverity["Warning"] = "warning";
+})(TestSeverity || (TestSeverity = {}));
+
+class TestWalker {
+    static defaultRoot() {
+        return useAvailableSuiteRoot();
+    }
+    static hasNoTests(root = TestWalker.defaultRoot()) {
+        if (!root)
+            return true;
+        return !has(root, IsolateTest.is);
+    }
+    static someIncompleteTests(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return some(root, isolate => {
+            IsolateTest.isX(isolate);
+            return isolate.isPending() && predicate(isolate);
+        }, IsolateTest.is);
+    }
+    static someTests(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return some(root, isolate => {
+            IsolateTest.isX(isolate);
+            return predicate(isolate);
+        }, IsolateTest.is);
+    }
+    static everyTest(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            return false;
+        return every(root, isolate => {
+            IsolateTest.isX(isolate);
+            return predicate(isolate);
+        }, IsolateTest.is);
+    }
+    static walkTests(callback, root = TestWalker.defaultRoot()) {
+        if (!root)
+            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;
+        });
+    }
+    static pluckTests(predicate, root = TestWalker.defaultRoot()) {
+        if (!root)
+            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);
+    }
+}
+
+/**
+ * Runs done callback per field when async tests are finished running.
+ */
+function useRunFieldCallbacks(fieldName) {
+    const [fieldCallbacks] = useFieldCallbacks();
+    if (fieldName &&
+        !TestWalker.hasRemainingTests(fieldName) &&
+        isArray(fieldCallbacks[fieldName])) {
+        callEach(fieldCallbacks[fieldName]);
+    }
+}
+/**
+ * Runs unlabelled done callback when async tests are finished running.
  */
-function registerTest(testObject) {
-    var bus = useBus();
+function useRunDoneCallbacks() {
+    const [doneCallbacks] = useDoneCallbacks();
+    callEach(doneCallbacks);
+}
+
+function useInitVestBus() {
+    const VestBus = bus.createBus();
+    // 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 (testObject.isCanceled()) {
+            return;
+        }
+        useRunFieldCallbacks(testObject.fieldName);
+        if (!TestWalker.hasRemainingTests()) {
+            // When no more tests are running, emit the done event
+            VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+        }
+    });
+    on(Events.TEST_RUN_STARTED, () => {
+        /* Let's just invalidate the suite cache for now */
+    });
+    // Called when all the tests, including async, are done running
+    on(Events.ALL_RUNNING_TESTS_FINISHED, () => {
+        useRunDoneCallbacks();
+    });
+    on(Events.RESET_FIELD, (fieldName) => {
+        TestWalker.resetField(fieldName);
+    });
+    on(Events.SUITE_RUN_STARTED, () => {
+        useResetCallbacks();
+    });
+    on(Events.REMOVE_FIELD, (fieldName) => {
+        TestWalker.removeTestByFieldName(fieldName);
+    });
+    on(Events.RESET_SUITE, () => {
+        useResetSuite();
+    });
+    return VestBus;
+    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);
+        });
+    }
+}
+
+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 : {};
+    }
+}
+
+// @vx-allow use-use
+function include(fieldName) {
+    const inclusion = useInclusion();
+    const exclusion = useExclusion();
+    invariant(isStringValue(fieldName));
+    inclusion[fieldName] = defaultTo(exclusion.tests[fieldName], true);
+    return { when };
+    function when(condition) {
+        const inclusion = useInclusion();
+        const exclusion = useExclusion();
+        // This callback will run as part of the "isExcluded" series of checks
+        inclusion[fieldName] = () => {
+            if (hasOwnProperty(exclusion.tests, fieldName)) {
+                // I suspect this code is technically unreachable because
+                // if there are any skip/only rules applied to the current
+                // field, the "isExcluded" function will have already bailed
+                return defaultTo(exclusion.tests[fieldName], true);
+            }
+            if (isStringValue(condition)) {
+                return Boolean(exclusion.tests[condition]);
+            }
+            return optionalFunctionValue(condition, optionalFunctionValue(useCreateSuiteResult));
+        };
+    }
+}
+
+function useAttemptRunTestObjectByTier(testObject) {
+    useVerifyTestRun(testObject);
+    if (testObject.isNonActionable()) {
+        // TODO: Need to test that this works as expected
+        return;
+    }
+    if (testObject.isUntested()) {
+        useRunTest(testObject);
+    }
+    else if (testObject.isAsyncTest()) {
+        testObject.setPending();
+        useRunAsyncTest(testObject);
+    }
+}
+function runSyncTest(testObject) {
+    return SuiteContext.run({ currentTest: testObject }, () => testObject.run());
+}
+/**
+ * runs test, if async - adds to pending array
+ */
+function useRunTest(testObject) {
+    const VestBus = useVestBus();
     // Run test callback.
     // If a promise is returned, set as async and
     // Move to pending list.
-    var result = runSyncTest(testObject);
+    const result = runSyncTest(testObject);
     try {
         // try catch for safe property access
         // in case object is an enforce chain
         if (isPromise(result)) {
             testObject.asyncTest = result;
             testObject.setPending();
-            runAsyncTest(testObject);
+            useRunAsyncTest(testObject);
         }
         else {
-            bus.emit(Events.TEST_COMPLETED, testObject);
+            onTestCompleted(VestBus, testObject);
         }
     }
     catch (e) {
-        throw new Error("Unexpected error encountered during test registration.\n      Test Object: ".concat(JSON.stringify(testObject), ".\n      Error: ").concat(e, "."));
+        throw new Error(text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
+            testObject: JSON.stringify(testObject),
+            error: e,
+        }));
     }
 }
-
 /**
- * This module serves as the "collision detection" mechanism for Vest.
- * It is used to ensure that tests are not called in a different order than
- * they were called in the previous run.
- * If they are, it will throw a deferred error unless explicitly allowed.
- *
- * For now it seems pretty safe, and it covers most common use cases, but it can
- * be improved in the future both in terms of performance and scenarios it covers.
+ * Runs async test.
  */
-// eslint-disable-next-line max-statements, max-lines-per-function
-function useTestAtCursor(newTestObject) {
-    var testObjects = useTestObjects()[0];
-    var prevTests = testObjects.prev;
-    if (isEmpty(prevTests)) {
-        useSetTestAtCursor(newTestObject);
-        return newTestObject;
-    }
-    var prevTest = useGetTestAtCursor(prevTests);
-    if (!isNullish(newTestObject.key)) {
-        var nextTest_1 = handleKeyTest(newTestObject.key, newTestObject);
-        useSetTestAtCursor(nextTest_1);
-        return nextTest_1;
-    }
-    if (testReorderDetected(prevTest, newTestObject)) {
-        throwTestOrderError(prevTest, newTestObject);
-        removeAllNextTestsInIsolate();
-        // Need to see if this has any effect at all.
-        prevTest = null;
-    }
-    var nextTest = defaultTo(prevTest, newTestObject);
-    useSetTestAtCursor(nextTest);
-    return nextTest;
-}
-function removeAllNextTestsInIsolate() {
-    var cursorAt = useCursor().current();
-    // We actually don't mind mutating the state directly (as can be seen above). There is no harm in it
-    // since we're only touching the "prev" state. The reason we still use the setter function is
-    // to prevent future headaches if we ever do need to rely on prev-state immutability.
-    useSetTests(function (current) {
-        current.splice(cursorAt);
-        return current;
+function useRunAsyncTest(testObject) {
+    const { asyncTest, message } = testObject;
+    if (!isPromise(asyncTest))
+        return;
+    const VestBus = useVestBus();
+    const done = persist(() => {
+        onTestCompleted(VestBus, testObject);
     });
-}
-function useSetTestAtCursor(testObject) {
-    var cursorPath = useCurrentPath();
-    useSetTests(function (tests) {
-        return nestedArray.setValueAtPath(tests, cursorPath, testObject);
+    const fail = persist((rejectionMessage) => {
+        if (testObject.isCanceled()) {
+            return;
+        }
+        testObject.message = isStringValue(rejectionMessage)
+            ? rejectionMessage
+            : message;
+        testObject.fail();
+        done();
     });
+    asyncTest.then(done, fail);
 }
-function useGetTestAtCursor(tests) {
-    var cursorPath = useCurrentPath();
-    return nestedArray.valueAtPath(tests, cursorPath);
+function onTestCompleted(VestBus, testObject) {
+    // Attempts passing if the test is not already failed.
+    // or is not canceled/omitted.
+    testObject.pass();
+    VestBus.emit(Events.TEST_COMPLETED, testObject);
 }
-function testReorderDetected(prevTest, newTest) {
-    return isNotEmpty(prevTest) && !isSameProfileTest(prevTest, newTest);
+
+// @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, useCurrentCursor()].concat(deps);
+        return useGetTestFromCache(dependencies, cacheAction);
+        function cacheAction() {
+            return test(fieldName, msg, testFn);
+        }
+    }
+    return memo;
 }
-function throwTestOrderError(prevTest, newTestObject) {
-    if (shouldAllowReorder()) {
-        return;
+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 (cachedValue.isCanceled()) {
+        // cache hit, but test is canceled
+        cache.invalidate(dependencies);
+        return cache(dependencies, cacheAction);
     }
-    deferThrow("Vest Critical Error: Tests called in different order than previous run.\n    expected: ".concat(prevTest.fieldName, "\n    received: ").concat(newTestObject.fieldName, "\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."));
+    IsolateTest.setNode(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 emit = useEmit();
+    const testObjectInput = { fieldName, groupName, key, message, testFn };
+    // This invalidates the suite cache.
+    emit(Events.TEST_RUN_STARTED);
+    return IsolateTest.create(useAttemptRunTestObjectByTier, testObjectInput);
+}
+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 handleKeyTest(key, newTestObject) {
-    var prevTestByKey = usePrevTestByKey(key);
-    var nextTest = newTestObject;
-    if (prevTestByKey) {
-        nextTest = prevTestByKey;
+
+function getTypedMethods() {
+    return {
+        group,
+        include,
+        omitWhen,
+        only,
+        optional,
+        skip,
+        skipWhen,
+        test,
+    };
+}
+
+function useDeferDoneCallback(doneCallback, fieldName) {
+    const [, setFieldCallbacks] = useFieldCallbacks();
+    const [, setDoneCallbacks] = useDoneCallbacks();
+    if (fieldName) {
+        setFieldCallbacks(fieldCallbacks => assign(fieldCallbacks, {
+            [fieldName]: (fieldCallbacks[fieldName] || []).concat(doneCallback),
+        }));
+        return;
     }
-    useRetainTestKey(key, nextTest);
-    return nextTest;
+    setDoneCallbacks(doneCallbacks => doneCallbacks.concat(doneCallback));
 }
 
-// eslint-disable-next-line max-statements
-function registerPrevRunTest(testObject) {
-    var cursor = useCursor();
-    if (shouldSkipBasedOnMode(testObject)) {
-        testObject.skip();
-        useTestAtCursor(testObject);
-        cursor.next();
-        return testObject;
-    }
-    var prevRunTest = useTestAtCursor(testObject);
-    if (inActiveOmitWhen() || optionalFiedIsApplied(testObject.fieldName)) {
-        prevRunTest.omit();
-        cursor.next();
-        return prevRunTest;
-    }
-    if (isExcluded(testObject)) {
-        // We're forcing skipping the pending test
-        // if we're directly within a skipWhen block
-        // This mostly means that we're probably giving
-        // up on this async test intentionally.
-        prevRunTest.skip(isExcludedIndividually());
-        cursor.next();
-        return prevRunTest;
-    }
-    cancelOverriddenPendingTest(prevRunTest, testObject);
-    useSetTestAtCursor(testObject);
-    registerTestObjectByTier(testObject);
-    cursor.next();
-    return testObject;
+/**
+ * DONE is here and not in its own module to prevent circular dependency issues.
+ */
+function shouldSkipDoneRegistration(callback, fieldName, output) {
+    var _a;
+    // If we do not have any test runs for the current field
+    return !!(!isFunction(callback) ||
+        (fieldName && numberEquals((_a = output.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount, 0)));
 }
-function registerTestObjectByTier(testObject) {
-    if (testObject.isUntested()) {
-        registerTest(testObject);
+
+function useSuiteRunResult() {
+    return assign({}, useCreateSuiteResult(), {
+        done: persist(done),
+    });
+}
+/**
+ * Registers done callbacks.
+ * @register {Object} Vest output object.
+ */
+// @vx-allow use-use
+function done(...args) {
+    const [callback, fieldName] = args.reverse();
+    const output = useSuiteRunResult();
+    if (shouldSkipDoneRegistration(callback, fieldName, output)) {
+        return output;
     }
-    else if (isPromise(testObject.asyncTest)) {
-        testObject.setPending();
-        runAsyncTest(testObject);
+    const useDoneCallback = () => callback(useCreateSuiteResult());
+    if (!TestWalker.hasRemainingTests(fieldName)) {
+        useDoneCallback();
+        return output;
     }
+    useDeferDoneCallback(useDoneCallback, fieldName);
+    return output;
 }
 
-/* eslint-disable jest/valid-title */
-function bindTestMemo(test) {
-    var cache = cache$2(10); // arbitrary cache size
-    // eslint-disable-next-line max-statements
-    function memo(fieldName) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
-        var cursorAt = useCursor().current();
-        var _a = args.reverse(), deps = _a[0], testFn = _a[1], msg = _a[2];
-        // Implicit dependency for more specificity
-        var dependencies = [useSuiteId(), fieldName, cursorAt].concat(deps);
-        var cached = cache.get(dependencies);
-        if (isNull(cached)) {
-            // cache miss
-            return cache(dependencies, function () { return test(fieldName, msg, testFn); });
-        }
-        if (cached[1].isCanceled()) {
-            // cache hit, but test is canceled
-            cache.invalidate(dependencies);
-            return cache(dependencies, function () { return test(fieldName, msg, testFn); });
-        }
-        return registerPrevRunTest(cached[1]);
-    }
-    return memo;
+function validateSuiteCallback(suiteCallback) {
+    invariant(isFunction(suiteCallback), ErrorStrings.SUITE_MUST_BE_INITIALIZED_WITH_FUNCTION);
 }
 
-function testBase(fieldName) {
-    var args = [];
-    for (var _i = 1; _i < arguments.length; _i++) {
-        args[_i - 1] = arguments[_i];
-    }
-    var _a = (isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
-    invariant(isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
-    invariant(isFunction(testFn), incompatibleParamsError('Test callback', 'function'));
-    var context$1 = context.useX();
-    var testObject = new VestTest(fieldName, testFn, {
-        message: message,
-        groupName: context$1.groupName,
-        key: key
+// @vx-allow use-use
+function createSuite(...args) {
+    const [suiteCallback, suiteName] = args.reverse();
+    validateSuiteCallback(suiteCallback);
+    // Create a stateRef for the suite
+    // It holds the suite's persisted values that may remain between runs.
+    const stateRef = useCreateVestState({ suiteName });
+    function suite(...args) {
+        return SuiteContext.run({}, () => {
+            // eslint-disable-next-line vest-internal/use-use
+            const emit = 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
+    // will be bound to the suite's stateRef and be able to access it.
+    return PersistedContext.run(stateRef, () => {
+        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()));
     });
-    return registerPrevRunTest(testObject);
 }
+function useRunSuiteCallback(suiteCallback, ...args) {
+    return () => {
+        suiteCallback(...args);
+        return useSuiteRunResult();
+    };
+}
+
+class IsolateEach extends Isolate {
+    constructor() {
+        super(...arguments);
+        this.allowReorder = true;
+    }
+}
+
 /**
- * Represents a single case in a validation suite.
+ * Iterates over an array of items, allowing to run tests individually per item.
+ *
+ * Requires setting a "key" property on each item tested.
  *
  * @example
  *
- * test("username", "Username is required", () => {
- *  enforce(data.username).isNotBlank();
- * });
+ * each(itemsArray, (item) => {
+ *  test(item.name, 'Item value must not be empty', () => {
+ *    enforce(item.value).isNotEmpty();
+ *  }, item.id)
+ * })
  */
-var test = assign(testBase, {
-    memo: bindTestMemo(testBase)
-});
-function incompatibleParamsError(name, expected) {
-    return "Incompatible params passed to test function. ".concat(name, " must be a ").concat(expected);
+function each(list, callback) {
+    invariant(isFunction(callback), ErrorStrings.EACH_CALLBACK_MUST_BE_A_FUNCTION);
+    IsolateEach.create(() => {
+        list.forEach((arg, index) => {
+            callback(arg, index);
+        });
+    });
+}
+
+function group(groupName, callback) {
+    return Isolate.create(() => {
+        SuiteContext.run({ groupName }, callback);
+    });
 }
 
-var ERROR_OUTSIDE_OF_TEST = "warn hook called outside of a test callback. It won't have an effect."
-    ;
+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.
  */
+// @vx-allow use-use
 function warn() {
-    var ctx = context.useX('warn ' + ERROR_HOOK_CALLED_OUTSIDE);
-    invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
-    ctx.currentTest.warn();
+    const currentTest = useCurrentTest(ErrorStrings.HOOK_CALLED_OUTSIDE);
+    invariant(currentTest, ERROR_OUTSIDE_OF_TEST);
+    currentTest.warn();
 }
 
-var VERSION = "5.0.0-dev-781e21";
-
-export { VERSION, context, create, each, eager, group, include, omitWhen, only, optional, skip, skipWhen, suiteSelectors, test, warn };
+export { Modes, createSuite as create, each, group, include, mode, omitWhen, only, optional, skip, skipWhen, staticSuite, suiteSelectors, test, warn };