vest 5.2.8 → 5.2.10

package/dist/umd/vest.development.js

@@ -139,18 +139,85 @@
       return ((_b = (_a = SuiteOptionalFields.getOptionalField(root, fieldName)) === null || _a === void 0 ? void 0 : _a.applied) !== null && _b !== void 0 ? _b : false);
   }
 
-  var Events;
-  (function (Events) {
-      Events["TEST_RUN_STARTED"] = "test_run_started";
-      Events["TEST_COMPLETED"] = "test_completed";
-      Events["ALL_RUNNING_TESTS_FINISHED"] = "all_running_tests_finished";
-      Events["REMOVE_FIELD"] = "remove_field";
-      Events["RESET_FIELD"] = "reset_field";
-      Events["RESET_SUITE"] = "reset_suite";
-      Events["SUITE_RUN_STARTED"] = "suite_run_started";
-      Events["SUITE_CALLBACK_RUN_FINISHED"] = "SUITE_CALLBACK_RUN_FINISHED";
-      Events["DONE_TEST_OMISSION_PASS"] = "DONE_TEST_OMISSION_PASS";
-  })(Events || (Events = {}));
+  var FocusModes;
+  (function (FocusModes) {
+      FocusModes[FocusModes["ONLY"] = 0] = "ONLY";
+      FocusModes[FocusModes["SKIP"] = 1] = "SKIP";
+  })(FocusModes || (FocusModes = {}));
+
+  function IsolateFocused(focusMode, match) {
+      return vestjsRuntime.Isolate.create(VestIsolateType.Focused, vestUtils.noop, {
+          focusMode,
+          match: vestUtils.asArray(match).filter(vestUtils.isStringValue),
+          matchAll: match === true,
+      });
+  }
+  class FocusSelectors {
+      static isSkipFocused(focus, fieldName) {
+          return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.SKIP &&
+              (hasFocus(focus, fieldName) || focus.data.matchAll === true));
+      }
+      static isOnlyFocused(focus, fieldName) {
+          return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.ONLY && hasFocus(focus, fieldName));
+      }
+      static isIsolateFocused(isolate) {
+          return vestjsRuntime.IsolateSelectors.isIsolateType(isolate, VestIsolateType.Focused);
+      }
+  }
+  /**
+   * Adds a field or a list of fields into the inclusion list
+   *
+   * @example
+   *
+   * only('username');
+   */
+  // @vx-allow use-use
+  function only(match) {
+      return IsolateFocused(FocusModes.ONLY, defaultMatch(match));
+  }
+  /**
+   * Adds a field or a list of fields into the exclusion list
+   *
+   * @example
+   *
+   * skip('username');
+   */
+  // @vx-allow use-use
+  function skip(match) {
+      return IsolateFocused(FocusModes.SKIP, defaultMatch(match));
+  }
+  function defaultMatch(match) {
+      return match === false ? [] : match;
+  }
+  function hasFocus(focus, fieldName) {
+      var _a, _b;
+      return (vestUtils.isNotEmpty(focus === null || focus === void 0 ? void 0 : focus.data.match) &&
+          (fieldName ? (_b = (_a = focus === null || focus === void 0 ? void 0 : focus.data.match) === null || _a === void 0 ? void 0 : _a.includes(fieldName)) !== null && _b !== void 0 ? _b : true : true));
+  }
+
+  function group(...args) {
+      const [callback, groupName] = args.reverse();
+      return vestjsRuntime.Isolate.create(VestIsolateType.Group, () => {
+          return SuiteContext.run(Object.assign({}, (groupName && { groupName })), callback);
+      });
+  }
+
+  var ErrorStrings;
+  (function (ErrorStrings) {
+      ErrorStrings["HOOK_CALLED_OUTSIDE"] = "hook called outside of a running suite.";
+      ErrorStrings["EXPECTED_VEST_TEST"] = "Expected value to be an instance of IsolateTest";
+      ErrorStrings["FIELD_NAME_REQUIRED"] = "Field name must be passed";
+      ErrorStrings["SUITE_MUST_BE_INITIALIZED_WITH_FUNCTION"] = "Suite must be initialized with a function";
+      ErrorStrings["PROMISIFY_REQUIRE_FUNCTION"] = "Vest.Promisify must be called with a function";
+      ErrorStrings["PARSER_EXPECT_RESULT_OBJECT"] = "Vest parser: expected argument at position 0 to be Vest's result object.";
+      ErrorStrings["WARN_MUST_BE_CALLED_FROM_TEST"] = "Warn must be called from within the body of a test function";
+      ErrorStrings["EACH_CALLBACK_MUST_BE_A_FUNCTION"] = "Each must be called with a function";
+      ErrorStrings["INVALID_PARAM_PASSED_TO_FUNCTION"] = "Incompatible params passed to {fn_name} function. \"{param}\" must be of type {expected}";
+      ErrorStrings["TESTS_CALLED_IN_DIFFERENT_ORDER"] = "Vest Critical Error: Tests called in different order than previous run.\n    expected: {fieldName}\n    received: {prevName}\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.";
+      ErrorStrings["UNEXPECTED_TEST_REGISTRATION_ERROR"] = "Unexpected error encountered during test registration.\n      Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.\n      Error: {error}.";
+      ErrorStrings["UNEXPECTED_TEST_RUN_ERROR"] = "Unexpected error encountered during test run. Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.";
+      ErrorStrings["INCLUDE_SELF"] = "Trying to call include.when on the same field.";
+  })(ErrorStrings || (ErrorStrings = {}));
 
   const suiteResultCache = vestUtils.cache();
   function useCreateVestState({ suiteName, VestReconciler, }) {
@@ -201,124 +268,6 @@
       useExpireSuiteResultCache();
   }
 
-  const CommonStates = {
-      PENDING: 'PENDING',
-      INITIAL: 'INITIAL',
-  };
-  const State = {
-      [CommonStates.PENDING]: CommonStates.PENDING,
-      [CommonStates.INITIAL]: CommonStates.INITIAL,
-      DONE: 'DONE',
-  };
-  const machine$1 = {
-      initial: State.INITIAL,
-      states: {
-          [State.DONE]: {},
-          [State.INITIAL]: {
-              [State.PENDING]: State.PENDING,
-              [State.DONE]: State.DONE,
-          },
-          [State.PENDING]: {
-              [State.DONE]: State.DONE,
-          },
-      },
-  };
-  function transition(from, to) {
-      return CommonStateMachine.staticTransition(from !== null && from !== void 0 ? from : State.INITIAL, to);
-  }
-  function setDone(isolate) {
-      isolate.status = transition(isolate.status, State.DONE);
-  }
-  function setPending(isolate) {
-      isolate.status = transition(isolate.status, State.PENDING);
-  }
-  const CommonStateMachine = vestUtils.StateMachine(machine$1);
-
-  class VestIsolate {
-      static getStatus(isolate) {
-          var _a;
-          return (_a = isolate.status) !== null && _a !== void 0 ? _a : CommonStates.INITIAL;
-      }
-      static setStatus(isolate, status, payload) {
-          isolate.status = this.stateMachine.staticTransition(VestIsolate.getStatus(isolate), status, payload);
-      }
-      static statusEquals(isolate, status) {
-          return VestIsolate.getStatus(isolate) === status;
-      }
-      static setPending(isolate) {
-          this.setStatus(isolate, CommonStates.PENDING);
-      }
-      static isPending(isolate) {
-          return VestIsolate.statusEquals(isolate, CommonStates.PENDING);
-      }
-  }
-  VestIsolate.stateMachine = CommonStateMachine;
-
-  var ErrorStrings;
-  (function (ErrorStrings) {
-      ErrorStrings["HOOK_CALLED_OUTSIDE"] = "hook called outside of a running suite.";
-      ErrorStrings["EXPECTED_VEST_TEST"] = "Expected value to be an instance of IsolateTest";
-      ErrorStrings["FIELD_NAME_REQUIRED"] = "Field name must be passed";
-      ErrorStrings["SUITE_MUST_BE_INITIALIZED_WITH_FUNCTION"] = "Suite must be initialized with a function";
-      ErrorStrings["PROMISIFY_REQUIRE_FUNCTION"] = "Vest.Promisify must be called with a function";
-      ErrorStrings["PARSER_EXPECT_RESULT_OBJECT"] = "Vest parser: expected argument at position 0 to be Vest's result object.";
-      ErrorStrings["WARN_MUST_BE_CALLED_FROM_TEST"] = "Warn must be called from within the body of a test function";
-      ErrorStrings["EACH_CALLBACK_MUST_BE_A_FUNCTION"] = "Each must be called with a function";
-      ErrorStrings["INVALID_PARAM_PASSED_TO_FUNCTION"] = "Incompatible params passed to {fn_name} function. \"{param}\" must be of type {expected}";
-      ErrorStrings["TESTS_CALLED_IN_DIFFERENT_ORDER"] = "Vest Critical Error: Tests called in different order than previous run.\n    expected: {fieldName}\n    received: {prevName}\n    This can happen on one of two reasons:\n    1. You're using if/else statements to conditionally select tests. Instead, use \"skipWhen\".\n    2. You are iterating over a list of tests, and their order changed. Use \"each\" and a custom key prop so that Vest retains their state.";
-      ErrorStrings["UNEXPECTED_TEST_REGISTRATION_ERROR"] = "Unexpected error encountered during test registration.\n      Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.\n      Error: {error}.";
-      ErrorStrings["UNEXPECTED_TEST_RUN_ERROR"] = "Unexpected error encountered during test run. Please report this issue to Vest's Github repository.\n      Test Object: {testObject}.";
-      ErrorStrings["INCLUDE_SELF"] = "Trying to call include.when on the same field.";
-  })(ErrorStrings || (ErrorStrings = {}));
-
-  const TestStatus = {
-      [CommonStates.PENDING]: CommonStates.PENDING,
-      CANCELED: 'CANCELED',
-      FAILED: 'FAILED',
-      OMITTED: 'OMITTED',
-      PASSING: 'PASSING',
-      SKIPPED: 'SKIPPED',
-      UNTESTED: 'UNTESTED',
-      WARNING: 'WARNING',
-  };
-  const TestAction = {
-      RESET: 'RESET',
-  };
-  const machine = {
-      initial: TestStatus.UNTESTED,
-      states: {
-          '*': {
-              [TestStatus.OMITTED]: TestStatus.OMITTED,
-              [TestAction.RESET]: TestStatus.UNTESTED,
-          },
-          [TestStatus.UNTESTED]: {
-              [TestStatus.CANCELED]: TestStatus.CANCELED,
-              [TestStatus.FAILED]: TestStatus.FAILED,
-              [TestStatus.PASSING]: TestStatus.PASSING,
-              [TestStatus.PENDING]: TestStatus.PENDING,
-              [TestStatus.SKIPPED]: TestStatus.SKIPPED,
-              [TestStatus.WARNING]: TestStatus.WARNING,
-          },
-          [TestStatus.PENDING]: {
-              [TestStatus.CANCELED]: TestStatus.CANCELED,
-              [TestStatus.FAILED]: TestStatus.FAILED,
-              [TestStatus.PASSING]: TestStatus.PASSING,
-              [TestStatus.SKIPPED]: [
-                  TestStatus.SKIPPED,
-                  (force) => force === true,
-              ],
-              [TestStatus.WARNING]: TestStatus.WARNING,
-          },
-          [TestStatus.SKIPPED]: {},
-          [TestStatus.FAILED]: {},
-          [TestStatus.WARNING]: {},
-          [TestStatus.PASSING]: {},
-          [TestStatus.CANCELED]: {},
-          [TestStatus.OMITTED]: {},
-      },
-  };
-  const IsolateTestStateMachine = vestUtils.StateMachine(machine);
-
   var Severity;
   (function (Severity) {
       Severity["WARNINGS"] = "warnings";
@@ -340,161 +289,449 @@
       TestSeverity["Warning"] = "warning";
   })(TestSeverity || (TestSeverity = {}));
 
