@ait-co/devtools 0.1.144 → 0.2.0

package/dist/test-runner/runtime.js

@@ -1,659 +0,0 @@
-import { r as isThrottledError } from "../throttle-DKKzX1qC.js";
-//#region src/test-runner/runtime.ts
-/**
-* Thin test runtime for WebView execution.
-*
-* This file is bundled by `bundle.ts` together with the user's test file
-* into a single IIFE injected into the WebView via `Runtime.evaluate`.
-* It MUST stay browser-compatible — no Node.js APIs allowed.
-*
-* Design: rather than shipping @vitest/runner verbatim into a WebView (where
-* its Node-side internals cause issues), this runtime provides a minimal
-* compatible API surface — describe/it/test/expect globals — collects results
-* into a plain JSON-safe object, and exports `runTestModule` as the entry point.
-*
-* @vitest/runner and @vitest/expect are listed as dependencies so that the
-* package's type contracts are available and so the browser-compatible subsets
-* can be referenced. The Vitest custom pool that drives this runtime through
-* Vitest's `PoolRunnerInitializer` lives in `pool.ts`.
-*
-* NOTE: this file is imported by type from Node-side code (rpc.ts / relay-worker.ts)
-* for the RunReport / TestResult type shapes. The runtime ITSELF is not imported
-* at runtime on the Node side — only the types are used.
-*/
-/** Backoff delays (ms) between throttle-retry attempts: 1s, then 2s. */
-const TEST_RETRY_BACKOFF_MS = [1e3, 2e3];
-/** Max retry attempts per test after the initial run (devtools#767: "최대 2회 재시도"). */
-const TEST_MAX_RETRIES = TEST_RETRY_BACKOFF_MS.length;
-/** Real `setTimeout`-backed sleep — the production default for {@link RunTestModuleOptions.sleep}. */
-const DEFAULT_SLEEP = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-/**
-* Renders a thrown value into a `TestResult.error` string. Handles three
-* shapes:
-*   - a real `Error` (or subclass) — its `.message`;
-*   - an error-LIKE plain object with a string `.message` (the 2.x native
-*     bridge envelope this test-runner observes, e.g.
-*     `{name, code, userInfo, moduleName, __isError}` — devtools#767's
-*     `APP_BRIDGE_THROTTLED` rejections are exactly this shape, not an
-*     `Error` instance) — its `.message` field;
-*   - anything else — `String(e)` (the pre-#767 fallback, unchanged).
-*
-* Without the middle case, a native envelope's `.message` (the only useful
-* diagnostic text) was discarded in favor of the useless `"[object Object]"`.
-*/
-function stringifyThrown(e) {
-	if (e instanceof Error) return e.message;
-	if (typeof e === "object" && e !== null) {
-		const rec = e;
-		if (typeof rec.message === "string") return rec.message;
-	}
-	return String(e);
-}
-/**
-* Brand property that tags asymmetric matcher markers (`expect.any(String)`,
-* `expect.objectContaining(...)`, etc). A reserved string key is used as the
-* brand so the guard stays a plain own-property check — markers are only ever
-* compared in-process by reference, so no cross-realm Symbol coordination is
-* needed.
-*/
-const ASYMMETRIC_BRAND = "$$asymmetricMatch";
-/** Narrowing guard: is `v` an asymmetric matcher marker? */
-function isAsymmetric(v) {
-	return typeof v === "object" && v !== null && v[ASYMMETRIC_BRAND] === true && typeof v.asymmetricMatch === "function";
-}
-/**
-* `expect.any(Ctor)` — matches a value by its constructor. Primitive wrappers
-* (`String`/`Number`/`Boolean`) are matched by `typeof` (so the unboxed
-* primitive matches) AND by `instanceof` (so a boxed wrapper instance also
-* matches). `BigInt`/`Symbol` match by `typeof`. `Object` matches any non-null
-* object (NOT functions, matching vitest), `Array` uses `Array.isArray`,
-* `Function` uses `typeof === 'function'`, and any other constructor (user
-* classes) falls back to `instanceof`.
-*/
-function makeAny(ctor) {
-	const name = ctor.name ?? String(ctor);
-	const ctorAsFn = ctor;
-	return {
-		[ASYMMETRIC_BRAND]: true,
-		toString: () => `Any<${name}>`,
-		asymmetricMatch(actual) {
-			if (actual === null || actual === void 0) return false;
-			switch (ctor) {
-				case String: return typeof actual === "string" || actual instanceof String;
-				case Number: return typeof actual === "number" || actual instanceof Number;
-				case Boolean: return typeof actual === "boolean" || actual instanceof Boolean;
-				case BigInt: return typeof actual === "bigint";
-				case Symbol: return typeof actual === "symbol";
-				case Function: return typeof actual === "function";
-				case Object: return typeof actual === "object";
-				case Array: return Array.isArray(actual);
-				default: return ctorAsFn ? actual instanceof ctorAsFn : false;
-			}
-		}
-	};
-}
-/** `expect.anything()` — matches any value except `null`/`undefined`. */
-function makeAnything() {
-	return {
-		[ASYMMETRIC_BRAND]: true,
-		toString: () => "Anything",
-		asymmetricMatch: (actual) => actual !== null && actual !== void 0
-	};
-}
-/** `expect.objectContaining(obj)` — partial-match every key of `obj` on `actual`. */
-function makeObjectContaining(expected) {
-	return {
-		[ASYMMETRIC_BRAND]: true,
-		toString: () => `ObjectContaining<${safeStringify(expected)}>`,
-		asymmetricMatch: (actual) => deepMatchObject(actual, expected)
-	};
-}
-/** `expect.arrayContaining(arr)` — `actual` is an array containing each element of `arr`. */
-function makeArrayContaining(expected) {
-	return {
-		[ASYMMETRIC_BRAND]: true,
-		toString: () => `ArrayContaining<${safeStringify(expected)}>`,
-		asymmetricMatch(actual) {
-			if (!Array.isArray(actual)) return false;
-			return expected.every((exp) => actual.some((act) => isAsymmetric(exp) ? exp.asymmetricMatch(act) : deepEqual(act, exp)));
-		}
-	};
-}
-/** `expect.stringContaining(sub)` — `actual` is a string containing `sub`. */
-function makeStringContaining(sub) {
-	return {
-		[ASYMMETRIC_BRAND]: true,
-		toString: () => `StringContaining<${sub}>`,
-		asymmetricMatch: (actual) => typeof actual === "string" && actual.includes(sub)
-	};
-}
-/** `expect.stringMatching(re)` — `actual` is a string matching `re` (string or RegExp). */
-function makeStringMatching(re) {
-	const pattern = typeof re === "string" ? new RegExp(re) : re;
-	return {
-		[ASYMMETRIC_BRAND]: true,
-		toString: () => `StringMatching<${String(pattern)}>`,
-		asymmetricMatch: (actual) => typeof actual === "string" && pattern.test(actual)
-	};
-}
-/** JSON.stringify that never throws (cycles/BigInt) — for failure messages. */
-function safeStringify(v) {
-	try {
-		return JSON.stringify(v, (_k, val) => isAsymmetric(val) ? val.toString() : typeof val === "bigint" ? `${val}n` : val) ?? String(v);
-	} catch {
-		return String(v);
-	}
-}
-/**
-* Recursive structural equality — replaces JSON.stringify comparison to
-* handle key-order differences and undefined values correctly.
-*
-* When the `b` (expected) side is an asymmetric marker, its `asymmetricMatch`
-* predicate decides the result instead of structural comparison — markers are
-* placeholders, not plain objects, so deep-comparing them never matches.
-*/
-function deepEqual(a, b) {
-	if (isAsymmetric(b)) return b.asymmetricMatch(a);
-	if (Object.is(a, b)) return true;
-	if (a === null || b === null) return false;
-	if (typeof a !== "object" || typeof b !== "object") return false;
-	if (Array.isArray(a) && Array.isArray(b)) {
-		if (a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
-		return true;
-	}
-	if (Array.isArray(a) || Array.isArray(b)) return false;
-	const aObj = a;
-	const bObj = b;
-	const aKeys = Object.keys(aObj);
-	const bKeys = Object.keys(bObj);
-	if (aKeys.length !== bKeys.length) return false;
-	for (const key of aKeys) {
-		if (!Object.hasOwn(bObj, key)) return false;
-		if (!deepEqual(aObj[key], bObj[key])) return false;
-	}
-	return true;
-}
-/**
-* Partial-match: every key in `expected` must exist in `received` with a
-* recursively matching value. Extra keys in `received` are ignored.
-*
-* As in `deepEqual`, an asymmetric marker on the `expected` side delegates to
-* its `asymmetricMatch` predicate rather than being compared structurally.
-*/
-function deepMatchObject(received, expected) {
-	if (isAsymmetric(expected)) return expected.asymmetricMatch(received);
-	if (Object.is(received, expected)) return true;
-	if (expected === null || received === null) return Object.is(received, expected);
-	if (typeof expected !== "object" || typeof received !== "object") return Object.is(received, expected);
-	if (Array.isArray(expected) && Array.isArray(received)) {
-		if (expected.length !== received.length) return false;
-		for (let i = 0; i < expected.length; i++) if (!deepMatchObject(received[i], expected[i])) return false;
-		return true;
-	}
-	if (Array.isArray(expected) || Array.isArray(received)) return false;
-	const expObj = expected;
-	const recObj = received;
-	for (const key of Object.keys(expObj)) {
-		if (!Object.hasOwn(recObj, key)) return false;
-		if (!deepMatchObject(recObj[key], expObj[key])) return false;
-	}
-	return true;
-}
-/**
-* Resolves a dot-separated property path on an object.
-* Returns `{ found: true, value }` or `{ found: false }`.
-*/
-function resolvePath(obj, dotPath) {
-	const parts = dotPath.split(".");
-	let cur = obj;
-	for (const part of parts) {
-		if (cur === null || cur === void 0 || typeof cur !== "object") return { found: false };
-		const record = cur;
-		if (!Object.hasOwn(record, part)) return { found: false };
-		cur = record[part];
-	}
-	return {
-		found: true,
-		value: cur
-	};
-}
-/** Thrown by expect matchers on failure. */
-var AssertionError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "AssertionError";
-	}
-};
-/** Minimal expect builder compatible with Vitest's jest-style API. */
-var Expectation = class Expectation {
-	#received;
-	#negated = false;
-	constructor(received) {
-		this.#received = received;
-	}
-	get not() {
-		const neg = new Expectation(this.#received);
-		neg.#negated = true;
-		return neg;
-	}
-	#assert(pass, msg) {
-		if (!(this.#negated ? !pass : pass)) throw new AssertionError(this.#negated ? `Expected NOT: ${msg}` : msg);
-	}
-	toBe(expected) {
-		this.#assert(Object.is(this.#received, expected), `Expected ${String(expected)}, received ${String(this.#received)}`);
-	}
-	toEqual(expected) {
-		this.#assert(deepEqual(this.#received, expected), `Expected ${JSON.stringify(expected)}, received ${JSON.stringify(this.#received)}`);
-	}
-	toBeTruthy() {
-		this.#assert(Boolean(this.#received), `Expected truthy, received ${String(this.#received)}`);
-	}
-	toBeFalsy() {
-		this.#assert(!this.#received, `Expected falsy, received ${String(this.#received)}`);
-	}
-	toBeNull() {
-		this.#assert(this.#received === null, `Expected null, received ${String(this.#received)}`);
-	}
-	toBeUndefined() {
-		this.#assert(this.#received === void 0, `Expected undefined, received ${String(this.#received)}`);
-	}
-	toBeGreaterThan(n) {
-		this.#assert(typeof this.#received === "number" && this.#received > n, `Expected > ${n}, received ${String(this.#received)}`);
-	}
-	toBeLessThan(n) {
-		this.#assert(typeof this.#received === "number" && this.#received < n, `Expected < ${n}, received ${String(this.#received)}`);
-	}
-	toContain(sub) {
-		if (Array.isArray(this.#received)) {
-			this.#assert(this.#received.includes(sub), `Expected array to contain ${JSON.stringify(sub)}, received ${JSON.stringify(this.#received)}`);
-			return;
-		}
-		this.#assert(typeof this.#received === "string" && typeof sub === "string" && this.#received.includes(sub), `Expected to contain "${String(sub)}", received "${String(this.#received)}"`);
-	}
-	toThrow(msgFragment) {
-		if (typeof this.#received !== "function") throw new AssertionError("toThrow: expected a function");
-		let threw = false;
-		let errorMsg = "";
-		try {
-			this.#received();
-		} catch (e) {
-			threw = true;
-			errorMsg = e instanceof Error ? e.message : String(e);
-		}
-		if (msgFragment !== void 0) this.#assert(threw && errorMsg.includes(msgFragment), `Expected to throw containing "${msgFragment}", got "${errorMsg}"`);
-		else this.#assert(threw, "Expected function to throw");
-	}
-	toMatchObject(expected) {
-		this.#assert(deepMatchObject(this.#received, expected), `Expected object to match ${JSON.stringify(expected)}, received ${JSON.stringify(this.#received)}`);
-	}
-	toHaveProperty(dotPath, ...rest) {
-		const { found, value: actual } = resolvePath(this.#received, dotPath);
-		if (rest.length > 0) {
-			const value = rest[0];
-			this.#assert(found && deepEqual(actual, value), `Expected property "${dotPath}" to equal ${JSON.stringify(value)}, got ${JSON.stringify(actual)}`);
-		} else this.#assert(found, `Expected property "${dotPath}" to exist`);
-	}
-	toBeInstanceOf(ctor) {
-		this.#assert(this.#received instanceof ctor, `Expected instance of ${ctor.name ?? String(ctor)}, received ${String(this.#received)}`);
-	}
-	toBeTypeOf(typeStr) {
-		this.#assert(typeof this.#received === typeStr, `Expected typeof "${typeStr}", received "${typeof this.#received}"`);
-	}
-	toHaveLength(n) {
-		const length = this.#received?.length;
-		this.#assert(typeof length === "number" && length === n, `Expected length ${n}, received ${typeof length === "number" ? length : String(this.#received)}`);
-	}
-};
-/** The `expect` function installed as a global. */
-const expect = ((received) => new Expectation(received));
-expect.any = makeAny;
-expect.anything = makeAnything;
-expect.objectContaining = makeObjectContaining;
-expect.arrayContaining = makeArrayContaining;
-expect.stringContaining = makeStringContaining;
-expect.stringMatching = makeStringMatching;
-/**
-* Internal sentinel thrown by `ctx.skip()` to unwind the test body early.
-* Caught by the run loop (never surfaced as a failure) — see `runTestModule`'s
-* test-execution `catch` branch.
-*/
-var InPageSkipSentinel = class {
-	constructor(note) {
-		this.note = note;
-	}
-};
-function _makeTestContext(name) {
-	return {
-		skip(condition, note) {
-			if (condition === void 0 || condition) throw new InPageSkipSentinel(note);
-		},
-		task: { name }
-	};
-}
-const _pendingTests = [];
-const _suiteStack = [];
-/** Registers a suite scope; calls `fn` synchronously to collect inner tests. */
-function describe(name, fn) {
-	_suiteStack.push(name);
-	fn();
-	_suiteStack.pop();
-}
-/** Registers a test. */
-function it(name, fn) {
-	_pendingTests.push({
-		suitePath: [..._suiteStack],
-		name,
-		fn,
-		skip: false
-	});
-}
-/** Alias for `it`. */
-const test = it;
-/** Skipped test — registered but not executed. */
-describe.skip = (name, _fn) => {};
-it.skip = (name, _fn) => {
-	_pendingTests.push({
-		suitePath: [..._suiteStack],
-		name,
-		fn: () => {},
-		skip: true
-	});
-};
-test.skip = it.skip;
-function _conditionalIt(skip) {
-	return (name, fn) => {
-		_pendingTests.push({
-			suitePath: [..._suiteStack],
-			name,
-			fn,
-			skip
-		});
-	};
-}
-it.skipIf = (cond) => _conditionalIt(Boolean(cond));
-it.runIf = (cond) => _conditionalIt(!cond);
-test.skipIf = it.skipIf;
-test.runIf = it.runIf;
-describe.skipIf = (cond) => cond ? (name, _fn) => void 0 : (name, fn) => describe(name, fn);
-describe.runIf = (cond) => cond ? (name, fn) => describe(name, fn) : (name, _fn) => void 0;
-const _hooks = [];
-function _registerHook(type, fn) {
-	_hooks.push({
-		suitePath: [..._suiteStack],
-		type,
-		fn
-	});
-}
-/**
-* Returns hooks whose suitePath is a prefix of `testSuitePath`
-* (i.e. the hook's scope contains the test).
-*/
-function _hooksFor(type, testSuitePath) {
-	return _hooks.filter((h) => {
-		if (h.type !== type) return false;
-		if (h.suitePath.length > testSuitePath.length) return false;
-		for (let i = 0; i < h.suitePath.length; i++) if (h.suitePath[i] !== testSuitePath[i]) return false;
-		return true;
-	}).map((h) => h.fn);
-}
-/** Runs an array of hook functions in order, awaiting each. */
-async function _runHooks(fns) {
-	for (const fn of fns) try {
-		await fn();
-	} catch (e) {
-		return e instanceof Error ? e : new Error(String(e));
-	}
-	return null;
-}
-function beforeAll(fn) {
-	_registerHook("beforeAll", fn);
-}
-function afterAll(fn) {
-	_registerHook("afterAll", fn);
-}
-function beforeEach(fn) {
-	_registerHook("beforeEach", fn);
-}
-function afterEach(fn) {
-	_registerHook("afterEach", fn);
-}
-const _spyRegistry = [];
-function _createMockFn(impl) {
-	let currentImpl = impl;
-	const calls = [];
-	const mockFn = ((...args) => {
-		const returnValue = currentImpl ? currentImpl(...args) : void 0;
-		calls.push({
-			args,
-			returnValue
-		});
-		return returnValue;
-	});
-	mockFn.mock = { calls };
-	mockFn.mockImplementation = function(fn) {
-		currentImpl = fn;
-		return this;
-	};
-	mockFn.mockReturnValue = function(value) {
-		currentImpl = () => value;
-		return this;
-	};
-	mockFn.mockRestore = () => {};
-	return mockFn;
-}
-const vi = {
-	spyOn(obj, method) {
-		const original = obj[method];
-		const spy = _createMockFn(typeof original === "function" ? original : void 0);
-		spy.mockRestore = () => {
-			obj[method] = original;
-		};
-		_spyRegistry.push({
-			obj,
-			method,
-			original
-		});
-		obj[method] = spy;
-		return spy;
-	},
-	fn(impl) {
-		return _createMockFn(impl);
-	},
-	restoreAllMocks() {
-		for (const { obj, method, original } of _spyRegistry) obj[method] = original;
-		_spyRegistry.length = 0;
-	}
-};
-/**
-* Runtime globals object — exported for direct use in unit tests so that
-* test factories can reference runtime's own `it`/`expect`/`beforeAll`/etc.
-* without depending on `globalThis` injection.
-*
-* In a real WebView bundle these are accessed via globals installed by
-* `runTestModule`; in Node tests, import from here directly.
-*/
-const runtimeGlobals = {
-	describe,
-	it,
-	test,
-	expect,
-	beforeAll,
-	afterAll,
-	beforeEach,
-	afterEach,
-	vi
-};
-/**
-* Installs describe/it/test/expect/afterAll/afterEach/beforeAll/beforeEach/vi
-* as globals, invokes `moduleFactory` to register the user's tests, then
-* executes them and returns a RunReport.
-*
-* This function is exported as `__testBundle.runTestModule` by the IIFE wrapper
-* that bundle.ts generates. The Node-side rpc.ts calls it via `Runtime.evaluate`.
-*
-* @param moduleFactory - A zero-argument function that contains the user's
-*   top-level test code (describe/it/test calls). The bundler wraps the entire
-*   test module so that its top-level statements become the body of this factory.
-* @param opts - Test-only overrides (see {@link RunTestModuleOptions}). Never
-*   passed by the generated bundle (`rpc.ts#buildRunTestsExpression` calls
-*   `runTestModule(__userFactory)` with exactly one argument) — this second
-*   parameter exists so unit tests can inject a fake sleep and assert the
-*   THROTTLED-retry timing without real delays.
-*/
-async function runTestModule(moduleFactory, opts) {
-	const sleep = opts?.sleep ?? DEFAULT_SLEEP;
-	_pendingTests.length = 0;
-	_suiteStack.length = 0;
-	_hooks.length = 0;
-	_spyRegistry.length = 0;
-	const g = globalThis;
-	g.describe = describe;
-	g.it = it;
-	g.test = test;
-	g.expect = expect;
-	g.beforeAll = beforeAll;
-	g.afterAll = afterAll;
-	g.beforeEach = beforeEach;
-	g.afterEach = afterEach;
-	g.vi = vi;
-	if (moduleFactory) await moduleFactory();
-	const wallStart = Date.now();
-	const startedAt = new Date(wallStart).toISOString();
-	const results = [];
-	const firedBeforeAll = /* @__PURE__ */ new Set();
-	const lastIndexForScope = /* @__PURE__ */ new Map();
-	for (let i = 0; i < _pendingTests.length; i++) {
-		const key = _pendingTests[i].suitePath.join("\0");
-		lastIndexForScope.set(key, i);
-		const path = _pendingTests[i].suitePath;
-		for (let depth = 0; depth < path.length; depth++) {
-			const parentKey = path.slice(0, depth).join("\0");
-			const cur = lastIndexForScope.get(parentKey) ?? -1;
-			if (i > cur) lastIndexForScope.set(parentKey, i);
-		}
-	}
-	const MODULE_KEY = "";
-	if (!lastIndexForScope.has(MODULE_KEY) && _pendingTests.length > 0) lastIndexForScope.set(MODULE_KEY, _pendingTests.length - 1);
-	if (_pendingTests.length > 0) {
-		const baErr = await _runHooks(_hooksFor("beforeAll", []));
-		firedBeforeAll.add(MODULE_KEY);
-		if (baErr) {
-			for (const pending of _pendingTests) {
-				const fullName = [...pending.suitePath, pending.name].join(" > ");
-				results.push({
-					name: fullName,
-					status: "fail",
-					duration: 0,
-					error: `beforeAll failed: ${baErr.message}`
-				});
-			}
-			const duration = Date.now() - wallStart;
-			const passed = results.filter((r) => r.status === "pass").length;
-			const failed = results.filter((r) => r.status === "fail").length;
-			const skipped = results.filter((r) => r.status === "skip").length;
-			await _runHooks(_hooksFor("afterAll", []));
-			return {
-				startedAt,
-				duration,
-				passed,
-				failed,
-				skipped,
-				tests: results
-			};
-		}
-	}
-	const paceMs = (() => {
-		const raw = globalThis.__AIT_PACE_MS__;
-		return typeof raw === "number" && raw > 0 ? raw : 0;
-	})();
-	let ranFirstTest = false;
-	for (let i = 0; i < _pendingTests.length; i++) {
-		const pending = _pendingTests[i];
-		const fullName = [...pending.suitePath, pending.name].join(" > ");
-		if (pending.skip) {
-			results.push({
-				name: fullName,
-				status: "skip",
-				duration: 0
-			});
-			continue;
-		}
-		if (paceMs > 0 && ranFirstTest) await sleep(paceMs);
-		ranFirstTest = true;
-		for (let depth = 1; depth <= pending.suitePath.length; depth++) {
-			const scopeKey = pending.suitePath.slice(0, depth).join("\0");
-			if (!firedBeforeAll.has(scopeKey)) {
-				const baErr = await _runHooks(_hooks.filter((h) => h.type === "beforeAll" && h.suitePath.join("\0") === scopeKey).map((h) => h.fn));
-				firedBeforeAll.add(scopeKey);
-				if (baErr) results.push({
-					name: fullName,
-					status: "fail",
-					duration: 0,
-					error: `beforeAll failed: ${baErr.message}`
-				});
-			}
-		}
-		const beErr = await _runHooks(_hooksFor("beforeEach", pending.suitePath));
-		const tStart = Date.now();
-		let testErr;
-		let inPageSkip;
-		let throttleRetries = 0;
-		if (beErr) testErr = `beforeEach failed: ${beErr.message}`;
-		else for (let attempt = 0;; attempt++) try {
-			await pending.fn(_makeTestContext(fullName));
-			testErr = void 0;
-			break;
-		} catch (e) {
-			if (e instanceof InPageSkipSentinel) {
-				inPageSkip = e;
-				break;
-			}
-			testErr = stringifyThrown(e);
-			if (isThrottledError(e) && attempt < TEST_MAX_RETRIES) {
-				throttleRetries += 1;
-				await sleep(TEST_RETRY_BACKOFF_MS[attempt]);
-				continue;
-			}
-			break;
-		}
-		const aeErr = await _runHooks(_hooksFor("afterEach", pending.suitePath));
-		if (aeErr && !testErr && !inPageSkip) testErr = `afterEach failed: ${aeErr.message}`;
-		if (inPageSkip) results.push({
-			name: fullName,
-			status: "skip",
-			duration: Date.now() - tStart,
-			...inPageSkip.note !== void 0 ? { note: inPageSkip.note } : {}
-		});
-		else if (testErr !== void 0) results.push({
-			name: fullName,
-			status: "fail",
-			duration: Date.now() - tStart,
-			error: testErr,
-			...throttleRetries > 0 ? { throttleRetries } : {}
-		});
-		else results.push({
-			name: fullName,
-			status: "pass",
-			duration: Date.now() - tStart,
-			...throttleRetries > 0 ? { throttleRetries } : {}
-		});
-		for (let depth = pending.suitePath.length; depth >= 1; depth--) {
-			const scopeKey = pending.suitePath.slice(0, depth).join("\0");
-			if ((lastIndexForScope.get(scopeKey) ?? -1) === i) await _runHooks(_hooks.filter((h) => h.type === "afterAll" && h.suitePath.join("\0") === scopeKey).map((h) => h.fn));
-		}
-	}
-	await _runHooks(_hooks.filter((h) => h.type === "afterAll" && h.suitePath.length === 0).map((h) => h.fn));
-	return {
-		startedAt,
-		duration: Date.now() - wallStart,
-		passed: results.filter((r) => r.status === "pass").length,
-		failed: results.filter((r) => r.status === "fail").length,
-		skipped: results.filter((r) => r.status === "skip").length,
-		tests: results
-	};
-}
-//#endregion
-export { runTestModule, runtimeGlobals };
-
-//# sourceMappingURL=runtime.js.map