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

package/dist/umd/vest.development.js

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