@flemist/test-variants 5.0.12 → 5.0.13

package/build/createTestVariants-Bbto3Xye.mjs

@@ -0,0 +1,1103 @@
+import { timeControllerDefault as F } from "@flemist/time-controller";
+import { formatAny as ge, Subject as Je, deepCloneJsonLike as Xe } from "@flemist/simple-utils";
+import { combineAbortSignals as X, isPromiseLike as O, abortSignalToPromise as Ze, waitMicrotasks as Ke } from "@flemist/async-utils";
+import { AbortError as Qe, AbortControllerFast as Z } from "@flemist/abort-controller-fast";
+import { poolWait as ae, Pool as Ye } from "@flemist/time-limits";
+class et extends Error {
+}
+function re() {
+  if (typeof process < "u" && process.memoryUsage)
+    try {
+      return process.memoryUsage.rss();
+    } catch {
+    }
+  if (typeof performance < "u") {
+    const e = performance.memory;
+    if (e)
+      try {
+        return e.usedJSHeapSize;
+      } catch {
+      }
+  }
+  return null;
+}
+const tt = 1e3, B = [];
+function rt(e) {
+  return ge(e, { pretty: !0, maxDepth: 5, maxItems: 50 });
+}
+function nt(...e) {
+  const r = e.map((t) => typeof t == "string" ? t : rt(t)).join(" ");
+  B.push(r), B.length > tt && B.shift(), console.log(r);
+}
+function ot() {
+  return B.join(`
+`);
+}
+globalThis.__getStressTestLogLast = ot;
+const pe = (e, r) => {
+  nt(r);
+}, he = (e) => ge(e, {
+  pretty: !0,
+  maxDepth: 20,
+  maxItems: 100,
+  maxStringLength: 5e3,
+  dontExpandClassInstances: !0,
+  dontExpandFunctions: !0
+}), T = {
+  start: !0,
+  progress: 5e3,
+  completed: !0,
+  error: !0,
+  modeChange: !0,
+  debug: !1,
+  func: pe,
+  format: he
+}, it = {
+  start: !1,
+  progress: !1,
+  completed: !1,
+  error: !1,
+  modeChange: !1,
+  debug: !1,
+  func: pe,
+  format: he
+};
+function be(e) {
+  return e === !1 ? it : e === !0 || !e ? T : {
+    start: e.start ?? T.start,
+    progress: e.progress ?? T.progress,
+    completed: e.completed ?? T.completed,
+    error: e.error ?? T.error,
+    modeChange: e.modeChange ?? T.modeChange,
+    debug: e.debug ?? T.debug,
+    func: e.func ?? T.func,
+    format: e.format ?? T.format
+  };
+}
+function st(e, r) {
+  const t = e.now();
+  return {
+    startTime: t,
+    startMemory: r,
+    debugMode: !1,
+    tests: 0,
+    iterations: 0,
+    iterationsAsync: 0,
+    prevLogTime: t,
+    prevLogMemory: r,
+    pendingModeChange: null,
+    prevGcTime: t,
+    prevGcIterations: 0,
+    prevGcIterationsAsync: 0
+  };
+}
+class V extends Qe {
+}
+class lt {
+  _timeController;
+  _subject;
+  _interval;
+  _timer;
+  constructor(r, t) {
+    this._interval = r, this._timeController = t ?? F, this._subject = new Je({
+      startStopNotifier: () => (this.update(), () => {
+        this._timeController.clearTimeout(this._timer);
+      })
+    });
+  }
+  update() {
+    this._subject.emit(this._timeController.now()), this._timer = this._timeController.setTimeout(
+      () => this.update(),
+      this._interval
+    );
+  }
+  get interval() {
+    return this._interval;
+  }
+  set interval(r) {
+    this._interval = r, this._timer && (this._timeController.clearTimeout(this._timer), this.update());
+  }
+  subscribe(r) {
+    return this._subject.subscribe(r);
+  }
+}
+const at = 50, ut = 5;
+function ct(e, r) {
+  return e == null ? null : typeof e == "number" ? e : e(r) ?? null;
+}
+function ue(e, r) {
+  return typeof e == "number" ? { iterationsAsync: 0, iterationsSync: e } : e != null && typeof e == "object" ? e : r ? { iterationsAsync: 1, iterationsSync: 0 } : { iterationsAsync: 0, iterationsSync: 1 };
+}
+function ft(e, r) {
+  const t = r.log, i = r.pauseDebuggerOnError ?? !0, o = r.onStart, s = r.onEnd;
+  let n = null, a = 0;
+  function c(m, h, y) {
+    n == null && (n = { error: m, args: h, tests: y }, t.error && t.func(
+      "error",
+      `[test-variants] error variant: ${t.format(h)}
+tests: ${y}
+${t.format(m)}`
+    ));
+    const d = Date.now();
+    if (i)
+      debugger;
+    if (Date.now() - d > at && a < ut) {
+      t.func(
+        "debug",
+        `[test-variants] debug iteration: ${a}`
+      ), a++;
+      return;
+    }
+    const v = n;
+    throw n = null, r.onError && r.onError(v), v.error;
+  }
+  const g = new lt(100);
+  return function(h, y, d) {
+    o && o({ args: h, tests: y });
+    const b = ct(r.timeout, h);
+    let v = null, M = d, f = null;
+    b && (v = Date.now(), f = new Z(), M = {
+      abortSignal: X(
+        d.abortSignal,
+        f.signal
+      ),
+      timeController: d.timeController
+    });
+    function E() {
+      f.abort(
+        new et(
+          `[test-variants] test timeout ${b}ms exceeded`
+        )
+      );
+    }
+    try {
+      let S = e(h, M);
+      if (O(S)) {
+        let x = null;
+        return f && (x = g.subscribe(() => {
+          Date.now() - v >= b && (E(), x());
+        }), S = Promise.race([
+          S,
+          Ze(f.signal)
+        ])), S.then(
+          (A) => {
+            x?.();
+            const G = ue(A, !0);
+            return s && s({ args: h, tests: y, result: G }), G;
+          },
+          (A) => (x?.(), s && !(A instanceof V) && s({ args: h, tests: y, error: A }), c(A, h, y))
+        );
+      }
+      v != null && Date.now() - v >= b && (E(), f.signal.throwIfAborted());
+      const C = ue(S, !1);
+      return s && s({ args: h, tests: y, result: C }), C;
+    } catch (S) {
+      return S instanceof V ? void 0 : (s && s({ args: h, tests: y, error: S }), c(S, h, y));
+    }
+  };
+}
+function k(e, r, t) {
+  for (let i = 0, o = e.length; i < o; i++)
+    if (t ? t(e[i], r) : e[i] === r)
+      return i;
+  return -1;
+}
+function ce(e, r, t, i) {
+  const o = Object.keys(e.templates), s = {}, n = [], a = [], c = [], g = o.length;
+  for (let m = 0; m < g; m++) {
+    const h = o[m];
+    s[h] = void 0, n.push(-1), a.push(void 0), c.push(null);
+  }
+  return {
+    args: s,
+    argsNames: o,
+    indexes: n,
+    argValues: a,
+    argLimits: c,
+    attempts: 0,
+    templates: e,
+    limitArgOnError: t,
+    equals: r,
+    includeErrorVariant: i ?? !1
+  };
+}
+function P(e, r) {
+  const t = e.templates.templates[r], i = e.templates.extra[r];
+  let o;
+  if (typeof t == "function" ? o = t(e.args) : o = t, i == null)
+    return o;
+  let s = null;
+  const n = i.length;
+  for (let a = 0; a < n; a++) {
+    const c = i[a];
+    k(o, c, e.equals) < 0 && (s == null ? s = [...o, c] : s.push(c));
+  }
+  return s ?? o;
+}
+function I(e, r, t) {
+  const i = e.argValues[r].length;
+  if (i === 0)
+    return -1;
+  const o = e.argLimits[r];
+  if (o == null)
+    return i - 1;
+  let s = e.limitArgOnError;
+  if (typeof s == "function") {
+    const n = e.argsNames[r];
+    s = s({
+      name: n,
+      values: e.argValues[r],
+      maxValueIndex: o
+    });
+  }
+  return !t || s ? Math.min(o, i - 1) : i - 1;
+}
+function L(e) {
+  const r = e.indexes.length;
+  for (let t = 0; t < r; t++) {
+    const i = e.argLimits[t];
+    if (i == null)
+      return !1;
+    const o = e.indexes[t];
+    if (o > i)
+      return !0;
+    if (o < i)
+      return !1;
+  }
+  return !e.includeErrorVariant;
+}
+function N(e) {
+  const r = e.indexes.length;
+  for (let t = 0; t < r; t++)
+    e.indexes[t] = -1, e.argValues[t] = void 0, e.args[e.argsNames[t]] = void 0;
+}
+function ye(e) {
+  let r = !1, t = !0;
+  const i = e.indexes.length;
+  let o = i, s = !1, n = 0;
+  for (; n < i; n++) {
+    const a = e.argValues[n] == null;
+    (a || s) && (a && (r = !0), e.argValues[n] = P(
+      e,
+      e.argsNames[n]
+    ));
+    const c = I(
+      e,
+      n,
+      n > o
+    );
+    if (c < 0) {
+      t = !1, e.indexes[n] = -1;
+      break;
+    }
+    a && (e.indexes[n] = 0, e.args[e.argsNames[n]] = e.argValues[n][0]), (s || e.indexes[n] > c) && (e.indexes[n] = c, e.args[e.argsNames[n]] = e.argValues[n][c], s = !0), o === i && e.indexes[n] < c && (o = n);
+  }
+  if (L(e))
+    return N(e), !1;
+  if (r && t)
+    return !0;
+  for (n--; n >= 0; n--) {
+    if (e.argValues[n] == null)
+      continue;
+    let a = n > o;
+    const c = I(e, n, a), g = e.indexes[n] + 1;
+    if (g <= c) {
+      e.indexes[n] = g, e.args[e.argsNames[n]] = e.argValues[n][g], g < c && (a = !0);
+      for (let m = n + 1; m < i; m++)
+        e.args[e.argsNames[m]] = void 0;
+      for (n++; n < i; n++) {
+        e.argValues[n] = P(
+          e,
+          e.argsNames[n]
+        );
+        const m = I(e, n, a);
+        if (m < 0)
+          break;
+        e.indexes[n] = 0, e.args[e.argsNames[n]] = e.argValues[n][0], m > 0 && (a = !0);
+      }
+      if (n >= i)
+        return L(e) ? (N(e), !1) : !0;
+    }
+  }
+  return N(e), !1;
+}
+function K(e) {
+  L(e) && N(e);
+  let r = !1, t = !0;
+  const i = e.indexes.length;
+  let o = i, s = !1, n = 0;
+  for (; n < i; n++) {
+    const a = e.argValues[n] == null;
+    (a || s) && (a && (r = !0), e.argValues[n] = P(
+      e,
+      e.argsNames[n]
+    ));
+    const c = I(
+      e,
+      n,
+      n > o
+    );
+    if (c < 0) {
+      t = !1, e.indexes[n] = -1;
+      break;
+    }
+    a && (e.indexes[n] = c, e.args[e.argsNames[n]] = e.argValues[n][c]), (s || e.indexes[n] > c) && (e.indexes[n] = c, e.args[e.argsNames[n]] = e.argValues[n][c], s = !0), o === i && e.indexes[n] < c && (o = n);
+  }
+  if ((r || s) && t && !L(e))
+    return !0;
+  for (n--; n >= 0; n--) {
+    if (e.argValues[n] == null)
+      continue;
+    let a = n > o;
+    const c = I(e, n, a);
+    let g = e.indexes[n] - 1;
+    if (g > c && (g = c), g >= 0) {
+      e.indexes[n] = g, e.args[e.argsNames[n]] = e.argValues[n][g], g < c && (a = !0);
+      for (let m = n + 1; m < i; m++)
+        e.args[e.argsNames[m]] = void 0;
+      for (n++; n < i; n++) {
+        e.argValues[n] = P(
+          e,
+          e.argsNames[n]
+        );
+        const m = I(e, n, a);
+        if (m < 0)
+          break;
+        e.indexes[n] = m, e.args[e.argsNames[n]] = e.argValues[n][m], m > 0 && (a = !0);
+      }
+      if (n >= i)
+        return !0;
+    }
+  }
+  return N(e), !1;
+}
+function mt(e, r) {
+  N(e);
+  const t = e.argsNames, i = t.length;
+  let o = !1;
+  for (let s = 0; s < i; s++) {
+    const n = t[s], a = r[n];
+    if (a === void 0)
+      return null;
+    e.argValues[s] = P(e, n);
+    const c = I(e, s, o);
+    if (c < 0)
+      return null;
+    const g = k(
+      e.argValues[s],
+      a,
+      e.equals
+    );
+    if (g < 0 || g > c)
+      return null;
+    e.indexes[s] = g, e.args[e.argsNames[s]] = e.argValues[s][g], e.indexes[s] < c && (o = !0);
+  }
+  return L(e) ? null : e.indexes.slice();
+}
+function dt(e) {
+  const r = e.indexes.length;
+  if (r === 0)
+    return !1;
+  let t = !1;
+  for (let i = 0; i < r; i++) {
+    e.argValues[i] = P(e, e.argsNames[i]);
+    const o = I(e, i, t);
+    if (o < 0)
+      return Math.random() < 0.5 ? ye(e) : K(e);
+    e.indexes[i] = Math.floor(Math.random() * (o + 1)), e.args[e.argsNames[i]] = e.argValues[i][e.indexes[i]], e.indexes[i] < o && (t = !0);
+  }
+  return L(e) ? K(e) : !0;
+}
+function U(e) {
+  return e.mode === "forward" || e.mode === "backward";
+}
+function gt(e, r, t, i) {
+  const o = r[t], s = e.templates[t];
+  if (typeof s != "function") {
+    if (k(s, o, i) >= 0)
+      return;
+    s.push(o);
+    return;
+  }
+  const n = e.extra[t];
+  if (n == null) {
+    e.extra[t] = [o];
+    return;
+  }
+  k(n, o, i) >= 0 || n.push(o);
+}
+function pt(e, r, t) {
+  for (const i in r)
+    if (Object.prototype.hasOwnProperty.call(r, i)) {
+      if (i === "seed")
+        continue;
+      gt(e, r, i, t);
+    }
+}
+function fe(e, r) {
+  for (const t in r)
+    if (Object.prototype.hasOwnProperty.call(r, t)) {
+      if (t === "seed")
+        continue;
+      if (!e[t])
+        return !1;
+    }
+  return !0;
+}
+const ht = [{ mode: "forward" }];
+function bt(e) {
+  const {
+    argsTemplates: r,
+    equals: t,
+    limitArgOnError: i,
+    includeErrorVariant: o,
+    getSeed: s,
+    iterationModes: n,
+    onModeChange: a,
+    limitCompletionCount: c,
+    limitTests: g,
+    limitTime: m
+  } = e, h = e.timeController ?? F, y = {
+    templates: Xe(r),
+    extra: {}
+  }, d = n == null || n.length === 0 ? ht : n, b = [];
+  let v = null, M = null, f = 0, E = 0, S = !1, C = 0;
+  function x() {
+    S || (S = !0, C = h.now(), A(), f = 0, ie(), xe());
+  }
+  function A() {
+    for (let l = 0, u = d.length; l < u; l++)
+      b.push(G());
+  }
+  function G() {
+    return {
+      navigationState: ce(
+        y,
+        t ?? null,
+        i ?? null,
+        o ?? null
+      ),
+      cycleCount: 0,
+      completedCount: 0,
+      testsInLastTurn: 0,
+      tryNextVariantAttempts: 0,
+      startTime: null
+    };
+  }
+  function xe() {
+    v = ce(
+      y,
+      t ?? null,
+      // Initial values; overwritten in calcIndexes before each use
+      !1,
+      !1
+    );
+  }
+  function ie() {
+    a?.({
+      mode: d[f],
+      modeIndex: f,
+      tests: E
+    });
+  }
+  function Te(l) {
+    x(), fe(y.templates, l) && pt(y, l, t);
+  }
+  function se(l, u) {
+    return x(), fe(y.templates, l) ? (v.limitArgOnError = u?.limitArg ?? i ?? null, v.includeErrorVariant = u?.includeLimit ?? o ?? !1, mt(v, l)) : null;
+  }
+  function Me(l) {
+    const u = l?.args;
+    if (u == null)
+      return;
+    x();
+    const p = se(u);
+    if (p != null) {
+      M = {
+        args: u,
+        error: l?.error,
+        tests: l?.tests ?? E
+      }, v.argLimits = p;
+      for (let w = 0, q = b.length; w < q; w++) {
+        const H = b[w].navigationState;
+        H.argLimits = p;
+      }
+    }
+  }
+  function Ie() {
+    return x(), Ve();
+  }
+  function Ve() {
+    for (; ; ) {
+      if (!Ce())
+        return null;
+      for (; ; ) {
+        const l = qe();
+        if (l != null)
+          return b[f].testsInLastTurn++, E++, l;
+        if (Pe()) {
+          if (!$e())
+            return null;
+          De();
+          break;
+        }
+      }
+    }
+  }
+  function Ce() {
+    return !(Ae() || Oe() || D() && (Le() || !_e()) || !Ne());
+  }
+  function Ae() {
+    return g != null && E >= g;
+  }
+  function Oe() {
+    return m != null && h.now() - C >= m;
+  }
+  function Le() {
+    if (!D())
+      throw new Error("Unexpected behavior");
+    return c != null && c <= 0;
+  }
+  function _e() {
+    if (!D())
+      throw new Error("Unexpected behavior");
+    for (let l = 0, u = d.length; l < u; l++)
+      if (_(d[l]) && W(l))
+        return !0;
+    return !1;
+  }
+  function Ne() {
+    for (let l = 0, u = d.length; l < u; l++)
+      if (W(l))
+        return !0;
+    return !1;
+  }
+  function Pe() {
+    f++;
+    const l = f >= d.length;
+    return l && (f = 0), ie(), l;
+  }
+  function $e() {
+    if (D()) {
+      const l = Ge();
+      if (c != null && l >= c)
+        return !1;
+    }
+    return !0;
+  }
+  function D() {
+    for (let l = 0, u = d.length; l < u; l++)
+      if (U(d[l]))
+        return !0;
+    return !1;
+  }
+  function Ge() {
+    let l = !1, u = 1 / 0;
+    for (let p = 0, w = b.length; p < w; p++) {
+      const q = b[p], H = d[p];
+      U(H) && (l = !0, W(p) && q.completedCount < u && (u = q.completedCount));
+    }
+    if (!l)
+      throw new Error("Unexpected behavior");
+    return u;
+  }
+  function W(l) {
+    const u = d[l], p = b[l];
+    return u.limitTests != null && u.limitTests <= 0 || _(u) && (u.cycles != null && u.cycles <= 0 || u.attemptsPerVariant != null && u.attemptsPerVariant <= 0) ? !1 : p.tryNextVariantAttempts < 2;
+  }
+  function De() {
+    f = 0;
+    for (let l = 0, u = b.length; l < u; l++) {
+      const p = b[l];
+      p.testsInLastTurn = 0, p.startTime = null;
+    }
+  }
+  function qe() {
+    let l = 0;
+    for (; l < 2; ) {
+      if (!Ue())
+        return null;
+      const u = Fe();
+      if (u != null)
+        return u;
+      if (_(d[f]) && je())
+        return null;
+      l++;
+    }
+    return null;
+  }
+  function Ue() {
+    const l = d[f];
+    return !(Be() || ke() || _(l) && !Re(f));
+  }
+  function Be() {
+    const l = d[f], u = b[f];
+    return l.limitTests != null && u.testsInLastTurn >= l.limitTests;
+  }
+  function ke() {
+    const l = d[f], u = b[f];
+    return l.limitTime != null && u.startTime != null && h.now() - u.startTime >= l.limitTime;
+  }
+  function _(l) {
+    return U(l);
+  }
+  function Re(l) {
+    const u = d[l], p = b[l];
+    if (!_(u))
+      throw new Error("Unexpected behavior");
+    return p.cycleCount < (u.cycles ?? 1);
+  }
+  function je() {
+    const l = d[f], u = b[f];
+    if (!_(l))
+      throw new Error("Unexpected behavior");
+    return u.cycleCount++, u.cycleCount >= (l.cycles ?? 1) ? (u.cycleCount = 0, u.completedCount++, !0) : !1;
+  }
+  function Fe() {
+    const l = d[f], u = b[f], p = u.navigationState;
+    if ($(l)) {
+      if (z())
+        return null;
+      const w = We();
+      if (w != null)
+        return u.startTime == null && (u.startTime = h.now()), w;
+    }
+    return He() ? (u.tryNextVariantAttempts = 0, $(l) && ze(), u.startTime == null && (u.startTime = h.now()), le(p.args)) : (u.tryNextVariantAttempts++, null);
+  }
+  function We() {
+    const l = d[f], p = b[f].navigationState;
+    if (!$(l))
+      throw new Error("Unexpected behavior");
+    if (z())
+      throw new Error("Unexpected behavior");
+    const w = l.attemptsPerVariant ?? 1;
+    return p.attempts > 0 && p.attempts < w ? L(p) ? null : (p.attempts++, le(p.args)) : null;
+  }
+  function ze() {
+    const l = d[f], p = b[f].navigationState;
+    if (!$(l))
+      throw new Error("Unexpected behavior");
+    if (z())
+      throw new Error("Unexpected behavior");
+    p.attempts = 1;
+  }
+  function $(l) {
+    return U(l);
+  }
+  function z() {
+    const l = d[f];
+    if (!$(l))
+      throw new Error("Unexpected behavior");
+    return (l.attemptsPerVariant ?? 1) <= 0;
+  }
+  function He() {
+    const l = d[f], p = b[f].navigationState;
+    switch (l.mode) {
+      case "forward":
+        return ye(p);
+      case "backward":
+        return K(p);
+      case "random":
+        return dt(p);
+      default:
+        throw new Error(`Unknown mode: ${l.mode}`);
+    }
+  }
+  function le(l) {
+    const u = { ...l };
+    return s != null && (u.seed = s({ tests: E })), u;
+  }
+  return {
+    get limit() {
+      return M;
+    },
+    get modeIndex() {
+      return f;
+    },
+    get modeConfigs() {
+      return d;
+    },
+    get modeStates() {
+      return b;
+    },
+    get tests() {
+      return E;
+    },
+    calcIndexes: se,
+    extendTemplates: Te,
+    addLimit: Me,
+    next: Ie
+  };
+}
+function ne(e) {
+  if (e == null || e <= 0)
+    throw new Error(`Iterations = ${e}`);
+  e--;
+  const r = Ke().then(() => e);
+  return e <= 0 ? r : r.then(ne);
+}
+function yt(e, r, t) {
+  const i = r.limit ? {
+    error: r.limit.error,
+    args: r.limit.args,
+    tests: r.limit.tests
+  } : null;
+  if (i && !t)
+    throw i.error;
+  return {
+    iterations: e.iterations,
+    bestError: i
+  };
+}
+const me = 2 ** 31;
+function vt(e) {
+  if (e == null)
+    return { parallel: 1, sequentialOnError: !1 };
+  if (typeof e == "boolean")
+    return {
+      parallel: e ? me : 1,
+      sequentialOnError: !1
+    };
+  if (typeof e == "number")
+    return { parallel: e > 0 ? e : 1, sequentialOnError: !1 };
+  const r = e.count;
+  let t = 1;
+  return r === !0 ? t = me : typeof r == "number" && r > 0 && (t = r), {
+    parallel: t,
+    sequentialOnError: e.sequentialOnError ?? !1
+  };
+}
+function St(e) {
+  const r = e?.saveErrorVariants, t = r && e.createSaveErrorVariantsStore ? e.createSaveErrorVariantsStore(r) : null, i = e?.findBestError, { parallel: o, sequentialOnError: s } = vt(
+    e?.parallel
+  );
+  return {
+    store: t,
+    GC_Iterations: e?.GC_Iterations ?? 1e6,
+    GC_IterationsAsync: e?.GC_IterationsAsync ?? 1e4,
+    GC_Interval: e?.GC_Interval ?? 1e3,
+    logOptions: be(e?.log),
+    abortSignalExternal: e?.abortSignal,
+    findBestError: i,
+    dontThrowIfError: i?.dontThrowIfError,
+    timeController: e?.timeController ?? F,
+    parallel: o,
+    sequentialOnError: s
+  };
+}
+function R(e, r, t) {
+  const { options: i, variantsIterator: o } = e, s = o.limit?.args ?? r;
+  if (!i.store)
+    return;
+  const n = i.store.save(s);
+  if (t)
+    return n;
+}
+function Et(e, r, t, i) {
+  const { abortControllerParallel: o, state: s, options: n } = e, { logOptions: a } = n;
+  if (e.options.findBestError)
+    e.variantsIterator.addLimit({ args: r, error: t, tests: i }), s.debugMode = !1, R(e, r, !1), n.sequentialOnError && !o.signal.aborted ? (a.debug && a.func(
+      "debug",
+      "[test-variants] sequentialOnError: aborting parallel, switching to sequential"
+    ), o.abort(new V())) : a.debug && a.func(
+      "debug",
+      "[test-variants] parallel error in findBestError mode, continuing with new limits"
+    );
+  else {
+    if (o.signal.aborted)
+      return;
+    R(e, r, !1), o.abort(t);
+  }
+}
+function de(e, r, t, i) {
+  const { state: o } = e;
+  if (e.options.findBestError) {
+    e.variantsIterator.addLimit({ args: r, error: t, tests: i });
+    const n = R(e, r, !0);
+    if (n)
+      return n.then(() => {
+        o.debugMode = !1;
+      });
+    o.debugMode = !1;
+    return;
+  }
+  const s = R(e, r, !0);
+  if (s)
+    return s.then(() => {
+      throw t;
+    });
+  throw t;
+}
+function wt(e, r) {
+  const { GC_Iterations: t, GC_IterationsAsync: i, GC_Interval: o } = e.options;
+  return t > 0 && e.state.iterations - e.state.prevGcIterations >= t || i > 0 && e.state.iterationsAsync - e.state.prevGcIterationsAsync >= i || o > 0 && r - e.state.prevGcTime >= o;
+}
+async function xt(e, r) {
+  e.prevGcIterations = e.iterations, e.prevGcIterationsAsync = e.iterationsAsync, e.prevGcTime = r, await ne(1);
+}
+function oe(e) {
+  const r = e / 1e3;
+  if (r < 60)
+    return `${r.toFixed(1)}s`;
+  const t = r / 60;
+  return t < 60 ? `${t.toFixed(1)}m` : `${(t / 60).toFixed(1)}h`;
+}
+function Q(e) {
+  const r = e / 1073741824;
+  if (r >= 1)
+    return r >= 10 ? `${Math.round(r)}GB` : `${r.toFixed(1)}GB`;
+  const t = e / (1024 * 1024);
+  return t >= 10 ? `${Math.round(t)}MB` : `${t.toFixed(1)}MB`;
+}
+function Tt(e, r) {
+  if (!e)
+    return `mode[${r}]: null`;
+  let t = `mode[${r}]: ${e.mode}`;
+  return (e.mode === "forward" || e.mode === "backward") && (e.cycles != null && (t += `, cycles=${e.cycles}`), e.attemptsPerVariant != null && (t += `, attempts=${e.attemptsPerVariant}`)), e.limitTime != null && (t += `, limitTime=${oe(e.limitTime)}`), e.limitTests != null && (t += `, limitTests=${e.limitTests}`), t;
+}
+function ve(e, r) {
+  const t = e - r, i = t >= 0 ? "+" : "";
+  return `${Q(e)} (${i}${Q(t)})`;
+}
+function Mt(e, r) {
+  if (!e.start)
+    return;
+  let t = "[test-variants] start";
+  r != null && (t += `, memory: ${Q(r)}`), e.func("start", t);
+}
+function It(e) {
+  const { options: r, state: t } = e, { logOptions: i, timeController: o } = r;
+  if (!i.completed)
+    return;
+  const s = o.now() - t.startTime;
+  let n = `[test-variants] end, tests: ${t.tests} (${oe(s)}), async: ${t.iterationsAsync}`;
+  if (t.startMemory != null) {
+    const a = re();
+    a != null && (n += `, memory: ${ve(a, t.startMemory)}`);
+  }
+  i.func("completed", n);
+}
+function Se(e) {
+  const { options: r, state: t } = e, { logOptions: i } = r, o = t.pendingModeChange;
+  !i.modeChange || o == null || (i.func(
+    "modeChange",
+    `[test-variants] ${Tt(o.mode, o.modeIndex)}`
+  ), t.pendingModeChange = null);
+}
+function Vt(e) {
+  const { options: r, state: t } = e, { logOptions: i, timeController: o } = r, s = o.now();
+  if (!i.progress || s - t.prevLogTime < i.progress)
+    return !1;
+  Se(e);
+  const n = s - t.startTime;
+  let a = `[test-variants] tests: ${t.tests} (${oe(n)}), async: ${t.iterationsAsync}`;
+  if (t.prevLogMemory != null) {
+    const c = re();
+    c != null && (a += `, memory: ${ve(c, t.prevLogMemory)}`, t.prevLogMemory = c);
+  }
+  return i.func("progress", a), t.prevLogTime = s, !0;
+}
+function Y(e, r) {
+  e.debugMode = !1, r && (e.iterationsAsync += r.iterationsAsync, e.iterations += r.iterationsSync + r.iterationsAsync);
+}
+function ee(e) {
+  e.state.debugMode = !0, e.abortControllerParallel.abort(new V());
+}
+function Ee(e, r) {
+  const { testRun: t, testOptions: i, state: o } = e, s = o.tests;
+  o.tests++;
+  try {
+    const n = t(r, s, i);
+    if (O(n))
+      return n.then(
+        (a) => {
+          if (!a) {
+            ee(e);
+            return;
+          }
+          Y(o, a);
+        },
+        (a) => de(e, r, a, s)
+      );
+    if (!n) {
+      ee(e);
+      return;
+    }
+    Y(o, n);
+  } catch (n) {
+    return n instanceof V ? void 0 : de(e, r, n, s);
+  }
+}
+function Ct(e, r) {
+  const { pool: t, abortSignal: i, testRun: o, testOptionsParallel: s, state: n } = e;
+  if (!t)
+    return;
+  const a = n.tests;
+  n.tests++, (async () => {
+    try {
+      if (i.aborted)
+        return;
+      let c = o(r, a, s);
+      if (O(c) && (c = await c), !c) {
+        ee(e);
+        return;
+      }
+      Y(n, c);
+    } catch (c) {
+      if (c instanceof V)
+        return;
+      Et(e, r, c, a);
+    } finally {
+      t.release(1);
+    }
+  })();
+}
+function we(e) {
+  const { options: r, state: t } = e, { logOptions: i, timeController: o, GC_Interval: s } = r;
+  if (!i.progress && !s)
+    return;
+  Vt(e);
+  const n = o.now();
+  if (wt(e, n))
+    return xt(t, n);
+}
+function j(e) {
+  return e.options.abortSignalExternal?.aborted ?? !1;
+}
+function te(e) {
+  return e.abortSignal.aborted;
+}
+async function J(e, r) {
+  const { pool: t, state: i, options: o } = e, { parallel: s, logOptions: n } = o;
+  let a = null;
+  for (; !j(e); ) {
+    const c = t && !te(e);
+    let g = !1;
+    c && (t.hold(1) || await ae({ pool: t, count: 1, hold: !0 }), g = !0);
+    try {
+      if (r != null ? (a = r, r = null) : e.state.debugMode || (a = e.variantsIterator.next()), a == null)
+        break;
+      const m = we(e);
+      if (O(m) && await m, j(e))
+        continue;
+      if (c)
+        Ct(e, a), g = !1;
+      else {
+        n.debug && t && te(e) && n.func(
+          "debug",
+          `[test-variants] parallel aborted, running sequential: tests=${i.tests}`
+        );
+        const h = Ee(e, a);
+        O(h) && await h;
+      }
+    } finally {
+      g && t.release(1);
+    }
+  }
+  t && (await ae({ pool: t, count: s, hold: !0 }), t.release(s));
+}
+function At(e) {
+  const { pool: r, state: t, options: i } = e, { logOptions: o } = i;
+  if (r)
+    return J(e);
+  let s = null;
+  for (; !j(e) && (e.state.debugMode || (s = e.variantsIterator.next()), s != null); ) {
+    const n = we(e);
+    if (O(n))
+      return n.then(() => J(e, s));
+    if (j(e))
+      continue;
+    o.debug && te(e) && o.func(
+      "debug",
+      `[test-variants] parallel aborted, running sequential: tests=${t.tests}`
+    );
+    const a = Ee(e, s);
+    if (O(a))
+      return a.then(() => J(e));
+  }
+}
+async function Ot(e, r, t, i) {
+  const o = St(i), {
+    store: s,
+    logOptions: n,
+    abortSignalExternal: a,
+    findBestError: c,
+    dontThrowIfError: g,
+    timeController: m,
+    parallel: h
+  } = o, y = new Z(), d = new Z(), b = X(
+    a,
+    y.signal
+  ), v = X(
+    b,
+    d.signal
+  ), M = {
+    abortSignal: b,
+    timeController: m
+  }, f = {
+    abortSignal: v,
+    timeController: m
+  };
+  s && await s.replay({
+    testRun: e,
+    variantsIterator: r,
+    testOptions: M,
+    findBestErrorEnabled: !!c
+  });
+  const E = h <= 1 ? null : new Ye(h);
+  Mt(n, t.startMemory);
+  const S = {
+    options: o,
+    testRun: e,
+    variantsIterator: r,
+    testOptions: M,
+    testOptionsParallel: f,
+    abortControllerGlobal: y,
+    abortControllerParallel: d,
+    abortSignal: v,
+    pool: E,
+    state: t
+  };
+  Se(S);
+  try {
+    await At(S), v.throwIfAborted();
+  } catch (C) {
+    throw y.abort(new V()), C;
+  }
+  return b.throwIfAborted(), y.abort(new V()), It(S), await ne(1), yt(t, r, g);
+}
+function Dt(e) {
+  return function(t) {
+    return async function(o) {
+      const s = be(o?.log), n = ft(e, {
+        onStart: o?.onStart,
+        onEnd: o?.onEnd,
+        onError: o?.onError,
+        log: s,
+        pauseDebuggerOnError: o?.pauseDebuggerOnError,
+        timeout: o?.timeout
+      }), a = o?.timeController ?? F, c = re(), g = st(a, c), m = o?.onModeChange;
+      function h(d) {
+        g.pendingModeChange = d, m?.(d);
+      }
+      const y = bt({
+        argsTemplates: t,
+        getSeed: o?.getSeed,
+        iterationModes: o?.iterationModes,
+        equals: o?.findBestError?.equals,
+        limitArgOnError: o?.findBestError?.limitArgOnError,
+        includeErrorVariant: o?.findBestError?.includeErrorVariant,
+        timeController: a,
+        onModeChange: h,
+        limitCompletionCount: o?.cycles ?? 1,
+        limitTests: o?.limitTests,
+        limitTime: o?.limitTime
+      });
+      return Ot(n, y, g, o);
+    };
+  };
+}
+export {
+  et as T,
+  Dt as c
+};