@ait-co/devtools 0.1.144 → 0.2.0

package/dist/test-runner/method-pace.js

@@ -1,120 +0,0 @@
-//#region src/test-runner/method-pace.ts
-const REGISTRY_KEY = "__AIT_METHOD_PACE_STATE__";
-/** Reads (or lazily creates) the page-global per-method pacing registry. */
-function getRegistry() {
-	const g = globalThis;
-	let state = g[REGISTRY_KEY];
-	if (!(state instanceof Map)) {
-		state = /* @__PURE__ */ new Map();
-		g[REGISTRY_KEY] = state;
-	}
-	return state;
-}
-/** `setTimeout`-based sleep — no Node APIs, safe on the page side. */
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
-* True when `value` is a `class` declaration rather than a plain callable
-* function. The SDK export surface includes at least one class (`PermissionError`,
-* `src/__typecheck.ts`/`bridge-stub.ts` both reference it) — wrapping a class
-* in an async arrow function would silently break `new PermissionError()`
-* (arrow functions are not constructible), so classes must pass through
-* `wrapWithMethodPacing` unwrapped exactly like any other non-callable
-* export. Detected via `Function.prototype.toString` starting with
-* `"class "` — the standard, spec-guaranteed way to distinguish a class from
-* an ordinary function at runtime (no Babel/TS transform in this bundle
-* target — `target: 'es2022'` in `bundle.ts` — down-compiles `class` to a
-* function, so this check remains reliable for esbuild's es2022 output).
-*/
-function isClass(value) {
-	return Function.prototype.toString.call(value).startsWith("class ");
-}
-/**
-* Reads the page-global `__AIT_PACE_METHOD_MS__` gap value (devtools#769),
-* injected by `relay-factory.ts` the same way `__AIT_PACE_MS__`/`__AIT_CELL__`
-* are (`cell.ts#injectGlobals`). Absent/non-positive resolves to `0` — the
-* same "treat absence as zero" contract `runtime.ts`'s `__AIT_PACE_MS__` read
-* uses.
-*/
-function getPaceMethodMs() {
-	const raw = globalThis.__AIT_PACE_METHOD_MS__;
-	return typeof raw === "number" && raw > 0 ? raw : 0;
-}
-/**
-* Wraps a single named SDK function so that calls to it wait out `gapMs`
-* since the function's own previous invocation (tracked in the shared
-* `getRegistry()` map, keyed by `name`) before the real `fn` runs. The
-* result/rejection of `fn` passes through completely unchanged — pacing
-* never alters contract-observed behavior, only its timing.
-*/
-function buildPacedFunction(name, fn, gapMs) {
-	return async (...args) => {
-		const registry = getRegistry();
-		const now = performance.now();
-		const lastInvokeAt = registry.get(name);
-		if (lastInvokeAt !== void 0) {
-			const elapsed = now - lastInvokeAt;
-			if (elapsed < gapMs) await sleep(gapMs - elapsed);
-		}
-		registry.set(name, performance.now());
-		return fn(...args);
-	};
-}
-/**
-* Wraps an SDK-shaped bridge object (`window.__sdk`, or the already
-* stub-wrapped result of `bridge-stub.ts#wrapSdkWithStub`) so that every
-* function-valued export is paced to a minimum `gapMs` interval between
-* calls to the SAME name (devtools#769). Non-function exports (constants,
-* etc.) and classes (`PermissionError`, etc. — wrapping a class would break
-* `new`, see `isClass`) pass through completely untouched.
-*
-* **Composition with bridge-stub (devtools#740)**: this wrapper is applied to
-* the RAW `window.__sdk` object, and `wrapSdkWithStub` is applied on TOP of
-* the paced result (`wrapSdkWithStub(wrapWithMethodPacing(rawSdk, gapMs),
-* stubEnabled)` — see `bundle.ts`'s sdk-redirect virtual module). This means
-* pacing sits BEHIND the stub interception: a stubbed name
-* (`STUB_REGISTRY` — `openPermissionDialog`, `requestPermission`,
-* `saveBase64Data`, `showFullScreenAd`) resolves instantly from the fixture
-* with no added delay, because `wrapSdkWithStub`'s Proxy intercepts the
-* property access before the paced function is ever reached. Only calls that
-* fall through to the REAL bridge — the ones that actually risk
-* `APP_BRIDGE_THROTTLED` — pay the pacing cost. Fixed by this ordering, not
-* incidental: swapping it (pacing outside the stub) would pace fixture
-* look-ups that can never hit the native rate limiter, for no benefit.
-*
-* `gapMs <= 0` (the default, no `--pace-method` / non-2.x cell) returns `sdk`
-* itself, untouched — the exact object identity is preserved so the
-* zero-diff-when-off contract holds under strict-equality checks, matching
-* `wrapSdkWithStub`'s own `enabled === false` fast path.
-*
-* **Memoization**: wrapper functions are cached per name in a `Map` local to
-* this call's `Proxy` (`wrapperCache` below), so repeated property access on
-* the SAME `sdk` object within a single `wrapWithMethodPacing` call returns
-* the SAME wrapper reference. This cache does NOT persist across separate
-* `wrapWithMethodPacing` calls — each call (e.g. the sdk-redirect virtual
-* module re-evaluated per test file bundle) gets its own fresh `Map` and
-* therefore its own wrapper function instances, even for the same method
-* name. That's fine for pacing correctness: the actual timing state lives in
-* the page-global `getRegistry()` map (keyed by method name, not by wrapper
-* identity), so cross-bundle pacing still works. But callers should NOT
-* assume cross-call function identity — only "same wrapper within one call"
-* is guaranteed.
-*/
-function wrapWithMethodPacing(sdk, gapMs) {
-	if (!(gapMs > 0)) return sdk;
-	const wrapperCache = /* @__PURE__ */ new Map();
-	return new Proxy(sdk, { get(target, prop, receiver) {
-		const value = Reflect.get(target, prop, receiver);
-		if (typeof prop !== "string" || typeof value !== "function" || isClass(value)) return value;
-		const cached = wrapperCache.get(prop);
-		if (cached !== void 0) return cached;
-		const wrapped = buildPacedFunction(prop, value, gapMs);
-		wrapperCache.set(prop, wrapped);
-		return wrapped;
-	} });
-}
-//#endregion
-export { getPaceMethodMs, wrapWithMethodPacing };
-
-//# sourceMappingURL=method-pace.js.map

package/dist/test-runner/method-pace.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"method-pace.js","names":[],"sources":["../../src/test-runner/method-pace.ts"],"sourcesContent":["/**\n * Per-method minimum-interval pacing for SDK calls (devtools#769).\n *\n * #767's `--pace` inserts delays BETWEEN test files / test-to-test — it has no\n * effect on a burst of same-method calls WITHIN a single test body (e.g. a\n * clipboard happy-path loop calling `setClipboardText`/`getClipboardText`\n * eight times back to back). Real-device observation (sdk-example#293,\n * 2.x×iOS) showed that burst alone is enough to saturate the native\n * per-method bridge rate limit (`APP_BRIDGE_THROTTLED`, devtools#767/throttle.ts)\n * even though `--pace`'s file/test spacing was already in effect — the\n * limiter reacts to burst cadence within a method name, not just across test\n * boundaries.\n *\n * This module wraps `window.__sdk` (the same bridge object `bundle.ts`'s\n * `sdkRedirectPlugin` redirects SDK imports to) so that every call to the\n * SAME named function waits out a minimum gap since that function's PREVIOUS\n * invocation before the real call proceeds. Preflight (`cell.ts`) proved the\n * inverse case empirically: a steady 250ms sequential cadence passes cleanly\n * where an unpaced burst does not — sequential-with-spacing is the fix this\n * module generalizes to every SDK call, not just the six permission probes.\n *\n * Runs entirely on the PAGE side (browser-compatible, no Node APIs) — bundled\n * into the injected IIFE by `bundle.ts`'s `sdkRedirectPlugin`, the same way\n * `bridge-stub.ts` and `runtime.ts` are. Imported ONLY from the test-runner\n * (never from `sdk-example/src` — boilerplate cleanliness, umbrella §1.4).\n *\n * SECRET-HANDLING: this module carries no secrets — only method names and\n * millisecond timestamps/durations.\n */\n\n/**\n * Page-global registry of per-method last-invocation timestamps\n * (`performance.now()`-relative, monotonic). One registry per page — shared\n * across every wrapped SDK object so repeated `wrapWithMethodPacing` calls\n * (e.g. the sdk-redirect virtual module re-evaluated per test file bundle)\n * still see the true last-invoke time of a given method name, not a fresh\n * per-bundle registry that would silently reset pacing at every file\n * boundary.\n */\ntype MethodPaceState = Map<string, number>;\n\nconst REGISTRY_KEY = '__AIT_METHOD_PACE_STATE__';\n\n/** Reads (or lazily creates) the page-global per-method pacing registry. */\nfunction getRegistry(): MethodPaceState {\n  const g = globalThis as { [REGISTRY_KEY]?: MethodPaceState };\n  let state = g[REGISTRY_KEY];\n  if (!(state instanceof Map)) {\n    state = new Map<string, number>();\n    g[REGISTRY_KEY] = state;\n  }\n  return state;\n}\n\n/** `setTimeout`-based sleep — no Node APIs, safe on the page side. */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * True when `value` is a `class` declaration rather than a plain callable\n * function. The SDK export surface includes at least one class (`PermissionError`,\n * `src/__typecheck.ts`/`bridge-stub.ts` both reference it) — wrapping a class\n * in an async arrow function would silently break `new PermissionError()`\n * (arrow functions are not constructible), so classes must pass through\n * `wrapWithMethodPacing` unwrapped exactly like any other non-callable\n * export. Detected via `Function.prototype.toString` starting with\n * `\"class \"` — the standard, spec-guaranteed way to distinguish a class from\n * an ordinary function at runtime (no Babel/TS transform in this bundle\n * target — `target: 'es2022'` in `bundle.ts` — down-compiles `class` to a\n * function, so this check remains reliable for esbuild's es2022 output).\n */\nfunction isClass(value: (...args: unknown[]) => unknown): boolean {\n  return Function.prototype.toString.call(value).startsWith('class ');\n}\n\n/**\n * Reads the page-global `__AIT_PACE_METHOD_MS__` gap value (devtools#769),\n * injected by `relay-factory.ts` the same way `__AIT_PACE_MS__`/`__AIT_CELL__`\n * are (`cell.ts#injectGlobals`). Absent/non-positive resolves to `0` — the\n * same \"treat absence as zero\" contract `runtime.ts`'s `__AIT_PACE_MS__` read\n * uses.\n */\nexport function getPaceMethodMs(): number {\n  const raw = (globalThis as { __AIT_PACE_METHOD_MS__?: unknown }).__AIT_PACE_METHOD_MS__;\n  return typeof raw === 'number' && raw > 0 ? raw : 0;\n}\n\n/**\n * Wraps a single named SDK function so that calls to it wait out `gapMs`\n * since the function's own previous invocation (tracked in the shared\n * `getRegistry()` map, keyed by `name`) before the real `fn` runs. The\n * result/rejection of `fn` passes through completely unchanged — pacing\n * never alters contract-observed behavior, only its timing.\n */\nfunction buildPacedFunction(\n  name: string,\n  fn: (...args: unknown[]) => unknown,\n  gapMs: number,\n): (...args: unknown[]) => unknown {\n  return async (...args: unknown[]) => {\n    const registry = getRegistry();\n    const now = performance.now();\n    const lastInvokeAt = registry.get(name);\n    if (lastInvokeAt !== undefined) {\n      const elapsed = now - lastInvokeAt;\n      if (elapsed < gapMs) {\n        await sleep(gapMs - elapsed);\n      }\n    }\n    // Record the timestamp AFTER any wait but BEFORE the real call — this is\n    // \"last invoke attempt\", matching the preflight's own \"sequential with\n    // spacing before each call\" model rather than \"last completion\", so two\n    // long-running calls in flight cannot both slip under the gap.\n    registry.set(name, performance.now());\n    return fn(...args);\n  };\n}\n\n/**\n * Wraps an SDK-shaped bridge object (`window.__sdk`, or the already\n * stub-wrapped result of `bridge-stub.ts#wrapSdkWithStub`) so that every\n * function-valued export is paced to a minimum `gapMs` interval between\n * calls to the SAME name (devtools#769). Non-function exports (constants,\n * etc.) and classes (`PermissionError`, etc. — wrapping a class would break\n * `new`, see `isClass`) pass through completely untouched.\n *\n * **Composition with bridge-stub (devtools#740)**: this wrapper is applied to\n * the RAW `window.__sdk` object, and `wrapSdkWithStub` is applied on TOP of\n * the paced result (`wrapSdkWithStub(wrapWithMethodPacing(rawSdk, gapMs),\n * stubEnabled)` — see `bundle.ts`'s sdk-redirect virtual module). This means\n * pacing sits BEHIND the stub interception: a stubbed name\n * (`STUB_REGISTRY` — `openPermissionDialog`, `requestPermission`,\n * `saveBase64Data`, `showFullScreenAd`) resolves instantly from the fixture\n * with no added delay, because `wrapSdkWithStub`'s Proxy intercepts the\n * property access before the paced function is ever reached. Only calls that\n * fall through to the REAL bridge — the ones that actually risk\n * `APP_BRIDGE_THROTTLED` — pay the pacing cost. Fixed by this ordering, not\n * incidental: swapping it (pacing outside the stub) would pace fixture\n * look-ups that can never hit the native rate limiter, for no benefit.\n *\n * `gapMs <= 0` (the default, no `--pace-method` / non-2.x cell) returns `sdk`\n * itself, untouched — the exact object identity is preserved so the\n * zero-diff-when-off contract holds under strict-equality checks, matching\n * `wrapSdkWithStub`'s own `enabled === false` fast path.\n *\n * **Memoization**: wrapper functions are cached per name in a `Map` local to\n * this call's `Proxy` (`wrapperCache` below), so repeated property access on\n * the SAME `sdk` object within a single `wrapWithMethodPacing` call returns\n * the SAME wrapper reference. This cache does NOT persist across separate\n * `wrapWithMethodPacing` calls — each call (e.g. the sdk-redirect virtual\n * module re-evaluated per test file bundle) gets its own fresh `Map` and\n * therefore its own wrapper function instances, even for the same method\n * name. That's fine for pacing correctness: the actual timing state lives in\n * the page-global `getRegistry()` map (keyed by method name, not by wrapper\n * identity), so cross-bundle pacing still works. But callers should NOT\n * assume cross-call function identity — only \"same wrapper within one call\"\n * is guaranteed.\n */\nexport function wrapWithMethodPacing(\n  sdk: Record<string, unknown>,\n  gapMs: number,\n): Record<string, unknown> {\n  if (!(gapMs > 0)) return sdk;\n\n  const wrapperCache = new Map<string, (...args: unknown[]) => unknown>();\n\n  return new Proxy(sdk, {\n    get(target, prop, receiver) {\n      const value = Reflect.get(target, prop, receiver);\n      if (\n        typeof prop !== 'string' ||\n        typeof value !== 'function' ||\n        isClass(value as (...args: unknown[]) => unknown)\n      ) {\n        // Non-function export (constants, symbols) OR a class (e.g.\n        // PermissionError) — pass through unchanged. Wrapping a class would\n        // break `new`, and per-name pacing only makes sense for callable SDK\n        // methods anyway.\n        return value;\n      }\n      const cached = wrapperCache.get(prop);\n      if (cached !== undefined) return cached;\n      const wrapped = buildPacedFunction(prop, value as (...args: unknown[]) => unknown, gapMs);\n      wrapperCache.set(prop, wrapped);\n      return wrapped;\n    },\n  });\n}\n"],"mappings":";AAyCA,MAAM,eAAe;;AAGrB,SAAS,cAA+B;CACtC,MAAM,IAAI;CACV,IAAI,QAAQ,EAAE;AACd,KAAI,EAAE,iBAAiB,MAAM;AAC3B,0BAAQ,IAAI,KAAqB;AACjC,IAAE,gBAAgB;;AAEpB,QAAO;;;AAIT,SAAS,MAAM,IAA2B;AACxC,QAAO,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;AAgB1D,SAAS,QAAQ,OAAiD;AAChE,QAAO,SAAS,UAAU,SAAS,KAAK,MAAM,CAAC,WAAW,SAAS;;;;;;;;;AAUrE,SAAgB,kBAA0B;CACxC,MAAM,MAAO,WAAoD;AACjE,QAAO,OAAO,QAAQ,YAAY,MAAM,IAAI,MAAM;;;;;;;;;AAUpD,SAAS,mBACP,MACA,IACA,OACiC;AACjC,QAAO,OAAO,GAAG,SAAoB;EACnC,MAAM,WAAW,aAAa;EAC9B,MAAM,MAAM,YAAY,KAAK;EAC7B,MAAM,eAAe,SAAS,IAAI,KAAK;AACvC,MAAI,iBAAiB,KAAA,GAAW;GAC9B,MAAM,UAAU,MAAM;AACtB,OAAI,UAAU,MACZ,OAAM,MAAM,QAAQ,QAAQ;;AAOhC,WAAS,IAAI,MAAM,YAAY,KAAK,CAAC;AACrC,SAAO,GAAG,GAAG,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CtB,SAAgB,qBACd,KACA,OACyB;AACzB,KAAI,EAAE,QAAQ,GAAI,QAAO;CAEzB,MAAM,+BAAe,IAAI,KAA8C;AAEvE,QAAO,IAAI,MAAM,KAAK,EACpB,IAAI,QAAQ,MAAM,UAAU;EAC1B,MAAM,QAAQ,QAAQ,IAAI,QAAQ,MAAM,SAAS;AACjD,MACE,OAAO,SAAS,YAChB,OAAO,UAAU,cACjB,QAAQ,MAAyC,CAMjD,QAAO;EAET,MAAM,SAAS,aAAa,IAAI,KAAK;AACrC,MAAI,WAAW,KAAA,EAAW,QAAO;EACjC,MAAM,UAAU,mBAAmB,MAAM,OAA0C,MAAM;AACzF,eAAa,IAAI,MAAM,QAAQ;AAC/B,SAAO;IAEV,CAAC"}

