vest 5.0.0-dev-040354 → 5.0.0-dev-9c596e

package/dist/umd/vest.development.js

@@ -1,442 +1,285 @@
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('n4s'), require('vest-utils'), require('context')) :
   typeof define === 'function' && define.amd ? define(['exports', 'n4s', 'vest-utils', 'context'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}, global.n4s, global['vest-utils'], global.context));
-}(this, (function (exports, n4s, vestUtils, context$1) { 'use strict';
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vest = {}, global.n4s, global["vest-utils"], global.context));
+})(this, (function (exports, n4s, vestUtils, context) { 'use strict';
 
-  function shouldUseErrorAsMessage(message, error) {
-      // kind of cheating with this safe guard, but it does the job
-      return vestUtils.isUndefined(message) && vestUtils.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 (vestUtils.isNullish(startNode.children)) {
+          return;
       }
+      let broke = false;
+      for (const isolate of startNode.children) {
+          if (broke) {
+              return;
+          }
+          if (vestUtils.isNullish(visitOnly) || vestUtils.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 = context$1.createCascade(function (ctxRef, parentContext) {
-      return parentContext
-          ? null
-          : vestUtils.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 vestUtils.assign(prev, (_a = {},
-              _a[fieldName] = vestUtils.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: vestUtils.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 = vestUtils.cache();
-  function useTestsFlat() {
-      var current = useTestObjects()[0].current;
-      return flatCache([current], function () { return vestUtils.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 = vestUtils.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 (vestUtils.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);
+          vestUtils.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) {
+          vestUtils.invariant(node.usesKey());
+          const prevNodeByKey = useHistoryKey(node.key);
+          let nextNode = node;
+          if (!vestUtils.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 vestUtils.isNotNullish(this.key);
+      }
+      addChild(child) {
+          vestUtils.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 (vestUtils.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, vestUtils.optionalFunctionValue(initialState, prevState));
-          return function useStateKey() {
-              return [
-                  current()[key],
-                  function (nextState) {
-                      return set(key, vestUtils.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;
       }
-      function set(index, value) {
-          var prevValue = state.references[index];
-          state.references[index] = value;
-          var _a = registrations[index], onUpdate = _a[1];
-          if (vestUtils.isFunction(onUpdate)) {
-              onUpdate(value, prevValue);
+      shouldAllowReorder() {
+          var _a;
+          return (_a = closestExists(this, node => node.allowReorder)) !== null && _a !== void 0 ? _a : false;
+      }
+      get rootNode() {
+          var _a;
+          return (_a = closest(this, node => vestUtils.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 (vestUtils.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;
+  function nonMatchingFieldName(WithFieldName, fieldName) {
+      return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
   }
-  /**
-   * @returns {number[]} The current cursor path of the isolate tree
-   */
-  function useCurrentPath() {
-      var isolate = useIsolate();
-      return isolate.path.concat(isolate.cursor.current());
-  }
-  /**
-   * @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 vestUtils.asArray(vestUtils.nestedArray.getCurrent(prev, useCurrentPath())).reduce(function (prevKeys, testObject) {
-          if (!(testObject instanceof VestTest)) {
-              return prevKeys;
-          }
-          if (vestUtils.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 (vestUtils.isNullish(current[key])) {
-          current[key] = testObject;
-      }
-      else {
-          vestUtils.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;
-      vestUtils.invariant(vestUtils.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 vestUtils.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;
@@ -455,14 +298,7 @@
           : SeverityCount.WARN_COUNT;
   }
 
-  function nonMatchingFieldName(testObject, fieldName) {
-      return !!fieldName && !matchingFieldName(testObject, fieldName);
-  }
-  function matchingFieldName(testObject, fieldName) {
-      return !!(fieldName && testObject.fieldName === fieldName);
-  }
-
-  var nonMatchingGroupName = vestUtils.bindNot(matchingGroupName);
+  const nonMatchingGroupName = vestUtils.bindNot(matchingGroupName);
   function matchingGroupName(testObject, groupName) {
       return testObject.groupName === groupName;
   }
@@ -482,14 +318,12 @@
       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;
           }
@@ -512,137 +346,179 @@
       return true;
   }
 
+  exports.Modes = void 0;
+  (function (Modes) {
+      Modes["ALL"] = "ALL";
+      Modes["EAGER"] = "EAGER";
+  })(exports.Modes || (exports.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 (vestUtils.isArray(optionals) || vestUtils.isStringValue(optionals)) {
-          vestUtils.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: vestUtils.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(exports.Modes.EAGER);
+  }
+  function useShouldSkipBasedOnMode(testObject) {
+      return useIsEager() && hasErrorsByTestObjects(testObject.fieldName);
+  }
+
+  const SuiteContext = context.createCascade((ctxRef, parentContext) => {
+      if (parentContext) {
+          return null;
+      }
+      return vestUtils.assign({
+          exclusion: {
+              tests: {},
+              groups: {},
+          },
+          inclusion: {},
+          mode: vestUtils.tinyState.createTinyState(exports.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 = vestUtils.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 (vestUtils.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 vestUtils.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 vestUtils.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;
       }
@@ -655,102 +531,110 @@
        * 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 = vestUtils.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);
-      // If `valid` is false to begin with, keep it that way. Otherwise, assess.
-      tests[testObject.fieldName].valid =
-          tests[testObject.fieldName].valid === false
+  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.
+      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 = vestUtils.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 vestUtils.assign(baseStats(), {
+      return vestUtils.assign(new SummaryBase(), {
           errors: [],
-          warnings: []
+          warnings: [],
+          valid: true,
       });
   }
 
@@ -765,9 +649,9 @@
       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 (vestUtils.isPositive(testGroup[field][countKey])) {
               // We will probably never get to the fallback array
               // leaving it just in case the implementation changes
@@ -779,17 +663,19 @@
 
   // 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
@@ -798,15 +684,15 @@
           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;
               }
           }
@@ -827,9 +713,15 @@
       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);
       }
@@ -837,8 +729,6 @@
           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);
   }
@@ -856,14 +746,14 @@
   // 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 vestUtils.isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
       }
-      for (var field in group) {
+      for (const field in group) {
           if (vestUtils.isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
               return true;
           }
@@ -874,309 +764,28 @@
   // 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 vestUtils.isPositive(failureCount);
   }
-
-  var cache$1 = vestUtils.cache(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 vestUtils.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 (vestUtils.isEmpty(allIncomplete)) {
-          return false;
-      }
-      if (fieldName) {
-          return allIncomplete.some(function (testObject) {
-              return matchingFieldName(testObject, fieldName);
-          });
-      }
-      return true;
-  }
-
-  var cache = vestUtils.cache(20);
-  function produceFullResult() {
-      var testObjects = useTestsFlat();
-      var ctxRef = { stateRef: useStateRef() };
-      return cache([testObjects], context.bind(ctxRef, function () {
-          return vestUtils.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 !!(!vestUtils.isFunction(callback) ||
-          (fieldName && vestUtils.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 (vestUtils.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 (vestUtils.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] = vestUtils.optionalFunctionValue(optionalConfig.rule);
-              verifyAndOmit(testObject);
-          }
-      }
-  }
-
-  /**
-   * Removes test object from suite state
-   */
-  function removeTestFromState (testObject) {
-      useSetTests(function (tests) {
-          return vestUtils.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) &&
-          vestUtils.isArray(fieldCallbacks[fieldName])) {
-          vestUtils.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;
-      vestUtils.callEach(doneCallbacks);
-  }
-
-  // eslint-disable-next-line max-lines-per-function
-  function initBus() {
-      var vestBus = vestUtils.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();
-      vestUtils.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];
-      vestUtils.invariant(vestUtils.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: vestUtils.seq(), suiteName: suiteName });
-      // Create base context reference. All hooks will derive their data from this
-      var ctxRef = { stateRef: stateRef, bus: bus };
-      var suite = vestUtils.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) {
-      vestUtils.invariant(vestUtils.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(() => vestUtils.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.
    *
@@ -1186,20 +795,21 @@
    *  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.
-                  vestUtils.optionalFunctionValue(conditional, vestUtils.optionalFunctionValue(produceSuiteResult))
-          }, function () { return callback(); });
+                  vestUtils.optionalFunctionValue(condition, vestUtils.optionalFunctionValue(useCreateSuiteResult)),
+          }, callback);
       });
   }
-  function isExcludedIndividually() {
-      return !!context.useX().skipped;
+  function useIsExcludedIndividually() {
+      return useSkipped();
   }
 
   /**
@@ -1209,11 +819,12 @@
    *
    * 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
@@ -1222,31 +833,31 @@
    *
    * 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
           }
@@ -1259,7 +870,7 @@
               return keyTests[fieldName] === false;
           }
       }
-      if (isTopLevelWhenThereIsAnIncludedGroup(groupName)) {
+      if (useIsTopLevelWhenThereIsAnIncludedGroup(groupName)) {
           return true;
       }
       // if field is only'ed
@@ -1278,11 +889,10 @@
   /**
    * 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 = vestUtils.hasOwnProperty(keyGroups, groupName);
+  function useIsGroupExcluded(groupName) {
+      const exclusion = useExclusion();
+      const keyGroups = exclusion.groups;
+      const groupPresent = vestUtils.hasOwnProperty(keyGroups, groupName);
       // When group is either only'ed or skipped
       if (groupPresent) {
           // Return true if group is skipped and false if only'ed
@@ -1290,29 +900,28 @@
       }
       // 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;
       }
-      vestUtils.asArray(item).forEach(function (itemName) {
+      vestUtils.asArray(item).forEach((itemName) => {
           if (!vestUtils.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
           }
@@ -1320,17 +929,16 @@
       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;
           }
@@ -1339,422 +947,1012 @@
   }
 
   /**
-   * 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) {
-      vestUtils.invariant(vestUtils.isStringValue(groupName), groupErrorMsg('name must be a string'));
-      vestUtils.invariant(vestUtils.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() ||
+                  vestUtils.optionalFunctionValue(conditional, vestUtils.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;
-      vestUtils.invariant(vestUtils.isStringValue(fieldName));
-      inclusion[fieldName] = vestUtils.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 (vestUtils.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 vestUtils.defaultTo(exclusion.tests[fieldName], true);
-              }
-              if (vestUtils.isStringValue(condition)) {
-                  return Boolean(exclusion.tests[condition]);
-              }
-              return vestUtils.optionalFunctionValue(condition, vestUtils.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() ||
-                  vestUtils.optionalFunctionValue(conditional, vestUtils.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 (vestUtils.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;
       }
+      vestUtils.deferThrow(vestUtils.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 (!vestUtils.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 = vestUtils.isStringValue(rejectionMessage)
-              ? rejectionMessage
-              : message;
-          testObject.fail();
-          done();
-      });
-      try {
-          asyncTest.then(done, fail);
-      }
-      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();
+          state = target;
       }
   }
 
-  /**
-   * 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
-   */
-  function registerTest(testObject) {
-      var bus = useBus();
-      // Run test callback.
+  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 vestUtils.isUndefined(message) && vestUtils.isStringValue(error);
+  }
+
+  class IsolateTest extends Isolate {
+      constructor({ fieldName, testFn, message, groupName, key = null, }) {
+          super();
+          this.children = null;
+          this.id = vestUtils.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 vestUtils.isPromise(this.asyncTest);
+      }
+      static is(value) {
+          return value instanceof IsolateTest;
+      }
+      static isX(value) {
+          vestUtils.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) &&
+          vestUtils.isArray(fieldCallbacks[fieldName])) {
+          vestUtils.callEach(fieldCallbacks[fieldName]);
+      }
+  }
+  /**
+   * Runs unlabelled done callback when async tests are finished running.
+   */
+  function useRunDoneCallbacks() {
+      const [doneCallbacks] = useDoneCallbacks();
+      vestUtils.callEach(doneCallbacks);
+  }
+
+  function useInitVestBus() {
+      const VestBus = vestUtils.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 = vestUtils.cache();
+  const PersistedContext = context.createCascade((vestState, parentContext) => {
+      if (parentContext) {
+          return null;
+      }
+      vestUtils.invariant(vestState.historyRoot);
+      const [historyRootNode] = vestState.historyRoot();
+      const ctxRef = {};
+      vestUtils.assign(ctxRef, {
+          historyNode: historyRootNode,
+          runtimeNode: null,
+          runtimeRoot: null,
+      }, vestState);
+      return ctxRef;
+  });
+  function useCreateVestState({ suiteName, } = {}) {
+      const stateRef = {
+          VestBus: useInitVestBus(),
+          doneCallbacks: vestUtils.tinyState.createTinyState(() => []),
+          fieldCallbacks: vestUtils.tinyState.createTinyState(() => ({})),
+          historyRoot: vestUtils.tinyState.createTinyState(null),
+          suiteId: vestUtils.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 (vestUtils.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();
+      vestUtils.invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
+      currentIsolate.addChild(child);
+  }
+  function useSetIsolateKey(key, value) {
+      if (!key) {
+          return;
+      }
+      const currentIsolate = useIsolate();
+      vestUtils.invariant(currentIsolate, ErrorStrings.NO_ACTIVE_ISOLATE);
+      if (vestUtils.isNullish(currentIsolate.keys[key])) {
+          currentIsolate.keys[key] = value;
+          return;
+      }
+      vestUtils.deferThrow(vestUtils.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 (vestUtils.isArray(optionals) || vestUtils.isStringValue(optionals)) {
+          vestUtils.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: vestUtils.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();
+      vestUtils.invariant(vestUtils.isStringValue(fieldName));
+      inclusion[fieldName] = vestUtils.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 (vestUtils.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 vestUtils.defaultTo(exclusion.tests[fieldName], true);
+              }
+              if (vestUtils.isStringValue(condition)) {
+                  return Boolean(exclusion.tests[condition]);
+              }
+              return vestUtils.optionalFunctionValue(condition, vestUtils.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 (vestUtils.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(vestUtils.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 (vestUtils.isEmpty(prevTests)) {
-          useSetTestAtCursor(newTestObject);
-          return newTestObject;
-      }
-      var prevTest = useGetTestAtCursor(prevTests);
-      if (!vestUtils.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 = vestUtils.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 (!vestUtils.isPromise(asyncTest))
+          return;
+      const VestBus = useVestBus();
+      const done = persist(() => {
+          onTestCompleted(VestBus, testObject);
       });
-  }
-  function useSetTestAtCursor(testObject) {
-      var cursorPath = useCurrentPath();
-      useSetTests(function (tests) {
-          return vestUtils.nestedArray.setValueAtPath(tests, cursorPath, testObject);
+      const fail = persist((rejectionMessage) => {
+          if (testObject.isCanceled()) {
+              return;
+          }
+          testObject.message = vestUtils.isStringValue(rejectionMessage)
+              ? rejectionMessage
+              : message;
+          testObject.fail();
+          done();
       });
+      asyncTest.then(done, fail);
   }
-  function useGetTestAtCursor(tests) {
-      var cursorPath = useCurrentPath();
-      return vestUtils.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 vestUtils.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 (vestUtils.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);
       }
-      vestUtils.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] = (vestUtils.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 = vestUtils.assign(vestTest, {
+      memo: wrapTestMemo(vestTest),
+  });
+  function validateTestParams(fieldName, testFn) {
+      const fnName = 'test';
+      vestUtils.invariant(vestUtils.isStringValue(fieldName), vestUtils.text(ErrorStrings.INVALID_PARAM_PASSED_TO_FUNCTION, {
+          fn_name: fnName,
+          param: 'fieldName',
+          expected: 'string',
+      }));
+      vestUtils.invariant(vestUtils.isFunction(testFn), vestUtils.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 => vestUtils.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 !!(!vestUtils.isFunction(callback) ||
+          (fieldName && vestUtils.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 vestUtils.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 (vestUtils.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 = vestUtils.cache(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 (vestUtils.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) {
+      vestUtils.invariant(vestUtils.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 = (vestUtils.isFunction(args[1]) ? args : __spreadArray([undefined], args, true)), message = _a[0], testFn = _a[1], key = _a[2];
-      vestUtils.invariant(vestUtils.isStringValue(fieldName), incompatibleParamsError('fieldName', 'string'));
-      vestUtils.invariant(vestUtils.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 vestUtils.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 = vestUtils.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) {
+      vestUtils.invariant(vestUtils.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 vestUtils.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);
-      vestUtils.invariant(ctx.currentTest, ERROR_OUTSIDE_OF_TEST);
-      ctx.currentTest.warn();
+      const currentTest = useCurrentTest(ErrorStrings.HOOK_CALLED_OUTSIDE);
+      vestUtils.invariant(currentTest, ERROR_OUTSIDE_OF_TEST);
+      currentTest.warn();
   }
 
-  var VERSION = "5.0.0-dev-040354";
-
   Object.defineProperty(exports, 'enforce', {
     enumerable: true,
-    get: function () {
-      return n4s.enforce;
-    }
+    get: function () { return n4s.enforce; }
   });
-  exports.VERSION = VERSION;
-  exports.context = context;
-  exports.create = create;
+  exports.create = createSuite;
   exports.each = each;
-  exports.eager = eager;
   exports.group = group;
   exports.include = include;
+  exports.mode = mode;
   exports.omitWhen = omitWhen;
   exports.only = only;
   exports.optional = optional;
   exports.skip = skip;
   exports.skipWhen = skipWhen;
+  exports.staticSuite = staticSuite;
   exports.suiteSelectors = suiteSelectors;
   exports.test = test;
   exports.warn = warn;
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));