-  class VestTest extends VestIsolate {
-      // Read
-      static getData(test) {
-          vestUtils.invariant(test.data);
-          return test.data;
-      }
-      static is(isolate) {
-          return vestjsRuntime.IsolateSelectors.isIsolateType(isolate, VestIsolateType.Test);
-      }
-      static isX(isolate) {
-          vestUtils.invariant(VestTest.is(isolate), ErrorStrings.EXPECTED_VEST_TEST);
+  // calls collectAll or getByFieldName depending on whether fieldName is provided
+  function gatherFailures(testGroup, severityKey, fieldName) {
+      return fieldName
+          ? getByFieldName(testGroup, severityKey, fieldName)
+          : collectAll(testGroup, severityKey);
+  }
+  function getByFieldName(testGroup, severityKey, fieldName) {
+      var _a;
+      return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
+  }
+  function collectAll(testGroup, severityKey) {
+      const output = {};
+      const countKey = countKeyBySeverity(severityKey);
+      for (const field in testGroup) {
+          if (vestUtils.isPositive(testGroup[field][countKey])) {
+              // We will probably never get to the fallback array
+              // leaving it just in case the implementation changes
+              output[field] = testGroup[field][severityKey] || [];
+          }
       }
-      static cast(isolate) {
-          VestTest.isX(isolate);
-          return isolate;
+      return output;
+  }
+
+  function nonMatchingFieldName(WithFieldName, fieldName) {
+      return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
+  }
+  function matchingFieldName(WithFieldName, fieldName) {
+      return !!(fieldName && WithFieldName.fieldName === fieldName);
+  }
+  function matchesOrHasNoFieldName(WithFieldName, fieldName) {
+      if (fieldName) {
+          return matchingFieldName(WithFieldName, fieldName);
       }
-      static warns(test) {
-          return VestTest.getData(test).severity === TestSeverity.Warning;
-      }
-      static isOmitted(test) {
-          return VestTest.statusEquals(test, TestStatus.OMITTED);
-      }
-      static isUntested(test) {
-          return VestTest.statusEquals(test, TestStatus.UNTESTED);
-      }
-      static isFailing(test) {
-          return VestTest.statusEquals(test, TestStatus.FAILED);
-      }
-      static isCanceled(test) {
-          return VestTest.statusEquals(test, TestStatus.CANCELED);
-      }
-      static isSkipped(test) {
-          return VestTest.statusEquals(test, TestStatus.SKIPPED);
-      }
-      static isPassing(test) {
-          return VestTest.statusEquals(test, TestStatus.PASSING);
-      }
-      static isWarning(test) {
-          return VestTest.statusEquals(test, TestStatus.WARNING);
+      return true;
+  }
+
+  function bindSuiteSelectors(get) {
+      return {
+          getError: (...args) => get().getError(...args),
+          getErrors: (...args) => get().getErrors(...args),
+          getErrorsByGroup: (...args) => get().getErrorsByGroup(...args),
+          getWarning: (...args) => get().getWarning(...args),
+          getWarnings: (...args) => get().getWarnings(...args),
+          getWarningsByGroup: (...args) => get().getWarningsByGroup(...args),
+          hasErrors: (...args) => get().hasErrors(...args),
+          hasErrorsByGroup: (...args) => get().hasErrorsByGroup(...args),
+          hasWarnings: (...args) => get().hasWarnings(...args),
+          hasWarningsByGroup: (...args) => get().hasWarningsByGroup(...args),
+          isPending: (...args) => {
+              return get().isPending(...args);
+          },
+          isTested: (...args) => get().isTested(...args),
+          isValid: (...args) => get().isValid(...args),
+          isValidByGroup: (...args) => get().isValidByGroup(...args),
+      };
+  }
+  // eslint-disable-next-line max-lines-per-function, max-statements
+  function suiteSelectors(summary) {
+      const selectors = {
+          getError,
+          getErrors,
+          getErrorsByGroup,
+          getWarning,
+          getWarnings,
+          getWarningsByGroup,
+          hasErrors,
+          hasErrorsByGroup,
+          hasWarnings,
+          hasWarningsByGroup,
+          isPending,
+          isTested,
+          isValid,
+          isValidByGroup,
+      };
+      return selectors;
+      // Booleans
+      function isValid(fieldName) {
+          var _a;
+          return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
       }
-      static hasFailures(test) {
-          return VestTest.isFailing(test) || VestTest.isWarning(test);
+      function isValidByGroup(groupName, fieldName) {
+          const group = summary.groups[groupName];
+          if (!group) {
+              return false;
+          }
+          if (fieldName) {
+              return isFieldValid(group, fieldName);
+          }
+          for (const fieldName in group) {
+              if (!isFieldValid(group, fieldName)) {
+                  return false;
+              }
+          }
+          return true;
       }
-      static isNonActionable(test) {
-          return (VestTest.isSkipped(test) ||
-              VestTest.isOmitted(test) ||
-              VestTest.isCanceled(test));
+      function hasWarnings(fieldName) {
+          return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
       }
-      static isTested(test) {
-          return VestTest.hasFailures(test) || VestTest.isPassing(test);
+      function hasErrors(fieldName) {
+          return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
       }
-      static awaitsResolution(test) {
-          // Is the test in a state where it can still be run, or complete running
-          // and its final status is indeterminate?
-          return (VestTest.isSkipped(test) ||
-              VestTest.isUntested(test) ||
-              VestTest.isPending(test));
+      function isTested(fieldName) {
+          var _a;
+          return vestUtils.isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount);
       }
-      static isAsyncTest(test) {
-          return vestUtils.isPromise(VestTest.getData(test).asyncTest);
+      function hasWarningsByGroup(groupName, fieldName) {
+          return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
       }
-      // Mutate
-      // static setPending(test: TIsolateTest) {
-      //   this.setStatus(test, TestStatus.PENDING);
-      // }
-      static fail(test) {
-          VestTest.setStatus(test, VestTest.warns(test) ? TestStatus.WARNING : TestStatus.FAILED);
+      function hasErrorsByGroup(groupName, fieldName) {
+          return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
       }
-      static pass(test) {
-          VestTest.setStatus(test, TestStatus.PASSING);
+      function getWarnings(fieldName) {
+          return getFailures(summary, Severity.WARNINGS, fieldName);
       }
-      static warn(test) {
-          VestTest.setData(test, current => (Object.assign(Object.assign({}, current), { severity: TestSeverity.Warning })));
+      function getWarning(fieldName) {
+          return getFailure(Severity.WARNINGS, summary, fieldName);
       }
-      static setData(test, setter) {
-          test.data = vestUtils.optionalFunctionValue(setter, VestTest.getData(test));
+      function getErrors(fieldName) {
+          return getFailures(summary, Severity.ERRORS, fieldName);
       }
-      static skip(test, force) {
-          // Without this force flag, the test will be marked as skipped even if it is pending.
-          // This means that it will not be counted in "allIncomplete" and its done callbacks
-          // will not be called, or will be called prematurely.
-          // What this mostly say is that when we have a pending test for one field, and we then
-          // start typing in a different field - the pending test will be canceled, which
-          // is usually an unwanted behavior.
-          // The only scenario in which we DO want to cancel the async test regardless
-          // is when we specifically skip a test with `skipWhen`, which is handled by the
-          // "force" boolean flag.
-          // I am not a fan of this flag, but it gets the job done.
-          VestTest.setStatus(test, TestStatus.SKIPPED, force);
+      function getError(fieldName) {
+          return getFailure(Severity.ERRORS, summary, fieldName);
       }
-      static cancel(test) {
-          VestTest.setStatus(test, TestStatus.CANCELED);
-          vestjsRuntime.IsolateMutator.abort(test, TestStatus.CANCELED);
+      function getErrorsByGroup(groupName, fieldName) {
+          return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
       }
-      static omit(test) {
-          VestTest.setStatus(test, TestStatus.OMITTED);
+      function getWarningsByGroup(groupName, fieldName) {
+          return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
       }
-      static reset(test) {
-          VestTest.setStatus(test, TestAction.RESET);
+      function isPending(fieldName) {
+          var _a;
+          return fieldName
+              ? vestUtils.greaterThan((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.pendingCount, 0)
+              : vestUtils.greaterThan(summary.pendingCount, 0);
       }
   }
-  VestTest.stateMachine = IsolateTestStateMachine;
-
-  function nonMatchingFieldName(WithFieldName, fieldName) {
-      return !!fieldName && !matchingFieldName(WithFieldName, fieldName);
+  function getFailures(summary, severityKey, fieldName) {
+      return gatherFailures(summary.tests, severityKey, fieldName);
   }
-  function matchingFieldName(WithFieldName, fieldName) {
-      return !!(fieldName && WithFieldName.fieldName === fieldName);
+  // Gathers all failures of a given severity within a group
+  // With a fieldName, it will only gather failures for that field
+  function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
+      return gatherFailures(summary.groups[groupName], severityKey, fieldName);
   }
-  function matchesOrHasNoFieldName(WithFieldName, fieldName) {
+  // Checks if a field is valid within a container object - can be within a group or top level
+  function isFieldValid(testContainer, fieldName) {
+      var _a;
+      return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
+  }
+  // Checks if a there are any failures of a given severity within a group
+  // If a fieldName is provided, it will only check for failures within that field
+  function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
+      var _a, _b;
+      const group = summary.groups[groupName];
+      if (!group) {
+          return false;
+      }
       if (fieldName) {
-          return matchingFieldName(WithFieldName, fieldName);
+          return vestUtils.isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
       }
-      return true;
-  }
-
-  class SuiteWalker {
-      static hasPending(predicate) {
-          const root = SuiteWalker.defaultRoot();
-          if (!root) {
-              return false;
+      for (const field in group) {
+          if (vestUtils.isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
+              return true;
           }
-          return vestjsRuntime.Walker.some(root, vestUtils.Predicates.all(VestIsolate.isPending, predicate !== null && predicate !== void 0 ? predicate : true));
       }
-      // Checks whether there are pending isolates in the tree.
-      // If a fieldname is provided, will only check tests with a matching fieldname.
-      static hasRemainingWithTestNameMatching(fieldName) {
-          return SuiteWalker.hasPending(vestUtils.Predicates.any(vestUtils.isNullish(fieldName), vestUtils.Predicates.all(VestTest.is, (testObject) => {
-              return matchesOrHasNoFieldName(VestTest.getData(testObject), fieldName);
-          })));
+      return false;
+  }
+  // Checks if there are any failures of a given severity
+  // If a fieldName is provided, it will only check for failures within that field
+  function hasFailures(summary, countKey, fieldName) {
+      var _a;
+      const failureCount = fieldName
+          ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
+          : summary[countKey] || 0;
+      return vestUtils.isPositive(failureCount);
+  }
+  function getFailure(severity, summary, fieldName) {
+      var _a;
+      const summaryKey = summary[severity];
+      if (!fieldName) {
+          return summaryKey[0];
       }
+      return (_a = summaryKey.find((summaryFailure) => matchingFieldName(summaryFailure, fieldName))) === null || _a === void 0 ? void 0 : _a.message;
   }
-  SuiteWalker.defaultRoot = vestjsRuntime.VestRuntime.useAvailableRoot;
 
-  class TestWalker {
-      static hasNoTests(root = TestWalker.defaultRoot()) {
-          if (!root)
-              return true;
-          return !vestjsRuntime.Walker.has(root, VestTest.is);
-      }
-      static someTests(predicate, root = TestWalker.defaultRoot()) {
-          if (!root)
-              return false;
-          return vestjsRuntime.Walker.some(root, isolate => {
-              VestTest.isX(isolate);
-              return predicate(isolate);
-          }, VestTest.is);
+  var _a, _b;
+  class SummaryBase {
+      constructor() {
+          this.errorCount = 0;
+          this.warnCount = 0;
+          this.testCount = 0;
+          this.pendingCount = 0;
       }
-      static everyTest(predicate, root = TestWalker.defaultRoot()) {
-          if (!root)
-              return false;
-          return vestjsRuntime.Walker.every(root, isolate => {
-              VestTest.isX(isolate);
-              return predicate(isolate);
-          }, VestTest.is);
+  }
+  class SuiteSummary extends SummaryBase {
+      constructor() {
+          super(...arguments);
+          this[_a] = [];
+          this[_b] = [];
+          this.groups = {};
+          this.tests = {};
+          this.valid = false;
+      }
+  }
+  _a = Severity.ERRORS, _b = Severity.WARNINGS;
+
+  const CommonStates = {
+      PENDING: 'PENDING',
+      INITIAL: 'INITIAL',
+  };
+  const State = {
+      [CommonStates.PENDING]: CommonStates.PENDING,
+      [CommonStates.INITIAL]: CommonStates.INITIAL,
+      DONE: 'DONE',
+  };
+  const machine$1 = {
+      initial: State.INITIAL,
+      states: {
+          [State.DONE]: {},
+          [State.INITIAL]: {
+              [State.PENDING]: State.PENDING,
+              [State.DONE]: State.DONE,
+          },
+          [State.PENDING]: {
+              [State.DONE]: State.DONE,
+          },
+      },
+  };
+  function transition(from, to) {
+      return CommonStateMachine.staticTransition(from !== null && from !== void 0 ? from : State.INITIAL, to);
+  }
+  function setDone(isolate) {
+      isolate.status = transition(isolate.status, State.DONE);
+  }
+  function setPending(isolate) {
+      isolate.status = transition(isolate.status, State.PENDING);
+  }
+  const CommonStateMachine = vestUtils.StateMachine(machine$1);
+
+  const TestStatus = {
+      [CommonStates.PENDING]: CommonStates.PENDING,
+      CANCELED: 'CANCELED',
+      FAILED: 'FAILED',
+      OMITTED: 'OMITTED',
+      PASSING: 'PASSING',
+      SKIPPED: 'SKIPPED',
+      UNTESTED: 'UNTESTED',
+      WARNING: 'WARNING',
+  };
+  const TestAction = {
+      RESET: 'RESET',
+  };
+  const machine = {
+      initial: TestStatus.UNTESTED,
+      states: {
+          '*': {
+              [TestStatus.OMITTED]: TestStatus.OMITTED,
+              [TestAction.RESET]: TestStatus.UNTESTED,
+          },
+          [TestStatus.UNTESTED]: {
+              [TestStatus.CANCELED]: TestStatus.CANCELED,
+              [TestStatus.FAILED]: TestStatus.FAILED,
+              [TestStatus.PASSING]: TestStatus.PASSING,
+              [TestStatus.PENDING]: TestStatus.PENDING,
+              [TestStatus.SKIPPED]: TestStatus.SKIPPED,
+              [TestStatus.WARNING]: TestStatus.WARNING,
+          },
+          [TestStatus.PENDING]: {
+              [TestStatus.CANCELED]: TestStatus.CANCELED,
+              [TestStatus.FAILED]: TestStatus.FAILED,
+              [TestStatus.PASSING]: TestStatus.PASSING,
+              [TestStatus.SKIPPED]: [
+                  TestStatus.SKIPPED,
+                  (force) => force === true,
+              ],
+              [TestStatus.WARNING]: TestStatus.WARNING,
+          },
+          [TestStatus.SKIPPED]: {},
+          [TestStatus.FAILED]: {},
+          [TestStatus.WARNING]: {},
+          [TestStatus.PASSING]: {},
+          [TestStatus.CANCELED]: {},
+          [TestStatus.OMITTED]: {},
+      },
+  };
+  const IsolateTestStateMachine = vestUtils.StateMachine(machine);
+
+  class VestIsolate {
+      static getStatus(isolate) {
+          var _a;
+          return (_a = isolate.status) !== null && _a !== void 0 ? _a : CommonStates.INITIAL;
+      }
+      static setStatus(isolate, status, payload) {
+          isolate.status = this.stateMachine.staticTransition(VestIsolate.getStatus(isolate), status, payload);
+      }
+      static statusEquals(isolate, status) {
+          return VestIsolate.getStatus(isolate) === status;
+      }
+      static setPending(isolate) {
+          this.setStatus(isolate, CommonStates.PENDING);
+      }
+      static isPending(isolate) {
+          return VestIsolate.statusEquals(isolate, CommonStates.PENDING);
+      }
+  }
+  VestIsolate.stateMachine = CommonStateMachine;
+
+  class VestTest extends VestIsolate {
+      // Read
+      static getData(test) {
+          vestUtils.invariant(test.data);
+          return test.data;
+      }
+      static is(isolate) {
+          return vestjsRuntime.IsolateSelectors.isIsolateType(isolate, VestIsolateType.Test);
+      }
+      static isX(isolate) {
+          vestUtils.invariant(VestTest.is(isolate), ErrorStrings.EXPECTED_VEST_TEST);
+      }
+      static cast(isolate) {
+          VestTest.isX(isolate);
+          return isolate;
+      }
+      static warns(test) {
+          return VestTest.getData(test).severity === TestSeverity.Warning;
+      }
+      static isOmitted(test) {
+          return VestTest.statusEquals(test, TestStatus.OMITTED);
+      }
+      static isUntested(test) {
+          return VestTest.statusEquals(test, TestStatus.UNTESTED);
+      }
+      static isFailing(test) {
+          return VestTest.statusEquals(test, TestStatus.FAILED);
+      }
+      static isCanceled(test) {
+          return VestTest.statusEquals(test, TestStatus.CANCELED);
+      }
+      static isSkipped(test) {
+          return VestTest.statusEquals(test, TestStatus.SKIPPED);
+      }
+      static isPassing(test) {
+          return VestTest.statusEquals(test, TestStatus.PASSING);
+      }
+      static isWarning(test) {
+          return VestTest.statusEquals(test, TestStatus.WARNING);
+      }
+      static hasFailures(test) {
+          return VestTest.isFailing(test) || VestTest.isWarning(test);
+      }
+      static isNonActionable(test) {
+          return (VestTest.isSkipped(test) ||
+              VestTest.isOmitted(test) ||
+              VestTest.isCanceled(test));
+      }
+      static isTested(test) {
+          return VestTest.hasFailures(test) || VestTest.isPassing(test);
+      }
+      static awaitsResolution(test) {
+          // Is the test in a state where it can still be run, or complete running
+          // and its final status is indeterminate?
+          return (VestTest.isSkipped(test) ||
+              VestTest.isUntested(test) ||
+              VestTest.isPending(test));
+      }
+      static isAsyncTest(test) {
+          return vestUtils.isPromise(VestTest.getData(test).asyncTest);
+      }
+      // Mutate
+      // static setPending(test: TIsolateTest) {
+      //   this.setStatus(test, TestStatus.PENDING);
+      // }
+      static fail(test) {
+          VestTest.setStatus(test, VestTest.warns(test) ? TestStatus.WARNING : TestStatus.FAILED);
+      }
+      static pass(test) {
+          VestTest.setStatus(test, TestStatus.PASSING);
+      }
+      static warn(test) {
+          VestTest.setData(test, current => (Object.assign(Object.assign({}, current), { severity: TestSeverity.Warning })));
+      }
+      static setData(test, setter) {
+          test.data = vestUtils.optionalFunctionValue(setter, VestTest.getData(test));
+      }
+      static skip(test, force) {
+          // Without this force flag, the test will be marked as skipped even if it is pending.
+          // This means that it will not be counted in "allIncomplete" and its done callbacks
+          // will not be called, or will be called prematurely.
+          // What this mostly say is that when we have a pending test for one field, and we then
+          // start typing in a different field - the pending test will be canceled, which
+          // is usually an unwanted behavior.
+          // The only scenario in which we DO want to cancel the async test regardless
+          // is when we specifically skip a test with `skipWhen`, which is handled by the
+          // "force" boolean flag.
+          // I am not a fan of this flag, but it gets the job done.
+          VestTest.setStatus(test, TestStatus.SKIPPED, force);
+      }
+      static cancel(test) {
+          VestTest.setStatus(test, TestStatus.CANCELED);
+          vestjsRuntime.IsolateMutator.abort(test, TestStatus.CANCELED);
+      }
+      static omit(test) {
+          VestTest.setStatus(test, TestStatus.OMITTED);
+      }
+      static reset(test) {
+          VestTest.setStatus(test, TestAction.RESET);
+      }
+  }
+  VestTest.stateMachine = IsolateTestStateMachine;
+
+  class SummaryFailure {
+      constructor(fieldName, message, groupName) {
+          this.fieldName = fieldName;
+          this.message = message;
+          this.groupName = groupName;
+      }
+      static fromTestObject(testObject) {
+          const { fieldName, message, groupName } = VestTest.getData(testObject);
+          return new SummaryFailure(fieldName, message, groupName);
+      }
+  }
+
+  class TestWalker {
+      static hasNoTests(root = TestWalker.defaultRoot()) {
+          if (!root)
+              return true;
+          return !vestjsRuntime.Walker.has(root, VestTest.is);
+      }
+      static someTests(predicate, root = TestWalker.defaultRoot()) {
+          if (!root)
+              return false;
+          return vestjsRuntime.Walker.some(root, isolate => {
+              VestTest.isX(isolate);
+              return predicate(isolate);
+          }, VestTest.is);
+      }
+      static everyTest(predicate, root = TestWalker.defaultRoot()) {
+          if (!root)
+              return false;
+          return vestjsRuntime.Walker.every(root, isolate => {
+              VestTest.isX(isolate);
+              return predicate(isolate);
+          }, VestTest.is);
       }
       static walkTests(callback, root = TestWalker.defaultRoot()) {
           if (!root)
@@ -526,178 +763,23 @@
   }
   TestWalker.defaultRoot = vestjsRuntime.VestRuntime.useAvailableRoot;
 
-  /**
-   * This module gets triggered once the suite is done running its sync tests.
-   *
-   * It goes over all the tests in the state, and checks if they need to be omitted.
-   */
-  function useOmitOptionalFields() {
-      const root = vestjsRuntime.VestRuntime.useAvailableRoot();
-      const optionalFields = SuiteOptionalFields.getOptionalFields(root);
-      // 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
-      const shouldOmit = new Set();
-      // iterate over each of the tests in the state
-      TestWalker.walkTests(testObject => {
-          if (VestTest.isPending(testObject)) {
-              return;
-          }
-          const { fieldName } = VestTest.getData(testObject);
-          // If we already added the current field (not this test specifically)
-          // no need for further checks, go and omit the test
-          if (shouldOmit.has(fieldName)) {
-              verifyAndOmit(testObject);
-          }
-          else {
-              // check if the field has an optional function
-              // if so, run it and verify/omit the test
-              runOptionalConfig(testObject);
-          }
-      });
-      vestjsRuntime.Bus.useEmit(Events.DONE_TEST_OMISSION_PASS);
-      function verifyAndOmit(testObject) {
-          const { fieldName } = VestTest.getData(testObject);
-          if (shouldOmit.has(fieldName)) {
-              VestTest.omit(testObject);
-              SuiteOptionalFields.setOptionalField(root, fieldName, current => (Object.assign(Object.assign({}, current), { applied: true })));
-          }
-      }
-      function runOptionalConfig(testObject) {
-          const { fieldName } = VestTest.getData(testObject);
-          // Ge the optional configuration for the given field
-          const optionalConfig = SuiteOptionalFields.getOptionalField(root, fieldName);
-          // If the optional was set to a function or a boolean, run it and verify/omit the test
-          if (vestUtils.optionalFunctionValue(optionalConfig.rule) === true) {
-              shouldOmit.add(fieldName);
-          }
-          verifyAndOmit(testObject);
-      }
-  }
-
-  /**
-   * Runs done callback per field when async tests are finished running.
-   */
-  function useRunFieldCallbacks(fieldName) {
-      const [fieldCallbacks] = useFieldCallbacks();
-      if (fieldName &&
-          !SuiteWalker.hasRemainingWithTestNameMatching(fieldName) &&
-          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);
-  }
-
-  // eslint-disable-next-line max-statements, max-lines-per-function
-  function useInitVestBus() {
-      const VestBus = vestjsRuntime.Bus.useBus();
-      // Report a the completion of a test. There may be other tests with the same
-      // name that are still running, or not yet started.
-      on(Events.TEST_COMPLETED, (testObject) => {
-          if (VestTest.isCanceled(testObject)) {
-              return;
-          }
-          const { fieldName } = VestTest.getData(testObject);
-          useRunFieldCallbacks(fieldName);
-      });
-      on(Events.TEST_RUN_STARTED, () => {
-          /* Let's just invalidate the suite cache for now */
-      });
-      on(vestjsRuntime.RuntimeEvents.ISOLATE_PENDING, (isolate) => {
-          if (VestTest.is(isolate)) {
-              VestTest.setPending(isolate);
-          }
-          setPending(isolate);
-      });
-      on(vestjsRuntime.RuntimeEvents.ISOLATE_DONE, (isolate) => {
-          if (VestTest.is(isolate)) {
-              VestBus.emit(Events.TEST_COMPLETED, isolate);
-          }
-          setDone(isolate);
-          if (!SuiteWalker.hasPending()) {
-              // When no more tests are running, emit the done event
-              VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
-          }
-      });
-      on(Events.DONE_TEST_OMISSION_PASS, () => {
-          /* We NEED to refresh the cache here. Don't ask */
-      });
-      // Called when all the tests, including async, are done running
-      on(Events.ALL_RUNNING_TESTS_FINISHED, () => {
-          // Small optimization. We don't need to run this if there are no async tests
-          // The reason is that we run this function immediately after the suite callback
-          // is run, so if the suite is only comprised of sync tests, we don't need to
-          // run this function twice since we know for a fact the state is up to date
-          if (TestWalker.someTests(VestTest.isAsyncTest)) {
-              useOmitOptionalFields();
+  class SuiteWalker {
+      static hasPending(predicate) {
+          const root = SuiteWalker.defaultRoot();
+          if (!root) {
+              return false;
           }
-          useRunDoneCallbacks();
-      });
-      on(Events.RESET_FIELD, (fieldName) => {
-          TestWalker.resetField(fieldName);
-      });
-      on(Events.SUITE_RUN_STARTED, () => {
-          useResetCallbacks();
-      });
-      on(Events.SUITE_CALLBACK_RUN_FINISHED, () => {
-          useOmitOptionalFields();
-      });
-      on(Events.REMOVE_FIELD, (fieldName) => {
-          TestWalker.removeTestByFieldName(fieldName);
-      });
-      on(Events.RESET_SUITE, () => {
-          useResetSuite();
-      });
-      return {
-          subscribe,
-      };
-      function subscribe(cb) {
-          return VestBus.on('*', () => {
-              cb();
-          }).off;
-      }
-      function on(event, cb) {
-          VestBus.on(event, (...args) => {
-              // This is more concise, but it might be an overkill
-              // if we're adding events that don't need to invalidate the cache
-              useExpireSuiteResultCache();
-              cb(...args);
-          });
-      }
-  }
-
-  class IsolateReconciler {
-      static match(_currentNode, _historyNode) {
-          return false;
-      }
-      static reconcile(currentNode, historyNode) {
-          return (currentNode !== null && currentNode !== void 0 ? currentNode : historyNode);
+          return vestjsRuntime.Walker.some(root, vestUtils.Predicates.all(VestIsolate.isPending, predicate !== null && predicate !== void 0 ? predicate : true));
       }
-  }
-
-  function isSameProfileTest(testObject1, testObject2) {
-      const { groupName: gn1 } = VestTest.getData(testObject1);
-      const { groupName: gn2, fieldName: fn2 } = VestTest.getData(testObject2);
-      return (matchingFieldName(VestTest.getData(testObject1), fn2) &&
-          gn1 === gn2 &&
-          testObject1.key === testObject2.key);
-  }
-
-  function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
-      if (currentRunTestObject !== prevRunTestObject &&
-          isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
-          VestTest.isPending(prevRunTestObject)) {
-          VestTest.cancel(prevRunTestObject);
+      // Checks whether there are pending isolates in the tree.
+      // If a fieldname is provided, will only check tests with a matching fieldname.
+      static hasRemainingWithTestNameMatching(fieldName) {
+          return SuiteWalker.hasPending(vestUtils.Predicates.any(vestUtils.isNullish(fieldName), vestUtils.Predicates.all(VestTest.is, (testObject) => {
+              return matchesOrHasNoFieldName(VestTest.getData(testObject), fieldName);
+          })));
       }
   }
+  SuiteWalker.defaultRoot = vestjsRuntime.VestRuntime.useAvailableRoot;
 
   const nonMatchingGroupName = vestUtils.bindNot(matchingGroupName);
   function matchingGroupName(testObject, groupName) {
@@ -747,296 +829,46 @@
       return true;
   }
 
-  /**
-   * Sets the current execution mode for the current suite.
-   *
-   * Supported modes:
-   * - `EAGER` - (default) Runs all tests, but stops on first failure for each given field.
-   * - `ALL` - Runs all tests, regardless of failures.
-   * - `ONE` - Stops suite execution on first failure of any field.
-   *
-   * @example
-   * ```js
-   * import {Modes, create} from 'vest';
-   *
-   * const suite = create('suite_name', () => {
-   *  vest.mode(Modes.ALL);
-   *
-   *  // ...
-   * });
-   * ```
-   * @param 'ALL' | 'EAGER' | 'ONE' mode - The mode to set.
-   */
-  // @vx-allow use-use
-  function mode(mode) {
-      const [, setMode] = useMode();
-      setMode(mode);
-  }
-  function useIsMode(mode) {
-      const [currentMode] = useMode();
-      return currentMode === mode;
-  }
-  function useIsEager() {
-      return useIsMode(exports.Modes.EAGER);
-  }
-  function useIsOne() {
-      return useIsMode(exports.Modes.ONE);
+  function useShouldAddValidProperty(fieldName) {
+      // Is the field optional, and the optional condition is applied
+      if (useIsOptionalFieldApplied(fieldName)) {
+          return true;
+      }
+      // Are there no tests?
+      if (TestWalker.hasNoTests()) {
+          return false;
+      }
+      // // Does the field have any tests with errors?
+      if (hasErrorsByTestObjects(fieldName)) {
+          return false;
+      }
+      // Does the given field have any pending tests that are not optional?
+      if (useHasNonOptionalIncomplete(fieldName)) {
+          return false;
+      }
+      // Does the field have no missing tests?
+      return useNoMissingTests(fieldName);
   }
-  function useShouldSkipBasedOnMode(testData) {
-      if (useIsOne()) {
-          return hasErrorsByTestObjects();
+  function useShouldAddValidPropertyInGroup(groupName, fieldName) {
+      if (useIsOptionalFieldApplied(fieldName)) {
+          return true;
       }
-      if (useIsEager()) {
-          return hasErrorsByTestObjects(testData.fieldName);
+      if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
+          return false;
       }
-      return false;
+      // Do the given group/field have any pending tests that are not optional?
+      if (useHasNonOptionalIncompleteByGroup(groupName, fieldName)) {
+          return false;
+      }
+      return useNoMissingTestsByGroup(groupName, fieldName);
   }
-
-  // calls collectAll or getByFieldName depending on whether fieldName is provided
-  function gatherFailures(testGroup, severityKey, fieldName) {
-      return fieldName
-          ? getByFieldName(testGroup, severityKey, fieldName)
-          : collectAll(testGroup, severityKey);
+  // Does the given field have any pending tests that are not optional?
+  function useHasNonOptionalIncomplete(fieldName) {
+      return SuiteWalker.hasPending(vestUtils.Predicates.all(VestTest.is, (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
   }
-  function getByFieldName(testGroup, severityKey, fieldName) {
-      var _a;
-      return ((_a = testGroup === null || testGroup === void 0 ? void 0 : testGroup[fieldName]) === null || _a === void 0 ? void 0 : _a[severityKey]) || [];
-  }
-  function collectAll(testGroup, severityKey) {
-      const output = {};
-      const countKey = countKeyBySeverity(severityKey);
-      for (const field in testGroup) {
-          if (vestUtils.isPositive(testGroup[field][countKey])) {
-              // We will probably never get to the fallback array
-              // leaving it just in case the implementation changes
-              output[field] = testGroup[field][severityKey] || [];
-          }
-      }
-      return output;
-  }
-
-  function bindSuiteSelectors(get) {
-      return {
-          getError: (...args) => get().getError(...args),
-          getErrors: (...args) => get().getErrors(...args),
-          getErrorsByGroup: (...args) => get().getErrorsByGroup(...args),
-          getWarning: (...args) => get().getWarning(...args),
-          getWarnings: (...args) => get().getWarnings(...args),
-          getWarningsByGroup: (...args) => get().getWarningsByGroup(...args),
-          hasErrors: (...args) => get().hasErrors(...args),
-          hasErrorsByGroup: (...args) => get().hasErrorsByGroup(...args),
-          hasWarnings: (...args) => get().hasWarnings(...args),
-          hasWarningsByGroup: (...args) => get().hasWarningsByGroup(...args),
-          isPending: (...args) => {
-              return get().isPending(...args);
-          },
-          isTested: (...args) => get().isTested(...args),
-          isValid: (...args) => get().isValid(...args),
-          isValidByGroup: (...args) => get().isValidByGroup(...args),
-      };
-  }
-  // eslint-disable-next-line max-lines-per-function, max-statements
-  function suiteSelectors(summary) {
-      const selectors = {
-          getError,
-          getErrors,
-          getErrorsByGroup,
-          getWarning,
-          getWarnings,
-          getWarningsByGroup,
-          hasErrors,
-          hasErrorsByGroup,
-          hasWarnings,
-          hasWarningsByGroup,
-          isPending,
-          isTested,
-          isValid,
-          isValidByGroup,
-      };
-      return selectors;
-      // Booleans
-      function isValid(fieldName) {
-          var _a;
-          return fieldName ? Boolean((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.valid) : summary.valid;
-      }
-      function isValidByGroup(groupName, fieldName) {
-          const group = summary.groups[groupName];
-          if (!group) {
-              return false;
-          }
-          if (fieldName) {
-              return isFieldValid(group, fieldName);
-          }
-          for (const fieldName in group) {
-              if (!isFieldValid(group, fieldName)) {
-                  return false;
-              }
-          }
-          return true;
-      }
-      function hasWarnings(fieldName) {
-          return hasFailures(summary, SeverityCount.WARN_COUNT, fieldName);
-      }
-      function hasErrors(fieldName) {
-          return hasFailures(summary, SeverityCount.ERROR_COUNT, fieldName);
-      }
-      function isTested(fieldName) {
-          var _a;
-          return vestUtils.isPositive((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.testCount);
-      }
-      function hasWarningsByGroup(groupName, fieldName) {
-          return hasFailuresByGroup(summary, SeverityCount.WARN_COUNT, groupName, fieldName);
-      }
-      function hasErrorsByGroup(groupName, fieldName) {
-          return hasFailuresByGroup(summary, SeverityCount.ERROR_COUNT, groupName, fieldName);
-      }
-      function getWarnings(fieldName) {
-          return getFailures(summary, Severity.WARNINGS, fieldName);
-      }
-      function getWarning(fieldName) {
-          return getFailure(Severity.WARNINGS, summary, fieldName);
-      }
-      function getErrors(fieldName) {
-          return getFailures(summary, Severity.ERRORS, fieldName);
-      }
-      function getError(fieldName) {
-          return getFailure(Severity.ERRORS, summary, fieldName);
-      }
-      function getErrorsByGroup(groupName, fieldName) {
-          return getFailuresByGroup(summary, Severity.ERRORS, groupName, fieldName);
-      }
-      function getWarningsByGroup(groupName, fieldName) {
-          return getFailuresByGroup(summary, Severity.WARNINGS, groupName, fieldName);
-      }
-      function isPending(fieldName) {
-          var _a;
-          return fieldName
-              ? vestUtils.greaterThan((_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a.pendingCount, 0)
-              : vestUtils.greaterThan(summary.pendingCount, 0);
-      }
-  }
-  function getFailures(summary, severityKey, fieldName) {
-      return gatherFailures(summary.tests, severityKey, fieldName);
-  }
-  // Gathers all failures of a given severity within a group
-  // With a fieldName, it will only gather failures for that field
-  function getFailuresByGroup(summary, severityKey, groupName, fieldName) {
-      return gatherFailures(summary.groups[groupName], severityKey, fieldName);
-  }
-  // Checks if a field is valid within a container object - can be within a group or top level
-  function isFieldValid(testContainer, fieldName) {
-      var _a;
-      return !!((_a = testContainer[fieldName]) === null || _a === void 0 ? void 0 : _a.valid);
-  }
-  // Checks if a there are any failures of a given severity within a group
-  // If a fieldName is provided, it will only check for failures within that field
-  function hasFailuresByGroup(summary, severityCount, groupName, fieldName) {
-      var _a, _b;
-      const group = summary.groups[groupName];
-      if (!group) {
-          return false;
-      }
-      if (fieldName) {
-          return vestUtils.isPositive((_a = group[fieldName]) === null || _a === void 0 ? void 0 : _a[severityCount]);
-      }
-      for (const field in group) {
-          if (vestUtils.isPositive((_b = group[field]) === null || _b === void 0 ? void 0 : _b[severityCount])) {
-              return true;
-          }
-      }
-      return false;
-  }
-  // Checks if there are any failures of a given severity
-  // If a fieldName is provided, it will only check for failures within that field
-  function hasFailures(summary, countKey, fieldName) {
-      var _a;
-      const failureCount = fieldName
-          ? (_a = summary.tests[fieldName]) === null || _a === void 0 ? void 0 : _a[countKey]
-          : summary[countKey] || 0;
-      return vestUtils.isPositive(failureCount);
-  }
-  function getFailure(severity, summary, fieldName) {
-      var _a;
-      const summaryKey = summary[severity];
-      if (!fieldName) {
-          return summaryKey[0];
-      }
-      return (_a = summaryKey.find((summaryFailure) => matchingFieldName(summaryFailure, fieldName))) === null || _a === void 0 ? void 0 : _a.message;
-  }
-
-  var _a, _b;
-  class SummaryBase {
-      constructor() {
-          this.errorCount = 0;
-          this.warnCount = 0;
-          this.testCount = 0;
-          this.pendingCount = 0;
-      }
-  }
-  class SuiteSummary extends SummaryBase {
-      constructor() {
-          super(...arguments);
-          this[_a] = [];
-          this[_b] = [];
-          this.groups = {};
-          this.tests = {};
-          this.valid = false;
-      }
-  }
-  _a = Severity.ERRORS, _b = Severity.WARNINGS;
-
-  class SummaryFailure {
-      constructor(fieldName, message, groupName) {
-          this.fieldName = fieldName;
-          this.message = message;
-          this.groupName = groupName;
-      }
-      static fromTestObject(testObject) {
-          const { fieldName, message, groupName } = VestTest.getData(testObject);
-          return new SummaryFailure(fieldName, message, groupName);
-      }
-  }
-
-  function useShouldAddValidProperty(fieldName) {
-      // Is the field optional, and the optional condition is applied
-      if (useIsOptionalFieldApplied(fieldName)) {
-          return true;
-      }
-      // Are there no tests?
-      if (TestWalker.hasNoTests()) {
-          return false;
-      }
-      // // Does the field have any tests with errors?
-      if (hasErrorsByTestObjects(fieldName)) {
-          return false;
-      }
-      // Does the given field have any pending tests that are not optional?
-      if (useHasNonOptionalIncomplete(fieldName)) {
-          return false;
-      }
-      // Does the field have no missing tests?
-      return useNoMissingTests(fieldName);
-  }
-  function useShouldAddValidPropertyInGroup(groupName, fieldName) {
-      if (useIsOptionalFieldApplied(fieldName)) {
-          return true;
-      }
-      if (hasGroupFailuresByTestObjects(Severity.ERRORS, groupName, fieldName)) {
-          return false;
-      }
-      // Do the given group/field have any pending tests that are not optional?
-      if (useHasNonOptionalIncompleteByGroup(groupName, fieldName)) {
-          return false;
-      }
-      return useNoMissingTestsByGroup(groupName, fieldName);
-  }
-  // Does the given field have any pending tests that are not optional?
-  function useHasNonOptionalIncomplete(fieldName) {
-      return SuiteWalker.hasPending(vestUtils.Predicates.all(VestTest.is, (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
-  }
-  // Do the given group/field have any pending tests that are not optional?
-  function useHasNonOptionalIncompleteByGroup(groupName, fieldName) {
-      return SuiteWalker.hasPending(vestUtils.Predicates.all(VestTest.is, (testObject) => !nonMatchingGroupName(testObject, groupName), (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
+  // Do the given group/field have any pending tests that are not optional?
+  function useHasNonOptionalIncompleteByGroup(groupName, fieldName) {
+      return SuiteWalker.hasPending(vestUtils.Predicates.all(VestTest.is, (testObject) => !nonMatchingGroupName(testObject, groupName), (testObject) => !nonMatchingFieldName(VestTest.getData(testObject), fieldName), () => !useIsOptionalFieldApplied(fieldName)));
   }
   // Did all of the tests for the provided field run/omit?
   // This makes sure that the fields are not skipped or pending.
@@ -1199,30 +1031,81 @@
   }
 
   /**
-   * Conditionally omits tests from the suite.
-   *
-   * @example
-   *
-   * omitWhen(res => res.hasErrors('username'), () => {
-   *  test('username', 'User already taken', async () => await doesUserExist(username)
-   * });
+   * Checks if context has included tests
    */
-  // @vx-allow use-use
-  function omitWhen(conditional, callback) {
-      vestjsRuntime.Isolate.create(VestIsolateType.OmitWhen, () => {
-          SuiteContext.run({
-              omitted: useWithinActiveOmitWhen() ||
-                  vestUtils.optionalFunctionValue(conditional, vestUtils.optionalFunctionValue(useCreateSuiteResult)),
-          }, callback);
-      });
-  }
-  // Checks that we're currently in an active omitWhen block
-  function useWithinActiveOmitWhen() {
-      return useOmitted();
+  function useHasOnliedTests(testObject, fieldName) {
+      return vestUtils.isNotNullish(vestjsRuntime.Walker.findClosest(testObject, (child) => {
+          if (!FocusSelectors.isIsolateFocused(child))
+              return false;
+          return FocusSelectors.isOnlyFocused(child, fieldName);
+      }));
   }
 
   /**
-   * Conditionally skips running tests within the callback.
+   * Conditionally includes a field for testing, based on specified criteria.
+   *
+   * @param {string} fieldName - The name of the field to include for testing.
+   *
+   * @example
+   * include('confirm').when('password');
+   * // Includes the "confirm" field for testing when the "password" field is included
+   *
+   * include('confirm').when(someValue);
+   * // Includes the "confirm" field for testing when the value of `someValue` is true
+   *
+   * include('confirm').when(() => someValue);
+   * // Includes the "confirm" field for testing when the callback function returns true
+   *
+   * include('username').when(result => result.hasErrors('username'));
+   * // Includes the "username" field for testing when there are errors associated with it in the current suite result
+   */
+  // @vx-allow use-use
+  function include(fieldName) {
+      vestUtils.invariant(vestUtils.isStringValue(fieldName));
+      const inclusion = useInclusion();
+      inclusion[fieldName] = true;
+      return { when };
+      /**
+       * Specifies the inclusion criteria for the field in `include` function.
+       */
+      function when(condition) {
+          vestUtils.invariant(condition !== fieldName, ErrorStrings.INCLUDE_SELF);
+          const inclusion = useInclusion();
+          // This callback will run as part of the "isExcluded" series of checks
+          inclusion[fieldName] = function isIncluded(currentNode) {
+              if (vestUtils.isStringValue(condition)) {
+                  return useHasOnliedTests(currentNode, condition);
+              }
+              return vestUtils.optionalFunctionValue(condition, vestUtils.optionalFunctionValue(useCreateSuiteResult));
+          };
+      }
+  }
+
+  /**
+   * Conditionally omits tests from the suite.
+   *
+   * @example
+   *
+   * omitWhen(res => res.hasErrors('username'), () => {
+   *  test('username', 'User already taken', async () => await doesUserExist(username)
+   * });
+   */
+  // @vx-allow use-use
+  function omitWhen(conditional, callback) {
+      vestjsRuntime.Isolate.create(VestIsolateType.OmitWhen, () => {
+          SuiteContext.run({
+              omitted: useWithinActiveOmitWhen() ||
+                  vestUtils.optionalFunctionValue(conditional, vestUtils.optionalFunctionValue(useCreateSuiteResult)),
+          }, callback);
+      });
+  }
+  // Checks that we're currently in an active omitWhen block
+  function useWithinActiveOmitWhen() {
+      return useOmitted();
+  }
+
+  /**
+   * Conditionally skips running tests within the callback.
    *
    * @example
    *
@@ -1247,71 +1130,85 @@
       return useSkipped();
   }
 
-  var FocusModes;
-  (function (FocusModes) {
-      FocusModes[FocusModes["ONLY"] = 0] = "ONLY";
-      FocusModes[FocusModes["SKIP"] = 1] = "SKIP";
-  })(FocusModes || (FocusModes = {}));
+  var Events;
+  (function (Events) {
+      Events["TEST_RUN_STARTED"] = "test_run_started";
+      Events["TEST_COMPLETED"] = "test_completed";
+      Events["ALL_RUNNING_TESTS_FINISHED"] = "all_running_tests_finished";
+      Events["REMOVE_FIELD"] = "remove_field";
+      Events["RESET_FIELD"] = "reset_field";
+      Events["RESET_SUITE"] = "reset_suite";
+      Events["SUITE_RUN_STARTED"] = "suite_run_started";
+      Events["SUITE_CALLBACK_RUN_FINISHED"] = "SUITE_CALLBACK_RUN_FINISHED";
+      Events["DONE_TEST_OMISSION_PASS"] = "DONE_TEST_OMISSION_PASS";
+  })(Events || (Events = {}));
 
-  function IsolateFocused(focusMode, match) {
-      return vestjsRuntime.Isolate.create(VestIsolateType.Focused, vestUtils.noop, {
-          focusMode,
-          match: vestUtils.asArray(match).filter(vestUtils.isStringValue),
-          matchAll: match === true,
-      });
-  }
-  class FocusSelectors {
-      static isSkipFocused(focus, fieldName) {
-          return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.SKIP &&
-              (hasFocus(focus, fieldName) || focus.data.matchAll === true));
-      }
-      static isOnlyFocused(focus, fieldName) {
-          return ((focus === null || focus === void 0 ? void 0 : focus.data.focusMode) === FocusModes.ONLY && hasFocus(focus, fieldName));
+  function IsolateTest(callback, input, key) {
+      const payload = Object.assign(Object.assign({}, IsolateTestBase()), { fieldName: input.fieldName, testFn: input.testFn });
+      if (input.groupName) {
+          payload.groupName = input.groupName;
       }
-      static isIsolateFocused(isolate) {
-          return vestjsRuntime.IsolateSelectors.isIsolateType(isolate, VestIsolateType.Focused);
+      if (input.message) {
+          payload.message = input.message;
       }
+      const isolate = vestjsRuntime.Isolate.create(VestIsolateType.Test, callback, payload, key !== null && key !== void 0 ? key : null);
+      return isolate;
   }
-  /**
-   * Adds a field or a list of fields into the inclusion list
-   *
-   * @example
-   *
-   * only('username');
-   */
-  // @vx-allow use-use
-  function only(match) {
-      return IsolateFocused(FocusModes.ONLY, defaultMatch(match));
+  function IsolateTestBase() {
+      return {
+          severity: TestSeverity.Error,
+          status: IsolateTestStateMachine.initial(),
+      };
   }
+
+  function shouldUseErrorAsMessage(message, error) {
+      // kind of cheating with this safe guard, but it does the job
+      return vestUtils.isUndefined(message) && vestUtils.isStringValue(error);
+  }
+
   /**
-   * Adds a field or a list of fields into the exclusion list
+   * Sets the current execution mode for the current suite.
+   *
+   * Supported modes:
+   * - `EAGER` - (default) Runs all tests, but stops on first failure for each given field.
+   * - `ALL` - Runs all tests, regardless of failures.
+   * - `ONE` - Stops suite execution on first failure of any field.
    *
    * @example
+   * ```js
+   * import {Modes, create} from 'vest';
    *
-   * skip('username');
+   * const suite = create('suite_name', () => {
+   *  vest.mode(Modes.ALL);
+   *
+   *  // ...
+   * });
+   * ```
+   * @param 'ALL' | 'EAGER' | 'ONE' mode - The mode to set.
    */
   // @vx-allow use-use
-  function skip(match) {
-      return IsolateFocused(FocusModes.SKIP, defaultMatch(match));
+  function mode(mode) {
+      const [, setMode] = useMode();
+      setMode(mode);
   }
-  function defaultMatch(match) {
-      return match === false ? [] : match;
+  function useIsMode(mode) {
+      const [currentMode] = useMode();
+      return currentMode === mode;
   }
-  function hasFocus(focus, fieldName) {
-      var _a, _b;
-      return (vestUtils.isNotEmpty(focus === null || focus === void 0 ? void 0 : focus.data.match) &&
-          (fieldName ? (_b = (_a = focus === null || focus === void 0 ? void 0 : focus.data.match) === null || _a === void 0 ? void 0 : _a.includes(fieldName)) !== null && _b !== void 0 ? _b : true : true));
+  function useIsEager() {
+      return useIsMode(exports.Modes.EAGER);
   }
-
-  /**
-   * Checks if context has included tests
-   */
-  function useHasOnliedTests(testObject, fieldName) {
-      return vestUtils.isNotNullish(vestjsRuntime.Walker.findClosest(testObject, (child) => {
-          if (!FocusSelectors.isIsolateFocused(child))
-              return false;
-          return FocusSelectors.isOnlyFocused(child, fieldName);
-      }));
+  function useIsOne() {
+      return useIsMode(exports.Modes.ONE);
+  }
+  function useShouldSkipBasedOnMode(testData) {
+      if (useIsOne()) {
+          return hasErrorsByTestObjects();
+      }
+      if (useIsEager()) {
+          return hasErrorsByTestObjects(testData.fieldName);
+      }
+      return false;
   }
 
   //Checks whether a certain test profile excluded by any of the exclusion groups.
@@ -1380,304 +1277,409 @@
       return testNode;
   }
 
-  class IsolateTestReconciler extends IsolateReconciler {
-      static match(currentNode, historyNode) {
-          return VestTest.is(currentNode) && VestTest.is(historyNode);
+  // eslint-disable-next-line max-statements
+  function useAttemptRunTest(testObject) {
+      useVerifyTestRun(testObject);
+      if (VestTest.isUntested(testObject)) {
+          return useRunTest(testObject);
       }
-      static reconcile(currentNode, historyNode) {
-          const reconcilerOutput = usePickNode(historyNode, currentNode);
-          cancelOverriddenPendingTestOnTestReRun(reconcilerOutput, currentNode, historyNode);
-          return reconcilerOutput;
+      if (!VestTest.isNonActionable(testObject)) {
+          // Probably unreachable. If we get here, it means that
+          // something was really wrong and should be reported.
+          /* istanbul ignore next */
+          vestUtils.deferThrow(vestUtils.text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
+              testObject: JSON.stringify(testObject),
+          }));
       }
   }
-  function usePickNode(historyNode, currentNode) {
-      const collisionResult = handleCollision(currentNode, historyNode);
-      return useVerifyTestRun(currentNode, collisionResult);
+  function runSyncTest(testObject) {
+      return SuiteContext.run({ currentTest: testObject }, () => {
+          let result;
+          const { message, testFn } = VestTest.getData(testObject);
+          try {
+              result = testFn({ signal: testObject.abortController.signal });
+          }
+          catch (error) {
+              if (shouldUseErrorAsMessage(message, error)) {
+                  VestTest.getData(testObject).message = error;
+              }
+              result = false;
+          }
+          if (result === false) {
+              VestTest.fail(testObject);
+          }
+          return result;
+      });
   }
-  function handleCollision(newNode, prevNode) {
-      if (vestjsRuntime.IsolateInspector.usesKey(newNode)) {
-          return VestTest.cast(vestjsRuntime.Reconciler.handleIsolateNodeWithKey(newNode));
-      }
-      if (vestjsRuntime.Reconciler.dropNextNodesOnReorder(nodeReorderDetected, newNode, prevNode)) {
-          throwTestOrderError(newNode, prevNode);
-          return newNode;
+  /**
+   * runs test, if async - adds to pending array
+   */
+  function useRunTest(testObject) {
+      // Run test callback.
+      // If a promise is returned, set as async and
+      // Move to pending list.
+      const result = runSyncTest(testObject);
+      try {
+          // try catch for safe property access
+          // in case object is an enforce chain
+          if (vestUtils.isPromise(result)) {
+              VestTest.getData(testObject).asyncTest = result;
+              return useRunAsyncTest(testObject);
+          }
+          onTestCompleted(testObject);
       }
-      if (!VestTest.is(prevNode)) {
-          // I believe we cannot actually reach this point.
-          // Because it should already be handled by nodeReorderDetected.
+      catch (e) {
+          // Probably unreachable. If we get here, it means that
+          // something was really wrong and should be reported.
           /* istanbul ignore next */
-          return newNode;
+          throw new Error(vestUtils.text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
+              testObject: JSON.stringify(testObject),
+              error: e,
+          }));
       }
-      // FIXME: May-13-2023
-      // This may not be the most ideal solution.
-      // In short: if the node was omitted in the previous run,
-      // we want to re-evaluate it. The reason is that we may incorrectly
-      // identify it is "optional" because it was omitted in the previous run.
-      // There may be a better way to handle this. Need to revisit this.
-      if (VestTest.isOmitted(prevNode)) {
-          return newNode;
+  }
+  /**
+   * Runs async test.
+   */
+  function useRunAsyncTest(testObject) {
+      const { asyncTest, message } = VestTest.getData(testObject);
+      if (!vestUtils.isPromise(asyncTest))
+          return;
+      // VestTest.setPending(testObject);
+      const done = vestjsRuntime.VestRuntime.persist(() => {
+          onTestCompleted(testObject);
+      });
+      const fail = vestjsRuntime.VestRuntime.persist((rejectionMessage) => {
+          if (VestTest.isCanceled(testObject)) {
+              return;
+          }
+          VestTest.getData(testObject).message = vestUtils.isStringValue(rejectionMessage)
+              ? rejectionMessage
+              : message;
+          VestTest.fail(testObject);
+          done();
+      });
+      return asyncTest.then(done, fail);
+  }
+  function onTestCompleted(testObject) {
+      // Attempts passing if the test is not already failed.
+      // or is not canceled/omitted.
+      VestTest.pass(testObject);
+  }
+
+  // @vx-allow use-use
+  function wrapTestMemo(test) {
+      function memo(fieldName, ...args) {
+          const [deps, testFn, msg] = args.reverse();
+          // Implicit dependency for better specificity
+          const dependencies = [
+              useSuiteId(),
+              fieldName,
+              vestjsRuntime.VestRuntime.useCurrentCursor(),
+          ].concat(deps);
+          return useGetTestFromCache(dependencies, cacheAction);
+          function cacheAction() {
+              return test(fieldName, msg, testFn);
+          }
       }
-      return prevNode;
+      return memo;
   }
-  function cancelOverriddenPendingTestOnTestReRun(nextNode, currentNode, prevTestObject) {
-      if (nextNode === currentNode && VestTest.is(currentNode)) {
-          cancelOverriddenPendingTest(prevTestObject, currentNode);
+  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 (VestTest.isCanceled(cachedValue)) {
+          // cache hit, but test is canceled
+          cache.invalidate(dependencies);
+          return cache(dependencies, cacheAction);
       }
+      vestjsRuntime.VestRuntime.addNodeToHistory(cachedValue);
+      return cachedValue;
   }
-  function nodeReorderDetected(newNode, prevNode) {
-      return VestTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
+
+  // @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 testObjectInput = { fieldName, groupName, message, testFn };
+      // This invalidates the suite cache.
+      vestjsRuntime.Bus.useEmit(Events.TEST_RUN_STARTED);
+      return IsolateTest(useAttemptRunTest, testObjectInput, key);
   }
-  function throwTestOrderError(newNode, prevNode) {
-      if (vestjsRuntime.IsolateInspector.canReorder(newNode)) {
-          return;
-      }
-      vestUtils.deferThrow(vestUtils.text(ErrorStrings.TESTS_CALLED_IN_DIFFERENT_ORDER, {
-          fieldName: VestTest.getData(newNode).fieldName,
-          prevName: VestTest.is(prevNode)
-              ? VestTest.getData(prevNode).fieldName
-              : undefined,
+  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 VestReconciler(currentNode, historyNode) {
-      var _a, _b;
-      return ((_b = (_a = [IsolateTestReconciler]
-          .find(reconciler => reconciler.match(currentNode, historyNode))) === null || _a === void 0 ? void 0 : _a.reconcile(currentNode, historyNode)) !== null && _b !== void 0 ? _b : null);
+  // import { optional, skipWhen, omitWhen, IsolateTest, group } from 'vest';
+  function getTypedMethods() {
+      return {
+          group,
+          include,
+          omitWhen,
+          only,
+          optional,
+          skip,
+          skipWhen,
+          test,
+      };
   }
 
-  function group(...args) {
-      const [callback, groupName] = args.reverse();
-      return vestjsRuntime.Isolate.create(VestIsolateType.Group, () => {
-          return SuiteContext.run(Object.assign({}, (groupName && { groupName })), callback);
+  /**
+   * This module gets triggered once the suite is done running its sync tests.
+   *
+   * It goes over all the tests in the state, and checks if they need to be omitted.
+   */
+  function useOmitOptionalFields() {
+      const root = vestjsRuntime.VestRuntime.useAvailableRoot();
+      const optionalFields = SuiteOptionalFields.getOptionalFields(root);
+      // 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
+      const shouldOmit = new Set();
+      // iterate over each of the tests in the state
+      TestWalker.walkTests(testObject => {
+          if (VestTest.isPending(testObject)) {
+              return;
+          }
+          const { fieldName } = VestTest.getData(testObject);
+          // If we already added the current field (not this test specifically)
+          // no need for further checks, go and omit the test
+          if (shouldOmit.has(fieldName)) {
+              verifyAndOmit(testObject);
+          }
+          else {
+              // check if the field has an optional function
+              // if so, run it and verify/omit the test
+              runOptionalConfig(testObject);
+          }
       });
+      vestjsRuntime.Bus.useEmit(Events.DONE_TEST_OMISSION_PASS);
+      function verifyAndOmit(testObject) {
+          const { fieldName } = VestTest.getData(testObject);
+          if (shouldOmit.has(fieldName)) {
+              VestTest.omit(testObject);
+              SuiteOptionalFields.setOptionalField(root, fieldName, current => (Object.assign(Object.assign({}, current), { applied: true })));
+          }
+      }
+      function runOptionalConfig(testObject) {
+          const { fieldName } = VestTest.getData(testObject);
+          // Ge the optional configuration for the given field
+          const optionalConfig = SuiteOptionalFields.getOptionalField(root, fieldName);
+          // If the optional was set to a function or a boolean, run it and verify/omit the test
+          if (vestUtils.optionalFunctionValue(optionalConfig.rule) === true) {
+              shouldOmit.add(fieldName);
+          }
+          verifyAndOmit(testObject);
+      }
   }
 
   /**
-   * Conditionally includes a field for testing, based on specified criteria.
-   *
-   * @param {string} fieldName - The name of the field to include for testing.
-   *
-   * @example
-   * include('confirm').when('password');
-   * // Includes the "confirm" field for testing when the "password" field is included
-   *
-   * include('confirm').when(someValue);
-   * // Includes the "confirm" field for testing when the value of `someValue` is true
-   *
-   * include('confirm').when(() => someValue);
-   * // Includes the "confirm" field for testing when the callback function returns true
-   *
-   * include('username').when(result => result.hasErrors('username'));
-   * // Includes the "username" field for testing when there are errors associated with it in the current suite result
+   * Runs done callback per field when async tests are finished running.
    */
-  // @vx-allow use-use
-  function include(fieldName) {
-      vestUtils.invariant(vestUtils.isStringValue(fieldName));
-      const inclusion = useInclusion();
-      inclusion[fieldName] = true;
-      return { when };
-      /**
-       * Specifies the inclusion criteria for the field in `include` function.
-       */
-      function when(condition) {
-          vestUtils.invariant(condition !== fieldName, ErrorStrings.INCLUDE_SELF);
-          const inclusion = useInclusion();
-          // This callback will run as part of the "isExcluded" series of checks
-          inclusion[fieldName] = function isIncluded(currentNode) {
-              if (vestUtils.isStringValue(condition)) {
-                  return useHasOnliedTests(currentNode, condition);
-              }
-              return vestUtils.optionalFunctionValue(condition, vestUtils.optionalFunctionValue(useCreateSuiteResult));
-          };
+  function useRunFieldCallbacks(fieldName) {
+      const [fieldCallbacks] = useFieldCallbacks();
+      if (fieldName &&
+          !SuiteWalker.hasRemainingWithTestNameMatching(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);
+  }
+
+  // eslint-disable-next-line max-statements, max-lines-per-function
+  function useInitVestBus() {
+      const VestBus = vestjsRuntime.Bus.useBus();
+      // Report a the completion of a test. There may be other tests with the same
+      // name that are still running, or not yet started.
+      on(Events.TEST_COMPLETED, (testObject) => {
+          if (VestTest.isCanceled(testObject)) {
+              return;
+          }
+          const { fieldName } = VestTest.getData(testObject);
+          useRunFieldCallbacks(fieldName);
+      });
+      on(Events.TEST_RUN_STARTED, () => {
+          /* Let's just invalidate the suite cache for now */
+      });
+      on(vestjsRuntime.RuntimeEvents.ISOLATE_PENDING, (isolate) => {
+          if (VestTest.is(isolate)) {
+              VestTest.setPending(isolate);
+          }
+          setPending(isolate);
+      });
+      on(vestjsRuntime.RuntimeEvents.ISOLATE_DONE, (isolate) => {
+          if (VestTest.is(isolate)) {
+              VestBus.emit(Events.TEST_COMPLETED, isolate);
+          }
+          setDone(isolate);
+          if (!SuiteWalker.hasPending()) {
+              // When no more tests are running, emit the done event
+              VestBus.emit(Events.ALL_RUNNING_TESTS_FINISHED);
+          }
+      });
+      on(Events.DONE_TEST_OMISSION_PASS, () => {
+          /* We NEED to refresh the cache here. Don't ask */
+      });
+      // Called when all the tests, including async, are done running
+      on(Events.ALL_RUNNING_TESTS_FINISHED, () => {
+          // Small optimization. We don't need to run this if there are no async tests
+          // The reason is that we run this function immediately after the suite callback
+          // is run, so if the suite is only comprised of sync tests, we don't need to
+          // run this function twice since we know for a fact the state is up to date
+          if (TestWalker.someTests(VestTest.isAsyncTest)) {
+              useOmitOptionalFields();
+          }
+          useRunDoneCallbacks();
+      });
+      on(Events.RESET_FIELD, (fieldName) => {
+          TestWalker.resetField(fieldName);
+      });
+      on(Events.SUITE_RUN_STARTED, () => {
+          useResetCallbacks();
+      });
+      on(Events.SUITE_CALLBACK_RUN_FINISHED, () => {
+          useOmitOptionalFields();
+      });
+      on(Events.REMOVE_FIELD, (fieldName) => {
+          TestWalker.removeTestByFieldName(fieldName);
+      });
+      on(Events.RESET_SUITE, () => {
+          useResetSuite();
+      });
+      return {
+          subscribe,
+      };
+      function subscribe(cb) {
+          return VestBus.on('*', () => {
+              cb();
+          }).off;
+      }
+      function on(event, cb) {
+          VestBus.on(event, (...args) => {
+              // This is more concise, but it might be an overkill
+              // if we're adding events that don't need to invalidate the cache
+              useExpireSuiteResultCache();
+              cb(...args);
+          });
       }
   }
 
-  function IsolateTest(callback, input, key) {
-      const payload = Object.assign(Object.assign({}, IsolateTestBase()), { fieldName: input.fieldName, testFn: input.testFn });
-      if (input.groupName) {
-          payload.groupName = input.groupName;
+  class IsolateReconciler {
+      static match(_currentNode, _historyNode) {
+          return false;
       }
-      if (input.message) {
-          payload.message = input.message;
+      static reconcile(currentNode, historyNode) {
+          return (currentNode !== null && currentNode !== void 0 ? currentNode : historyNode);
       }
-      const isolate = vestjsRuntime.Isolate.create(VestIsolateType.Test, callback, payload, key !== null && key !== void 0 ? key : null);
-      return isolate;
   }
-  function IsolateTestBase() {
-      return {
-          severity: TestSeverity.Error,
-          status: IsolateTestStateMachine.initial(),
-      };
+
+  function isSameProfileTest(testObject1, testObject2) {
+      const { groupName: gn1 } = VestTest.getData(testObject1);
+      const { groupName: gn2, fieldName: fn2 } = VestTest.getData(testObject2);
+      return (matchingFieldName(VestTest.getData(testObject1), fn2) &&
+          gn1 === gn2 &&
+          // Specifically using == here. The reason is that when serializing
+          // suite result, empty key gets removed, but it can also be null.
+          testObject1.key == testObject2.key);
   }
 
-  function shouldUseErrorAsMessage(message, error) {
-      // kind of cheating with this safe guard, but it does the job
-      return vestUtils.isUndefined(message) && vestUtils.isStringValue(error);
+  function cancelOverriddenPendingTest(prevRunTestObject, currentRunTestObject) {
+      if (currentRunTestObject !== prevRunTestObject &&
+          isSameProfileTest(prevRunTestObject, currentRunTestObject) &&
+          VestTest.isPending(prevRunTestObject)) {
+          VestTest.cancel(prevRunTestObject);
+      }
   }
 
-  // eslint-disable-next-line max-statements
-  function useAttemptRunTest(testObject) {
-      useVerifyTestRun(testObject);
-      if (VestTest.isUntested(testObject)) {
-          return useRunTest(testObject);
+  class IsolateTestReconciler extends IsolateReconciler {
+      static match(currentNode, historyNode) {
+          return VestTest.is(currentNode) && VestTest.is(historyNode);
       }
-      if (!VestTest.isNonActionable(testObject)) {
-          // Probably unreachable. If we get here, it means that
-          // something was really wrong and should be reported.
-          /* istanbul ignore next */
-          vestUtils.deferThrow(vestUtils.text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
-              testObject: JSON.stringify(testObject),
-          }));
+      static reconcile(currentNode, historyNode) {
+          const reconcilerOutput = usePickNode(historyNode, currentNode);
+          cancelOverriddenPendingTestOnTestReRun(reconcilerOutput, currentNode, historyNode);
+          return reconcilerOutput;
       }
   }
-  function runSyncTest(testObject) {
-      return SuiteContext.run({ currentTest: testObject }, () => {
-          let result;
-          const { message, testFn } = VestTest.getData(testObject);
-          try {
-              result = testFn({ signal: testObject.abortController.signal });
-          }
-          catch (error) {
-              if (shouldUseErrorAsMessage(message, error)) {
-                  VestTest.getData(testObject).message = error;
-              }
-              result = false;
-          }
-          if (result === false) {
-              VestTest.fail(testObject);
-          }
-          return result;
-      });
+  function usePickNode(historyNode, currentNode) {
+      const collisionResult = handleCollision(currentNode, historyNode);
+      return useVerifyTestRun(currentNode, collisionResult);
   }
-  /**
-   * runs test, if async - adds to pending array
-   */
-  function useRunTest(testObject) {
-      // Run test callback.
-      // If a promise is returned, set as async and
-      // Move to pending list.
-      const result = runSyncTest(testObject);
-      try {
-          // try catch for safe property access
-          // in case object is an enforce chain
-          if (vestUtils.isPromise(result)) {
-              VestTest.getData(testObject).asyncTest = result;
-              return useRunAsyncTest(testObject);
-          }
-          onTestCompleted(testObject);
+  function handleCollision(newNode, prevNode) {
+      if (vestjsRuntime.IsolateInspector.usesKey(newNode)) {
+          return VestTest.cast(vestjsRuntime.Reconciler.handleIsolateNodeWithKey(newNode, VestTest.isNonActionable));
       }
-      catch (e) {
-          // Probably unreachable. If we get here, it means that
-          // something was really wrong and should be reported.
+      if (vestjsRuntime.Reconciler.dropNextNodesOnReorder(nodeReorderDetected, newNode, prevNode)) {
+          throwTestOrderError(newNode, prevNode);
+          return newNode;
+      }
+      if (!VestTest.is(prevNode)) {
+          // I believe we cannot actually reach this point.
+          // Because it should already be handled by nodeReorderDetected.
           /* istanbul ignore next */
-          throw new Error(vestUtils.text(ErrorStrings.UNEXPECTED_TEST_REGISTRATION_ERROR, {
-              testObject: JSON.stringify(testObject),
-              error: e,
-          }));
+          return newNode;
       }
-  }
-  /**
-   * Runs async test.
-   */
-  function useRunAsyncTest(testObject) {
-      const { asyncTest, message } = VestTest.getData(testObject);
-      if (!vestUtils.isPromise(asyncTest))
-          return;
-      // VestTest.setPending(testObject);
-      const done = vestjsRuntime.VestRuntime.persist(() => {
-          onTestCompleted(testObject);
-      });
-      const fail = vestjsRuntime.VestRuntime.persist((rejectionMessage) => {
-          if (VestTest.isCanceled(testObject)) {
-              return;
-          }
-          VestTest.getData(testObject).message = vestUtils.isStringValue(rejectionMessage)
-              ? rejectionMessage
-              : message;
-          VestTest.fail(testObject);
-          done();
-      });
-      return asyncTest.then(done, fail);
-  }
-  function onTestCompleted(testObject) {
-      // Attempts passing if the test is not already failed.
-      // or is not canceled/omitted.
-      VestTest.pass(testObject);
-  }
-
-  // @vx-allow use-use
-  function wrapTestMemo(test) {
-      function memo(fieldName, ...args) {
-          const [deps, testFn, msg] = args.reverse();
-          // Implicit dependency for better specificity
-          const dependencies = [
-              useSuiteId(),
-              fieldName,
-              vestjsRuntime.VestRuntime.useCurrentCursor(),
-          ].concat(deps);
-          return useGetTestFromCache(dependencies, cacheAction);
-          function cacheAction() {
-              return test(fieldName, msg, testFn);
-          }
+      // FIXME: May-13-2023
+      // This may not be the most ideal solution.
+      // In short: if the node was omitted in the previous run,
+      // we want to re-evaluate it. The reason is that we may incorrectly
+      // identify it is "optional" because it was omitted in the previous run.
+      // There may be a better way to handle this. Need to revisit this.
+      if (VestTest.isOmitted(prevNode)) {
+          return newNode;
       }
-      return memo;
+      return prevNode;
   }
-  function useGetTestFromCache(dependencies, cacheAction) {
-      const cache = useTestMemoCache();
-      const cached = cache.get(dependencies);
-      if (vestUtils.isNull(cached)) {
-          // cache miss
-          return cache(dependencies, cacheAction);
-      }
-      const [, cachedValue] = cached;
-      if (VestTest.isCanceled(cachedValue)) {
-          // cache hit, but test is canceled
-          cache.invalidate(dependencies);
-          return cache(dependencies, cacheAction);
+  function cancelOverriddenPendingTestOnTestReRun(nextNode, currentNode, prevTestObject) {
+      if (nextNode === currentNode && VestTest.is(currentNode)) {
+          cancelOverriddenPendingTest(prevTestObject, currentNode);
       }
-      vestjsRuntime.VestRuntime.addNodeToHistory(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 testObjectInput = { fieldName, groupName, message, testFn };
-      // This invalidates the suite cache.
-      vestjsRuntime.Bus.useEmit(Events.TEST_RUN_STARTED);
-      return IsolateTest(useAttemptRunTest, testObjectInput, key);
+  function nodeReorderDetected(newNode, prevNode) {
+      return VestTest.is(prevNode) && !isSameProfileTest(prevNode, newNode);
   }
-  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 throwTestOrderError(newNode, prevNode) {
+      if (vestjsRuntime.IsolateInspector.canReorder(newNode)) {
+          return;
+      }
+      vestUtils.deferThrow(vestUtils.text(ErrorStrings.TESTS_CALLED_IN_DIFFERENT_ORDER, {
+          fieldName: VestTest.getData(newNode).fieldName,
+          prevName: VestTest.is(prevNode)
+              ? VestTest.getData(prevNode).fieldName
+              : undefined,
       }));
   }
 
-  // import { optional, skipWhen, omitWhen, IsolateTest, group } from 'vest';
-  function getTypedMethods() {
-      return {
-          group,
-          include,
-          omitWhen,
-          only,
-          optional,
-          skip,
-          skipWhen,
-          test,
-      };
+  function VestReconciler(currentNode, historyNode) {
+      var _a, _b;
+      return ((_b = (_a = [IsolateTestReconciler]
+          .find(reconciler => reconciler.match(currentNode, historyNode))) === null || _a === void 0 ? void 0 : _a.reconcile(currentNode, historyNode)) !== null && _b !== void 0 ? _b : null);
   }
 
   function useDeferDoneCallback(doneCallback, fieldName) {
@@ -1732,6 +1734,7 @@
   }
 
   // @vx-allow use-use
+  // eslint-disable-next-line max-lines-per-function
   function createSuite(...args) {
       const [suiteCallback, suiteName] = args.reverse();
       validateSuiteCallback(suiteCallback);
@@ -1746,6 +1749,7 @@
               return IsolateSuite(useRunSuiteCallback(suiteCallback, ...args));
           }).output;
       }
+      const mountedStatic = staticSuite(...args);
       // Assign methods to the suite
       // We do this within the VestRuntime so that the suite methods
       // will be bound to the suite's stateRef and be able to access it.
@@ -1755,7 +1759,7 @@
           return vestUtils.assign(
           // We're also binding the suite to the stateRef, so that the suite
           // can access the stateRef when it's called.
-          vestjsRuntime.VestRuntime.persist(suite), Object.assign(Object.assign({ dump: vestjsRuntime.VestRuntime.persist(() => vestjsRuntime.VestRuntime.useAvailableRoot()), get: vestjsRuntime.VestRuntime.persist(useCreateSuiteResult), remove: vestjsRuntime.Bus.usePrepareEmitter(Events.REMOVE_FIELD), reset: vestjsRuntime.Bus.usePrepareEmitter(Events.RESET_SUITE), resetField: vestjsRuntime.Bus.usePrepareEmitter(Events.RESET_FIELD), resume: vestjsRuntime.VestRuntime.persist(useLoadSuite), subscribe: VestBus.subscribe }, bindSuiteSelectors(vestjsRuntime.VestRuntime.persist(useCreateSuiteResult))), getTypedMethods()));
+          vestjsRuntime.VestRuntime.persist(suite), Object.assign(Object.assign({ dump: vestjsRuntime.VestRuntime.persist(() => vestjsRuntime.VestRuntime.useAvailableRoot()), get: vestjsRuntime.VestRuntime.persist(useCreateSuiteResult), remove: vestjsRuntime.Bus.usePrepareEmitter(Events.REMOVE_FIELD), reset: vestjsRuntime.Bus.usePrepareEmitter(Events.RESET_SUITE), resetField: vestjsRuntime.Bus.usePrepareEmitter(Events.RESET_FIELD), resume: vestjsRuntime.VestRuntime.persist(useLoadSuite), runStatic: (...args) => mountedStatic(...args), subscribe: VestBus.subscribe }, bindSuiteSelectors(vestjsRuntime.VestRuntime.persist(useCreateSuiteResult))), getTypedMethods()));
       });
   }
   function useRunSuiteCallback(suiteCallback, ...args) {
@@ -1766,6 +1770,17 @@
           return useSuiteRunResult();
       };
   }
+  // @vx-allow use-use
+  // eslint-disable-next-line max-lines-per-function
+  function staticSuite(...createArgs) {
+      return vestUtils.assign((...args) => {
+          const suite = createSuite(...createArgs);
+          const result = suite(...args);
+          return Object.freeze(vestUtils.assign({
+              dump: suite.dump,
+          }, result));
+      }, Object.assign({}, getTypedMethods()));
+  }
 
   function IsolateEach(callback) {
       return vestjsRuntime.Isolate.create(VestIsolateType.Each, callback, {
@@ -1795,33 +1810,6 @@
       });
   }
 
-  /**
-   * Creates a static suite for server-side validation.
-   *
-   * @param {Function} validationFn - The validation function that defines the suite's tests.
-   * @returns {Function} - A function that runs the validations defined in the suite.
-   *
-   * @example
-   * import { staticSuite, test, enforce } from 'vest';
-   *
-   * const suite = staticSuite(data => {
-   *   test('username', 'username is required', () => {
-   *     enforce(data.username).isNotEmpty();
-   *   });
-   * });
-   *
-   * suite(data);
-   */
-  function staticSuite(suiteCallback) {
-      return vestUtils.assign((...args) => {
-          const suite = createSuite(suiteCallback);
-          const result = suite(...args);
-          return Object.freeze(vestUtils.assign({
-              dump: suite.dump,
-          }, result));
-      }, Object.assign({}, getTypedMethods()));
-  }
-
   const ERROR_OUTSIDE_OF_TEST = ErrorStrings.WARN_MUST_BE_CALLED_FROM_TEST;
   /**
    * Sets the severity level of a test to `warn`, allowing it to fail without marking the suite as invalid.