package/dist/test-runner/pool.d.ts

@@ -1,2 +0,0 @@
-import { i as createRelayPool, n as RelayConnectionFactory, r as RelayPoolOptions, t as RELAY_POOL_NAME } from "../pool-DcaaOwUq.js";
-export { RELAY_POOL_NAME, RelayConnectionFactory, RelayPoolOptions, createRelayPool };

package/dist/test-runner/pool.js

@@ -1,136 +0,0 @@
-import { i as runTestFilesOverRelay } from "../relay-worker-B5HKkGUY.js";
-import { synthesizeFileTask, toTaskEventPacks, toTaskResultPacks } from "./task-graph.js";
-//#region src/test-runner/pool.ts
-/** The pool name Vitest matches against `getFilePoolName(project)`. */
-const RELAY_POOL_NAME = "ait-relay";
-/**
-* In-process `PoolWorker` backed by a CDP relay. Mirrors `TypecheckPoolWorker`:
-* `send` handles the message in-process and emits a `WorkerResponse` via the
-* `'message'` listener registered by the core's pool driver.
-*/
-var RelayPoolWorker = class {
-	name = RELAY_POOL_NAME;
-	cacheFs = false;
-	project;
-	factory;
-	runOpts;
-	listeners = /* @__PURE__ */ new Map();
-	connection;
-	constructor(project, opts) {
-		this.project = project;
-		this.factory = opts.connection;
-		this.runOpts = opts.run;
-	}
-	on(event, callback) {
-		let set = this.listeners.get(event);
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			this.listeners.set(event, set);
-		}
-		set.add(callback);
-	}
-	off(event, callback) {
-		this.listeners.get(event)?.delete(callback);
-	}
-	emit(event, arg) {
-		const set = this.listeners.get(event);
-		if (!set) return;
-		for (const cb of set) cb(arg);
-	}
-	deserialize(data) {
-		return data;
-	}
-	async start() {}
-	async stop() {
-		if (this.connection) {
-			const conn = this.connection;
-			this.connection = void 0;
-			await this.factory.close(conn);
-		}
-	}
-	send(message) {
-		this.handle(message).then((response) => {
-			if (response) this.emit("message", response);
-		});
-	}
-	async handle(message) {
-		switch (message.type) {
-			case "start": return {
-				__vitest_worker_response__: true,
-				type: "started"
-			};
-			case "run":
-			case "collect": {
-				const files = message.context.files.map((s) => s.filepath);
-				return {
-					__vitest_worker_response__: true,
-					type: "testfileFinished",
-					error: await this.runFiles(files).catch((e) => e)
-				};
-			}
-			case "stop": return {
-				__vitest_worker_response__: true,
-				type: "stopped"
-			};
-			case "cancel": return;
-		}
-	}
-	/**
-	* Bundles + injects + collects the given files over the relay, synthesises a
-	* Vitest task graph per file, and reports it through `vitest.state` so the
-	* reporter/watch/UI ecosystem sees real results.
-	*
-	* Returns nothing on success; a thrown error is surfaced as the
-	* `testfileFinished` error (a whole-pool failure, e.g. relay unreachable).
-	*/
-	async runFiles(files) {
-		const report = await runTestFilesOverRelay(await this.ensureConnection(), files, this.runOpts);
-		const root = this.project.config.root;
-		const projectName = this.project.name || void 0;
-		const state = this.project.vitest.state;
-		for (const fileResult of report.files) {
-			const perFile = "error" in fileResult.result ? {
-				startedAt: report.startedAt,
-				duration: 0,
-				passed: 0,
-				failed: 1,
-				skipped: 0,
-				tests: []
-			} : fileResult.result;
-			const fileTask = synthesizeFileTask(fileResult.file, root, projectName, RELAY_POOL_NAME, perFile);
-			state.collectFiles(this.project, [fileTask]);
-			state.updateTasks(toTaskResultPacks(fileTask));
-			toTaskEventPacks(fileTask);
-		}
-	}
-	async ensureConnection() {
-		if (!this.connection) this.connection = await this.factory.open();
-		return this.connection;
-	}
-};
-/**
-* Creates the Vitest `PoolRunnerInitializer` for the relay pool.
-*
-* Wire it into a Vitest config as `pool: createRelayPool({ connection })`.
-* Vitest moves an object `pool` into `config.poolRunner` and dispatches files
-* whose pool name equals `RELAY_POOL_NAME` to our `createPoolWorker`.
-*
-* @example
-*   // vitest.config.ts
-*   import { createRelayPool } from '@ait-co/devtools/test-runner';
-*   export default defineConfig({
-*     test: { pool: createRelayPool({ connection: myFactory }) },
-*   });
-*/
-function createRelayPool(opts) {
-	return {
-		name: RELAY_POOL_NAME,
-		createPoolWorker(options) {
-			return new RelayPoolWorker(options.project, opts);
-		}
-	};
-}
-//#endregion
-export { RELAY_POOL_NAME, createRelayPool };
-
-//# sourceMappingURL=pool.js.map

package/dist/test-runner/pool.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool.js","names":[],"sources":["../../src/test-runner/pool.ts"],"sourcesContent":["/**\n * Vitest 4.x custom pool: runs mini-app tests on a real device WebView over a\n * CDP relay instead of in a Node child process.\n *\n * Vitest's pool abstraction lets a `PoolRunnerInitializer` create a `PoolWorker`\n * that the core drives via a `WorkerRequest`/`WorkerResponse` message protocol.\n * Built-in pools (`forks`/`threads`) fork a child process; the `typecheck` pool\n * runs in-process and handles messages synchronously. We follow the in-process\n * `TypecheckPoolWorker` shape: a single long-lived \"worker\" that, on a `run`\n * request, bundles + injects + collects each file over the relay (#644's\n * `runTestFilesOverRelay`), synthesises a Vitest task graph (`task-graph.ts`),\n * and reports it through `vitest.state` so reporters/watch/UI/snapshot all work.\n *\n * Single-attach constraint: the relay supports one active page, so we keep one\n * worker for the whole run (`isolate: false`) rather than starting/stopping per\n * file — per-file start/stop would re-attach the relay on every file.\n *\n * SECRET-HANDLING: the relay connection (wss/TOTP) is supplied by the caller's\n * factory and never logged here; bundle code and result values are not logged.\n */\n\nimport type { PoolOptions, PoolWorker, TestProject, WorkerRequest } from 'vitest/node';\nimport type { CdpConnection } from '../mcp/cdp-connection.js';\nimport type { RelayRunOptions } from './relay-worker.js';\nimport { runTestFilesOverRelay } from './relay-worker.js';\nimport { synthesizeFileTask, toTaskEventPacks, toTaskResultPacks } from './task-graph.js';\n\n/** The pool name Vitest matches against `getFilePoolName(project)`. */\nexport const RELAY_POOL_NAME = 'ait-relay';\n\n/**\n * Factory the caller provides to open (and later close) the CDP relay\n * connection. Called once per worker lifecycle (`start`). The returned\n * `close` runs on `stop`.\n *\n * Kept as a factory (not a live connection) so the pool can be constructed in\n * config before any device is attached, and so `start`/`stop` own the lifecycle.\n */\nexport interface RelayConnectionFactory {\n  /** Opens the relay connection. Resolves once the page is attached & ready. */\n  open(): Promise<CdpConnection>;\n  /** Closes the relay connection opened by {@link open}. */\n  close(connection: CdpConnection): Promise<void>;\n  /**\n   * CLI-only session-phase hook (#730) — drives the QR dashboard's `phase`\n   * field (`'running'` on run start, `'complete'` on run end) so the\n   * dashboard can push an immediate SSE update instead of waiting for a\n   * poll/watchdog. The pool (this file) has no equivalent lifecycle and\n   * omits it; only `createRelayConnectionFactory` (relay-factory.ts) sets it.\n   */\n  onSessionPhase?(phase: 'running' | 'complete'): void;\n  /**\n   * CLI-only manual-blocking prompt hook (devtools#741) — pushes the QR\n   * dashboard's `manualPrompt` field before each manual-tagged file is\n   * injected, so a human watching the dashboard sees which file is next and\n   * how far along the manual queue is. Pass `null` to clear the prompt (the\n   * CLI does this once all manual files have run). The pool has no\n   * equivalent lifecycle and omits it; only `createRelayConnectionFactory`\n   * sets it.\n   */\n  onManualPrompt?(prompt: { file: string; index: number; total: number } | null): void;\n}\n\n/** Options for {@link createRelayPool}. */\nexport interface RelayPoolOptions {\n  /** Opens/closes the relay connection. */\n  connection: RelayConnectionFactory;\n  /** Forwarded to `runTestFilesOverRelay` (bundle options, per-file timeout). */\n  run?: RelayRunOptions;\n}\n\n/* -------------------------------------------------------------------------- */\n/* WorkerResponse helpers                                                       */\n/* -------------------------------------------------------------------------- */\n\n/** Minimal `WorkerResponse` shape we emit. Matches vitest/node's union. */\ntype EmittedResponse =\n  | { __vitest_worker_response__: true; type: 'started'; error?: unknown }\n  | { __vitest_worker_response__: true; type: 'stopped'; error?: unknown }\n  | { __vitest_worker_response__: true; type: 'testfileFinished'; error?: unknown };\n\n/* -------------------------------------------------------------------------- */\n/* The in-process relay PoolWorker                                              */\n/* -------------------------------------------------------------------------- */\n\n/**\n * In-process `PoolWorker` backed by a CDP relay. Mirrors `TypecheckPoolWorker`:\n * `send` handles the message in-process and emits a `WorkerResponse` via the\n * `'message'` listener registered by the core's pool driver.\n */\nclass RelayPoolWorker implements PoolWorker {\n  readonly name = RELAY_POOL_NAME;\n  readonly cacheFs = false;\n\n  private readonly project: TestProject;\n  private readonly factory: RelayConnectionFactory;\n  private readonly runOpts: RelayRunOptions | undefined;\n  private readonly listeners = new Map<string, Set<(arg: unknown) => void>>();\n  private connection: CdpConnection | undefined;\n\n  constructor(project: TestProject, opts: RelayPoolOptions) {\n    this.project = project;\n    this.factory = opts.connection;\n    this.runOpts = opts.run;\n  }\n\n  on(event: string, callback: (arg: unknown) => void): void {\n    let set = this.listeners.get(event);\n    if (!set) {\n      set = new Set();\n      this.listeners.set(event, set);\n    }\n    set.add(callback);\n  }\n\n  off(event: string, callback: (arg: unknown) => void): void {\n    this.listeners.get(event)?.delete(callback);\n  }\n\n  private emit(event: string, arg: unknown): void {\n    const set = this.listeners.get(event);\n    if (!set) return;\n    for (const cb of set) cb(arg);\n  }\n\n  deserialize(data: unknown): unknown {\n    // Relay results arrive as plain JSON objects already — identity is correct.\n    return data;\n  }\n\n  async start(): Promise<void> {\n    // Lifecycle ownership lives here, but the connection is opened lazily on the\n    // first `run`/`collect` so a never-run worker never touches the device.\n  }\n\n  async stop(): Promise<void> {\n    if (this.connection) {\n      const conn = this.connection;\n      this.connection = undefined;\n      await this.factory.close(conn);\n    }\n  }\n\n  send(message: WorkerRequest): void {\n    // Fire-and-forget like TypecheckPoolWorker: handle async, emit on settle.\n    void this.handle(message).then((response) => {\n      if (response) this.emit('message', response);\n    });\n  }\n\n  private async handle(message: WorkerRequest): Promise<EmittedResponse | undefined> {\n    switch (message.type) {\n      case 'start':\n        return { __vitest_worker_response__: true, type: 'started' };\n      case 'run':\n      case 'collect': {\n        const files = message.context.files.map((s) => s.filepath);\n        const error = await this.runFiles(files).catch((e) => e);\n        return { __vitest_worker_response__: true, type: 'testfileFinished', error };\n      }\n      case 'stop':\n        return { __vitest_worker_response__: true, type: 'stopped' };\n      case 'cancel':\n        return undefined;\n    }\n  }\n\n  /**\n   * Bundles + injects + collects the given files over the relay, synthesises a\n   * Vitest task graph per file, and reports it through `vitest.state` so the\n   * reporter/watch/UI ecosystem sees real results.\n   *\n   * Returns nothing on success; a thrown error is surfaced as the\n   * `testfileFinished` error (a whole-pool failure, e.g. relay unreachable).\n   */\n  private async runFiles(files: string[]): Promise<void> {\n    const conn = await this.ensureConnection();\n    const report = await runTestFilesOverRelay(conn, files, this.runOpts);\n\n    const root = this.project.config.root;\n    const projectName = this.project.name || undefined;\n    const state = this.project.vitest.state;\n\n    for (const fileResult of report.files) {\n      const perFile =\n        'error' in fileResult.result\n          ? // Whole-file bundle/inject error → synthesise a failed file with no tests.\n            {\n              startedAt: report.startedAt,\n              duration: 0,\n              passed: 0,\n              failed: 1,\n              skipped: 0,\n              tests: [],\n            }\n          : fileResult.result;\n\n      const fileTask = synthesizeFileTask(\n        fileResult.file,\n        root,\n        projectName,\n        RELAY_POOL_NAME,\n        perFile,\n      );\n\n      state.collectFiles(this.project, [fileTask]);\n      state.updateTasks(toTaskResultPacks(fileTask));\n      // Event packs drive reporter progress; updateTasks already recorded\n      // results, so events are advisory but keep watch/UI output coherent.\n      void toTaskEventPacks(fileTask);\n    }\n  }\n\n  private async ensureConnection(): Promise<CdpConnection> {\n    if (!this.connection) {\n      this.connection = await this.factory.open();\n    }\n    return this.connection;\n  }\n}\n\n/* -------------------------------------------------------------------------- */\n/* PoolRunnerInitializer factory                                               */\n/* -------------------------------------------------------------------------- */\n\n/**\n * Creates the Vitest `PoolRunnerInitializer` for the relay pool.\n *\n * Wire it into a Vitest config as `pool: createRelayPool({ connection })`.\n * Vitest moves an object `pool` into `config.poolRunner` and dispatches files\n * whose pool name equals `RELAY_POOL_NAME` to our `createPoolWorker`.\n *\n * @example\n *   // vitest.config.ts\n *   import { createRelayPool } from '@ait-co/devtools/test-runner';\n *   export default defineConfig({\n *     test: { pool: createRelayPool({ connection: myFactory }) },\n *   });\n */\nexport function createRelayPool(opts: RelayPoolOptions): {\n  readonly name: string;\n  createPoolWorker: (options: PoolOptions) => PoolWorker;\n} {\n  return {\n    name: RELAY_POOL_NAME,\n    createPoolWorker(options: PoolOptions): PoolWorker {\n      return new RelayPoolWorker(options.project, opts);\n    },\n  };\n}\n"],"mappings":";;;;AA4BA,MAAa,kBAAkB;;;;;;AA8D/B,IAAM,kBAAN,MAA4C;CAC1C,OAAgB;CAChB,UAAmB;CAEnB;CACA;CACA;CACA,4BAA6B,IAAI,KAA0C;CAC3E;CAEA,YAAY,SAAsB,MAAwB;AACxD,OAAK,UAAU;AACf,OAAK,UAAU,KAAK;AACpB,OAAK,UAAU,KAAK;;CAGtB,GAAG,OAAe,UAAwC;EACxD,IAAI,MAAM,KAAK,UAAU,IAAI,MAAM;AACnC,MAAI,CAAC,KAAK;AACR,yBAAM,IAAI,KAAK;AACf,QAAK,UAAU,IAAI,OAAO,IAAI;;AAEhC,MAAI,IAAI,SAAS;;CAGnB,IAAI,OAAe,UAAwC;AACzD,OAAK,UAAU,IAAI,MAAM,EAAE,OAAO,SAAS;;CAG7C,KAAa,OAAe,KAAoB;EAC9C,MAAM,MAAM,KAAK,UAAU,IAAI,MAAM;AACrC,MAAI,CAAC,IAAK;AACV,OAAK,MAAM,MAAM,IAAK,IAAG,IAAI;;CAG/B,YAAY,MAAwB;AAElC,SAAO;;CAGT,MAAM,QAAuB;CAK7B,MAAM,OAAsB;AAC1B,MAAI,KAAK,YAAY;GACnB,MAAM,OAAO,KAAK;AAClB,QAAK,aAAa,KAAA;AAClB,SAAM,KAAK,QAAQ,MAAM,KAAK;;;CAIlC,KAAK,SAA8B;AAE5B,OAAK,OAAO,QAAQ,CAAC,MAAM,aAAa;AAC3C,OAAI,SAAU,MAAK,KAAK,WAAW,SAAS;IAC5C;;CAGJ,MAAc,OAAO,SAA8D;AACjF,UAAQ,QAAQ,MAAhB;GACE,KAAK,QACH,QAAO;IAAE,4BAA4B;IAAM,MAAM;IAAW;GAC9D,KAAK;GACL,KAAK,WAAW;IACd,MAAM,QAAQ,QAAQ,QAAQ,MAAM,KAAK,MAAM,EAAE,SAAS;AAE1D,WAAO;KAAE,4BAA4B;KAAM,MAAM;KAAoB,OADvD,MAAM,KAAK,SAAS,MAAM,CAAC,OAAO,MAAM,EAAE;KACoB;;GAE9E,KAAK,OACH,QAAO;IAAE,4BAA4B;IAAM,MAAM;IAAW;GAC9D,KAAK,SACH;;;;;;;;;;;CAYN,MAAc,SAAS,OAAgC;EAErD,MAAM,SAAS,MAAM,sBADR,MAAM,KAAK,kBAAkB,EACO,OAAO,KAAK,QAAQ;EAErE,MAAM,OAAO,KAAK,QAAQ,OAAO;EACjC,MAAM,cAAc,KAAK,QAAQ,QAAQ,KAAA;EACzC,MAAM,QAAQ,KAAK,QAAQ,OAAO;AAElC,OAAK,MAAM,cAAc,OAAO,OAAO;GACrC,MAAM,UACJ,WAAW,WAAW,SAElB;IACE,WAAW,OAAO;IAClB,UAAU;IACV,QAAQ;IACR,QAAQ;IACR,SAAS;IACT,OAAO,EAAE;IACV,GACD,WAAW;GAEjB,MAAM,WAAW,mBACf,WAAW,MACX,MACA,aACA,iBACA,QACD;AAED,SAAM,aAAa,KAAK,SAAS,CAAC,SAAS,CAAC;AAC5C,SAAM,YAAY,kBAAkB,SAAS,CAAC;AAGzC,oBAAiB,SAAS;;;CAInC,MAAc,mBAA2C;AACvD,MAAI,CAAC,KAAK,WACR,MAAK,aAAa,MAAM,KAAK,QAAQ,MAAM;AAE7C,SAAO,KAAK;;;;;;;;;;;;;;;;;AAsBhB,SAAgB,gBAAgB,MAG9B;AACA,QAAO;EACL,MAAM;EACN,iBAAiB,SAAkC;AACjD,UAAO,IAAI,gBAAgB,QAAQ,SAAS,KAAK;;EAEpD"}