@ait-co/devtools 0.1.107 → 0.1.109

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

@@ -0,0 +1,80 @@
+import { i as createRelayPool, n as RelayConnectionFactory, t as RELAY_POOL_NAME } from "../pool-CuVMzWGB.js";
+
+//#region src/test-runner/config.d.ts
+/**
+ * Resolved phone-test configuration returned by `definePhoneTestConfig`.
+ */
+interface PhoneTestConfig {
+  /**
+   * Glob patterns (relative to cwd) for test files to run on the device.
+   * Defaults to `['**\/*.phone.test.ts']`.
+   */
+  include: string[];
+  /**
+   * Per-file evaluate timeout in milliseconds. Defaults to 30 000.
+   */
+  timeoutMs: number;
+  /**
+   * Additional esbuild `external` patterns for bundling.
+   * The SDK package is always external; add more here if needed.
+   */
+  extraExternals: string[];
+}
+/** User-facing config shape accepted by `definePhoneTestConfig`. */
+interface PhoneTestUserConfig {
+  include?: string[];
+  timeoutMs?: number;
+  extraExternals?: string[];
+}
+/**
+ * Define a phone-relay test configuration.
+ *
+ * Merges user overrides with sensible defaults and returns a resolved
+ * `PhoneTestConfig`. This object can be passed to `runTestFilesOverRelay`
+ * (via the CLI or custom scripts) to run tests on a real device WebView.
+ */
+declare function definePhoneTestConfig(userConfig?: PhoneTestUserConfig): PhoneTestConfig;
+/**
+ * The slice of a Vitest `test` config this helper produces — `pool`,
+ * `include`, and `testTimeout`. Typed structurally (not against Vitest's
+ * `InlineConfig`) so consumers can spread it into their own `defineConfig`
+ * without this module taking a value dependency on `vitest`.
+ */
+interface PhoneVitestTestConfig {
+  /** The relay `PoolRunnerInitializer`, matched by `getFilePoolName`. */
+  pool: ReturnType<typeof createRelayPool>;
+  /** Glob patterns for device test files. */
+  include: string[];
+  /** Per-test timeout in ms (mirrors the relay per-file evaluate timeout). */
+  testTimeout: number;
+}
+/** User config accepted by {@link definePhoneVitestConfig}. */
+interface PhoneVitestUserConfig extends PhoneTestUserConfig {
+  /**
+   * Opens/closes the CDP relay connection that tests run over. Required —
+   * without it there is no device to dispatch files to.
+   *
+   * SECRET-HANDLING: the factory owns the relay wss/TOTP; this config object
+   * never stores or logs those values.
+   */
+  connection: RelayConnectionFactory;
+}
+/**
+ * Build the Vitest `test` config slice for running tests on a device over the
+ * relay. Spread the result into your Vitest config:
+ *
+ * @example
+ *   // vitest.config.ts
+ *   import { defineConfig } from 'vitest/config';
+ *   import { definePhoneVitestConfig } from '@ait-co/devtools/test-runner';
+ *   export default defineConfig({
+ *     test: definePhoneVitestConfig({ connection: myRelayFactory }),
+ *   });
+ *
+ * Files matching `include` are dispatched to the relay pool (named
+ * {@link RELAY_POOL_NAME}); everything else runs in Vitest's default pool.
+ */
+declare function definePhoneVitestConfig(userConfig: PhoneVitestUserConfig): PhoneVitestTestConfig;
+//#endregion
+export { PhoneTestConfig, PhoneTestUserConfig, PhoneVitestTestConfig, PhoneVitestUserConfig, RELAY_POOL_NAME, type RelayConnectionFactory, createRelayPool, definePhoneTestConfig, definePhoneVitestConfig };
+//# sourceMappingURL=config.d.ts.map

package/dist/test-runner/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/test-runner/config.ts"],"mappings":";;;;;AA6DA;UArCiB,eAAA;;;;;EAKf,OAAA;EAgCsF;;AAcxF;EA1CE,SAAA;;;;;EAKA,cAAA;AAAA;;UAIe,mBAAA;EACf,OAAA;EACA,SAAA;EACA,cAAA;AAAA;;;;;;;AAkEF;iBAlDgB,qBAAA,CAAsB,UAAA,GAAa,mBAAA,GAAsB,eAAA;;;;;;;UAcxD,qBAAA;;EAEf,IAAA,EAAM,UAAA,QAAkB,eAAA;;EAExB,OAAA;;EAEA,WAAA;AAAA;;UAIe,qBAAA,SAA8B,mBAAA;;;;;;;;EAQ7C,UAAA,EAAY,sBAAA;AAAA;;;;;;;;;;;;;;;;iBAkBE,uBAAA,CAAwB,UAAA,EAAY,qBAAA,GAAwB,qBAAA"}

package/dist/test-runner/config.js

@@ -0,0 +1,54 @@
+import { RELAY_POOL_NAME, createRelayPool } from "./pool.js";
+//#region src/test-runner/config.ts
+const DEFAULT_CONFIG = {
+	include: ["**/*.phone.test.ts"],
+	timeoutMs: 3e4,
+	extraExternals: []
+};
+/**
+* Define a phone-relay test configuration.
+*
+* Merges user overrides with sensible defaults and returns a resolved
+* `PhoneTestConfig`. This object can be passed to `runTestFilesOverRelay`
+* (via the CLI or custom scripts) to run tests on a real device WebView.
+*/
+function definePhoneTestConfig(userConfig) {
+	return {
+		include: userConfig?.include ?? DEFAULT_CONFIG.include,
+		timeoutMs: userConfig?.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,
+		extraExternals: userConfig?.extraExternals ?? DEFAULT_CONFIG.extraExternals
+	};
+}
+/**
+* Build the Vitest `test` config slice for running tests on a device over the
+* relay. Spread the result into your Vitest config:
+*
+* @example
+*   // vitest.config.ts
+*   import { defineConfig } from 'vitest/config';
+*   import { definePhoneVitestConfig } from '@ait-co/devtools/test-runner';
+*   export default defineConfig({
+*     test: definePhoneVitestConfig({ connection: myRelayFactory }),
+*   });
+*
+* Files matching `include` are dispatched to the relay pool (named
+* {@link RELAY_POOL_NAME}); everything else runs in Vitest's default pool.
+*/
+function definePhoneVitestConfig(userConfig) {
+	const resolved = definePhoneTestConfig(userConfig);
+	return {
+		pool: createRelayPool({
+			connection: userConfig.connection,
+			run: {
+				timeoutMs: resolved.timeoutMs,
+				bundleOptions: { extraExternals: resolved.extraExternals }
+			}
+		}),
+		include: resolved.include,
+		testTimeout: resolved.timeoutMs
+	};
+}
+//#endregion
+export { RELAY_POOL_NAME, createRelayPool, definePhoneTestConfig, definePhoneVitestConfig };
+
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":[],"sources":["../../src/test-runner/config.ts"],"sourcesContent":["/**\n * Configuration helper for phone-relay test runs.\n *\n * `definePhoneTestConfig` is the user-facing entry point for configuring the\n * relay test runner. It mirrors the pattern of Vitest's `defineConfig` so\n * users can write:\n *\n *   // phone-test.config.ts\n *   import { definePhoneTestConfig } from '@ait-co/devtools/test-runner';\n *   export default definePhoneTestConfig({ ... });\n *\n * The helper resolves user config and, when given a relay connection factory,\n * builds the Vitest `pool` (`createRelayPool`) so Vitest's own config\n * resolution routes matching files to the device over the relay (#645). Without\n * a connection factory it still returns the resolved config for use with the\n * lower-level `runTestFilesOverRelay` transport (#644).\n */\n\nimport type { RelayConnectionFactory } from './pool.js';\nimport { createRelayPool, RELAY_POOL_NAME } from './pool.js';\n\n/**\n * Resolved phone-test configuration returned by `definePhoneTestConfig`.\n */\nexport interface PhoneTestConfig {\n  /**\n   * Glob patterns (relative to cwd) for test files to run on the device.\n   * Defaults to `['**\\/*.phone.test.ts']`.\n   */\n  include: string[];\n  /**\n   * Per-file evaluate timeout in milliseconds. Defaults to 30 000.\n   */\n  timeoutMs: number;\n  /**\n   * Additional esbuild `external` patterns for bundling.\n   * The SDK package is always external; add more here if needed.\n   */\n  extraExternals: string[];\n}\n\n/** User-facing config shape accepted by `definePhoneTestConfig`. */\nexport interface PhoneTestUserConfig {\n  include?: string[];\n  timeoutMs?: number;\n  extraExternals?: string[];\n}\n\nconst DEFAULT_CONFIG: PhoneTestConfig = {\n  include: ['**/*.phone.test.ts'],\n  timeoutMs: 30_000,\n  extraExternals: [],\n};\n\n/**\n * Define a phone-relay test configuration.\n *\n * Merges user overrides with sensible defaults and returns a resolved\n * `PhoneTestConfig`. This object can be passed to `runTestFilesOverRelay`\n * (via the CLI or custom scripts) to run tests on a real device WebView.\n */\nexport function definePhoneTestConfig(userConfig?: PhoneTestUserConfig): PhoneTestConfig {\n  return {\n    include: userConfig?.include ?? DEFAULT_CONFIG.include,\n    timeoutMs: userConfig?.timeoutMs ?? DEFAULT_CONFIG.timeoutMs,\n    extraExternals: userConfig?.extraExternals ?? DEFAULT_CONFIG.extraExternals,\n  };\n}\n\n/**\n * The slice of a Vitest `test` config this helper produces — `pool`,\n * `include`, and `testTimeout`. Typed structurally (not against Vitest's\n * `InlineConfig`) so consumers can spread it into their own `defineConfig`\n * without this module taking a value dependency on `vitest`.\n */\nexport interface PhoneVitestTestConfig {\n  /** The relay `PoolRunnerInitializer`, matched by `getFilePoolName`. */\n  pool: ReturnType<typeof createRelayPool>;\n  /** Glob patterns for device test files. */\n  include: string[];\n  /** Per-test timeout in ms (mirrors the relay per-file evaluate timeout). */\n  testTimeout: number;\n}\n\n/** User config accepted by {@link definePhoneVitestConfig}. */\nexport interface PhoneVitestUserConfig extends PhoneTestUserConfig {\n  /**\n   * Opens/closes the CDP relay connection that tests run over. Required —\n   * without it there is no device to dispatch files to.\n   *\n   * SECRET-HANDLING: the factory owns the relay wss/TOTP; this config object\n   * never stores or logs those values.\n   */\n  connection: RelayConnectionFactory;\n}\n\n/**\n * Build the Vitest `test` config slice for running tests on a device over the\n * relay. Spread the result into your Vitest config:\n *\n * @example\n *   // vitest.config.ts\n *   import { defineConfig } from 'vitest/config';\n *   import { definePhoneVitestConfig } from '@ait-co/devtools/test-runner';\n *   export default defineConfig({\n *     test: definePhoneVitestConfig({ connection: myRelayFactory }),\n *   });\n *\n * Files matching `include` are dispatched to the relay pool (named\n * {@link RELAY_POOL_NAME}); everything else runs in Vitest's default pool.\n */\nexport function definePhoneVitestConfig(userConfig: PhoneVitestUserConfig): PhoneVitestTestConfig {\n  const resolved = definePhoneTestConfig(userConfig);\n  return {\n    pool: createRelayPool({\n      connection: userConfig.connection,\n      run: {\n        timeoutMs: resolved.timeoutMs,\n        bundleOptions: { extraExternals: resolved.extraExternals },\n      },\n    }),\n    include: resolved.include,\n    testTimeout: resolved.timeoutMs,\n  };\n}\n\nexport type { RelayConnectionFactory };\nexport { createRelayPool, RELAY_POOL_NAME };\n"],"mappings":";;AAgDA,MAAM,iBAAkC;CACtC,SAAS,CAAC,qBAAqB;CAC/B,WAAW;CACX,gBAAgB,EAAE;CACnB;;;;;;;;AASD,SAAgB,sBAAsB,YAAmD;AACvF,QAAO;EACL,SAAS,YAAY,WAAW,eAAe;EAC/C,WAAW,YAAY,aAAa,eAAe;EACnD,gBAAgB,YAAY,kBAAkB,eAAe;EAC9D;;;;;;;;;;;;;;;;;AA6CH,SAAgB,wBAAwB,YAA0D;CAChG,MAAM,WAAW,sBAAsB,WAAW;AAClD,QAAO;EACL,MAAM,gBAAgB;GACpB,YAAY,WAAW;GACvB,KAAK;IACH,WAAW,SAAS;IACpB,eAAe,EAAE,gBAAgB,SAAS,gBAAgB;IAC3D;GACF,CAAC;EACF,SAAS,SAAS;EAClB,aAAa,SAAS;EACvB"}

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

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

package/dist/test-runner/pool.js

@@ -0,0 +1,136 @@
+import { runTestFilesOverRelay } from "./relay-worker.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

@@ -0,0 +1 @@
+{"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\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;;;;;;AA4C/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"}

package/dist/test-runner/relay-worker.d.ts

@@ -0,0 +1,2 @@
+import { a as runTestFilesOverRelay, i as flattenResults, n as RelayRunOptions, r as RelayRunReport, t as FileResult } from "../relay-worker-xxanNQGs.js";
+export { FileResult, RelayRunOptions, RelayRunReport, flattenResults, runTestFilesOverRelay };

package/dist/test-runner/relay-worker.js

@@ -0,0 +1,96 @@
+import { bundleTestFile } from "./bundle.js";
+import { injectAndRunBundle } from "./rpc.js";
+//#region src/test-runner/relay-worker.ts
+/**
+* Runs all `files` sequentially over the given CDP `connection`.
+*
+* For each file:
+*   1. Bundle with esbuild (includes SDK shim + runtime).
+*   2. Inject into the attached page via `Runtime.evaluate`.
+*   3. Await the `RunReport` JSON response.
+*   4. Accumulate results.
+*
+* Returns a `RelayRunReport` with per-file results and flattened totals.
+*
+* This function does NOT open or manage the relay connection — the caller
+* is responsible for attaching and closing it.
+*
+* TODO (#645): implement the Vitest `PoolRunnerInitializer` interface here
+* so that `runTestFilesOverRelay` can be used as a Vitest pool entry.
+*
+* @param connection - Active CDP connection (relay or local kind).
+* @param files      - Absolute paths to test files, run in order.
+* @param opts       - Optional per-run overrides.
+*/
+async function runTestFilesOverRelay(connection, files, opts) {
+	const wallStart = Date.now();
+	const startedAt = new Date(wallStart).toISOString();
+	const fileResults = [];
+	for (const file of files) {
+		let fileEntry;
+		try {
+			const { code } = await bundleTestFile(file, opts?.bundleOptions);
+			const rpcResult = await injectAndRunBundle(connection, code, opts?.timeoutMs);
+			if (rpcResult.ok) fileEntry = {
+				file,
+				result: rpcResult.report
+			};
+			else fileEntry = {
+				file,
+				result: { error: rpcResult.error }
+			};
+		} catch (e) {
+			fileEntry = {
+				file,
+				result: { error: e instanceof Error ? e.message : String(e) }
+			};
+		}
+		fileResults.push(fileEntry);
+	}
+	const totals = fileResults.reduce((acc, { result }) => {
+		if ("error" in result) {
+			acc.failed += 1;
+			acc.total += 1;
+		} else {
+			acc.passed += result.passed;
+			acc.failed += result.failed;
+			acc.skipped += result.skipped;
+			acc.total += result.passed + result.failed + result.skipped;
+		}
+		return acc;
+	}, {
+		passed: 0,
+		failed: 0,
+		skipped: 0,
+		total: 0
+	});
+	return {
+		startedAt,
+		duration: Date.now() - wallStart,
+		files: fileResults,
+		totals
+	};
+}
+/**
+* Flattens all test results from a `RelayRunReport` into a single array.
+* Files that errored during bundle/inject produce a synthetic failed entry.
+*/
+function flattenResults(report) {
+	const out = [];
+	for (const { file, result } of report.files) if ("error" in result) out.push({
+		file,
+		name: `<bundle/inject error>`,
+		status: "fail",
+		duration: 0,
+		error: result.error
+	});
+	else for (const t of result.tests) out.push({
+		...t,
+		file
+	});
+	return out;
+}
+//#endregion
+export { flattenResults, runTestFilesOverRelay };
+
+//# sourceMappingURL=relay-worker.js.map

package/dist/test-runner/relay-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-worker.js","names":[],"sources":["../../src/test-runner/relay-worker.ts"],"sourcesContent":["/**\n * Orchestrator: runs a list of test files sequentially over a CDP relay.\n *\n * Each file goes through: bundle → inject → run → collect.\n * This is the transport layer: it does NOT integrate with Vitest's pool or the\n * MCP surface. The Vitest custom pool (`pool.ts`) and the `run_tests` MCP tool\n * are separate callers that build on this orchestrator.\n *\n * Single-attach constraint: only one page is active at a time. Files run\n * sequentially; parallel execution across targets is out of scope.\n *\n * The 30-second per-file timeout is inherited from `injectAndRunBundle`.\n * For suites that exceed it, split the file into smaller pieces.\n *\n * SECRET-HANDLING: file paths are surfaced in reports; relay URLs are not.\n */\n\nimport type { CdpConnection } from '../mcp/cdp-connection.js';\nimport { type BundleOptions, bundleTestFile } from './bundle.js';\nimport { injectAndRunBundle } from './rpc.js';\nimport type { RunReport, TestResult } from './runtime.js';\n\n/** Per-file result in the aggregate `RunReport`. */\nexport interface FileResult {\n  /** Absolute or relative path to the test file. */\n  file: string;\n  /** Full run report for this file, or an error if bundling/injection failed. */\n  result: RunReport | { error: string };\n}\n\n/** Aggregate report returned by `runTestFilesOverRelay`. */\nexport interface RelayRunReport {\n  /** ISO timestamp of when the run started. */\n  startedAt: string;\n  /** Total elapsed wall-clock milliseconds. */\n  duration: number;\n  /** Per-file results in execution order. */\n  files: FileResult[];\n  /** Flattened totals across all files. */\n  totals: {\n    passed: number;\n    failed: number;\n    skipped: number;\n    total: number;\n  };\n}\n\n/** Options for `runTestFilesOverRelay`. */\nexport interface RelayRunOptions {\n  /**\n   * Options forwarded to `bundleTestFile` for each file.\n   */\n  bundleOptions?: BundleOptions;\n  /**\n   * Per-file evaluate timeout in milliseconds. Defaults to 30 000.\n   * Increase for long-running suites or split the file.\n   */\n  timeoutMs?: number;\n}\n\n/**\n * Runs all `files` sequentially over the given CDP `connection`.\n *\n * For each file:\n *   1. Bundle with esbuild (includes SDK shim + runtime).\n *   2. Inject into the attached page via `Runtime.evaluate`.\n *   3. Await the `RunReport` JSON response.\n *   4. Accumulate results.\n *\n * Returns a `RelayRunReport` with per-file results and flattened totals.\n *\n * This function does NOT open or manage the relay connection — the caller\n * is responsible for attaching and closing it.\n *\n * TODO (#645): implement the Vitest `PoolRunnerInitializer` interface here\n * so that `runTestFilesOverRelay` can be used as a Vitest pool entry.\n *\n * @param connection - Active CDP connection (relay or local kind).\n * @param files      - Absolute paths to test files, run in order.\n * @param opts       - Optional per-run overrides.\n */\nexport async function runTestFilesOverRelay(\n  connection: CdpConnection,\n  files: string[],\n  opts?: RelayRunOptions,\n): Promise<RelayRunReport> {\n  const wallStart = Date.now();\n  const startedAt = new Date(wallStart).toISOString();\n  const fileResults: FileResult[] = [];\n\n  for (const file of files) {\n    let fileEntry: FileResult;\n    try {\n      const { code } = await bundleTestFile(file, opts?.bundleOptions);\n      const rpcResult = await injectAndRunBundle(connection, code, opts?.timeoutMs);\n      if (rpcResult.ok) {\n        fileEntry = { file, result: rpcResult.report };\n      } else {\n        fileEntry = { file, result: { error: rpcResult.error } };\n      }\n    } catch (e) {\n      // Capture bundle/inject errors per-file so subsequent files still run.\n      fileEntry = {\n        file,\n        result: {\n          error: e instanceof Error ? e.message : String(e),\n        },\n      };\n    }\n    fileResults.push(fileEntry);\n  }\n\n  const totals = fileResults.reduce(\n    (acc, { result }) => {\n      if ('error' in result) {\n        // Treat whole-file errors as a single failure.\n        acc.failed += 1;\n        acc.total += 1;\n      } else {\n        acc.passed += result.passed;\n        acc.failed += result.failed;\n        acc.skipped += result.skipped;\n        acc.total += result.passed + result.failed + result.skipped;\n      }\n      return acc;\n    },\n    { passed: 0, failed: 0, skipped: 0, total: 0 },\n  );\n\n  return {\n    startedAt,\n    duration: Date.now() - wallStart,\n    files: fileResults,\n    totals,\n  };\n}\n\n/**\n * Flattens all test results from a `RelayRunReport` into a single array.\n * Files that errored during bundle/inject produce a synthetic failed entry.\n */\nexport function flattenResults(report: RelayRunReport): Array<TestResult & { file: string }> {\n  const out: Array<TestResult & { file: string }> = [];\n  for (const { file, result } of report.files) {\n    if ('error' in result) {\n      out.push({\n        file,\n        name: `<bundle/inject error>`,\n        status: 'fail',\n        duration: 0,\n        error: result.error,\n      });\n    } else {\n      for (const t of result.tests) {\n        out.push({ ...t, file });\n      }\n    }\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAiFA,eAAsB,sBACpB,YACA,OACA,MACyB;CACzB,MAAM,YAAY,KAAK,KAAK;CAC5B,MAAM,YAAY,IAAI,KAAK,UAAU,CAAC,aAAa;CACnD,MAAM,cAA4B,EAAE;AAEpC,MAAK,MAAM,QAAQ,OAAO;EACxB,IAAI;AACJ,MAAI;GACF,MAAM,EAAE,SAAS,MAAM,eAAe,MAAM,MAAM,cAAc;GAChE,MAAM,YAAY,MAAM,mBAAmB,YAAY,MAAM,MAAM,UAAU;AAC7E,OAAI,UAAU,GACZ,aAAY;IAAE;IAAM,QAAQ,UAAU;IAAQ;OAE9C,aAAY;IAAE;IAAM,QAAQ,EAAE,OAAO,UAAU,OAAO;IAAE;WAEnD,GAAG;AAEV,eAAY;IACV;IACA,QAAQ,EACN,OAAO,aAAa,QAAQ,EAAE,UAAU,OAAO,EAAE,EAClD;IACF;;AAEH,cAAY,KAAK,UAAU;;CAG7B,MAAM,SAAS,YAAY,QACxB,KAAK,EAAE,aAAa;AACnB,MAAI,WAAW,QAAQ;AAErB,OAAI,UAAU;AACd,OAAI,SAAS;SACR;AACL,OAAI,UAAU,OAAO;AACrB,OAAI,UAAU,OAAO;AACrB,OAAI,WAAW,OAAO;AACtB,OAAI,SAAS,OAAO,SAAS,OAAO,SAAS,OAAO;;AAEtD,SAAO;IAET;EAAE,QAAQ;EAAG,QAAQ;EAAG,SAAS;EAAG,OAAO;EAAG,CAC/C;AAED,QAAO;EACL;EACA,UAAU,KAAK,KAAK,GAAG;EACvB,OAAO;EACP;EACD;;;;;;AAOH,SAAgB,eAAe,QAA8D;CAC3F,MAAM,MAA4C,EAAE;AACpD,MAAK,MAAM,EAAE,MAAM,YAAY,OAAO,MACpC,KAAI,WAAW,OACb,KAAI,KAAK;EACP;EACA,MAAM;EACN,QAAQ;EACR,UAAU;EACV,OAAO,OAAO;EACf,CAAC;KAEF,MAAK,MAAM,KAAK,OAAO,MACrB,KAAI,KAAK;EAAE,GAAG;EAAG;EAAM,CAAC;AAI9B,QAAO"}

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

@@ -0,0 +1,53 @@
+import { t as CdpConnection } from "../cdp-connection-C0AP0tH2.js";
+import { t as RunReport } from "../runtime-Wi5d6Ywz.js";
+
+//#region src/test-runner/rpc.d.ts
+/**
+ * Wraps bundle code in a self-executing IIFE that:
+ *   1. Evaluates the bundle (registering describe/it/test).
+ *   2. Calls `__testBundle.runTestModule(...)` — the entry the runtime exports.
+ *   3. Returns a JSON-serialised `RunReport` string.
+ *
+ * The double-serialisation (RunReport → JSON string → returnByValue string)
+ * is intentional: CDP `returnByValue` reliably transports strings; deeply
+ * nested objects can lose fidelity across the Chii relay.
+ *
+ * SECRET-HANDLING: `bundleCode` MUST NOT be logged by callers.
+ */
+declare function buildRunTestsExpression(bundleCode: string): string;
+/**
+ * Result of `injectAndRunBundle`.
+ */
+type RpcRunResult = {
+  ok: true;
+  report: RunReport;
+} | {
+  ok: false;
+  error: string;
+};
+/**
+ * Parses the raw CDP `returnByValue` result from a `buildRunTestsExpression`
+ * evaluate call into a typed `RpcRunResult`.
+ *
+ * Throws only on parse failure — an `ok:false` envelope is a normal result.
+ *
+ * SECRET-HANDLING: `rawValue` is not included in error messages.
+ */
+declare function parseRunTestsResult(rawValue: unknown): RpcRunResult;
+/**
+ * Injects `bundleCode` into the attached page and awaits test execution.
+ *
+ * Uses `Runtime.evaluate` with `awaitPromise: true` to wait for the
+ * async IIFE to settle.  The 30-second CDP command timeout covers even
+ * long-running test suites; split into smaller files if you hit it.
+ *
+ * @param connection   - Active CDP connection (relay or local).
+ * @param bundleCode   - IIFE bundle string from `bundleTestFile`.
+ * @param timeoutMs    - Override the default 30 s timeout.
+ *
+ * SECRET-HANDLING: `bundleCode` and the raw CDP result value are never logged.
+ */
+declare function injectAndRunBundle(connection: CdpConnection, bundleCode: string, timeoutMs?: number): Promise<RpcRunResult>;
+//#endregion
+export { RpcRunResult, buildRunTestsExpression, injectAndRunBundle, parseRunTestsResult };
+//# sourceMappingURL=rpc.d.ts.map

package/dist/test-runner/rpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.d.ts","names":[],"sources":["../../src/test-runner/rpc.ts"],"mappings":";;;;;;;;;;;;;AAmEA;;;iBAvCgB,uBAAA,CAAwB,UAAA;;AAiFxC;;KApDY,YAAA;EAAiB,EAAA;EAAU,MAAA,EAAQ,SAAA;AAAA;EAAgB,EAAA;EAAW,KAAA;AAAA;;;;;;;;;iBAU1D,mBAAA,CAAoB,QAAA,YAAoB,YAAA;;;;;;;;;;;;;;iBA0ClC,kBAAA,CACpB,UAAA,EAAY,aAAA,EACZ,UAAA,UACA,SAAA,YACC,OAAA,CAAQ,YAAA"}

package/dist/test-runner/rpc.js

@@ -0,0 +1,78 @@
+//#region src/test-runner/rpc.ts
+/** Maximum milliseconds to wait for a single evaluate round-trip. */
+const DEFAULT_TIMEOUT_MS = 3e4;
+/**
+* Wraps bundle code in a self-executing IIFE that:
+*   1. Evaluates the bundle (registering describe/it/test).
+*   2. Calls `__testBundle.runTestModule(...)` — the entry the runtime exports.
+*   3. Returns a JSON-serialised `RunReport` string.
+*
+* The double-serialisation (RunReport → JSON string → returnByValue string)
+* is intentional: CDP `returnByValue` reliably transports strings; deeply
+* nested objects can lose fidelity across the Chii relay.
+*
+* SECRET-HANDLING: `bundleCode` MUST NOT be logged by callers.
+*/
+function buildRunTestsExpression(bundleCode) {
+	return `(async () => {  try { ${bundleCode} } catch(e) {    return JSON.stringify({ok:false,error:'bundle-eval: ' + String(e && e.message || e)});  }  if (typeof globalThis.__testBundle !== 'object' || typeof globalThis.__testBundle.runTestModule !== 'function' || typeof globalThis.__testBundle.__userFactory !== 'function') {    return JSON.stringify({ok:false,error:'bundle-missing-export: __testBundle.runTestModule or __userFactory is not a function'});  }  try {    const report = await globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory);    return JSON.stringify({ok:true,value:report});  } catch(e) {    return JSON.stringify({ok:false,error:'test-run: ' + String(e && e.message || e)});  }})()`;
+}
+/**
+* Parses the raw CDP `returnByValue` result from a `buildRunTestsExpression`
+* evaluate call into a typed `RpcRunResult`.
+*
+* Throws only on parse failure — an `ok:false` envelope is a normal result.
+*
+* SECRET-HANDLING: `rawValue` is not included in error messages.
+*/
+function parseRunTestsResult(rawValue) {
+	if (typeof rawValue !== "string") throw new Error(`rpc.parseRunTestsResult: unexpected return type "${typeof rawValue}" — expected JSON string`);
+	let parsed;
+	try {
+		parsed = JSON.parse(rawValue);
+	} catch {
+		throw new Error("rpc.parseRunTestsResult: bridge returned non-JSON string");
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("rpc.parseRunTestsResult: parsed result is not an object");
+	const obj = parsed;
+	if (obj.ok === true) return {
+		ok: true,
+		report: obj.value
+	};
+	if (obj.ok === false) return {
+		ok: false,
+		error: typeof obj.error === "string" ? obj.error : String(obj.error)
+	};
+	throw new Error("rpc.parseRunTestsResult: result missing \"ok\" field");
+}
+/**
+* Injects `bundleCode` into the attached page and awaits test execution.
+*
+* Uses `Runtime.evaluate` with `awaitPromise: true` to wait for the
+* async IIFE to settle.  The 30-second CDP command timeout covers even
+* long-running test suites; split into smaller files if you hit it.
+*
+* @param connection   - Active CDP connection (relay or local).
+* @param bundleCode   - IIFE bundle string from `bundleTestFile`.
+* @param timeoutMs    - Override the default 30 s timeout.
+*
+* SECRET-HANDLING: `bundleCode` and the raw CDP result value are never logged.
+*/
+async function injectAndRunBundle(connection, bundleCode, timeoutMs = DEFAULT_TIMEOUT_MS) {
+	const expression = buildRunTestsExpression(bundleCode);
+	const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error(`rpc: evaluate timed out after ${timeoutMs}ms`)), timeoutMs));
+	const evalPromise = connection.send("Runtime.evaluate", {
+		expression,
+		returnByValue: true,
+		awaitPromise: true
+	});
+	const cdpResult = await Promise.race([evalPromise, timeoutPromise]);
+	if (cdpResult.exceptionDetails) {
+		const msg = cdpResult.exceptionDetails.exception?.description ?? cdpResult.exceptionDetails.text ?? "Runtime.evaluate threw an exception";
+		throw new Error(`rpc.injectAndRunBundle: ${msg}`);
+	}
+	return parseRunTestsResult(cdpResult.result.value);
+}
+//#endregion
+export { buildRunTestsExpression, injectAndRunBundle, parseRunTestsResult };
+
+//# sourceMappingURL=rpc.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rpc.js","names":[],"sources":["../../src/test-runner/rpc.ts"],"sourcesContent":["/**\n * Node-side RPC helpers for injecting and collecting test execution over CDP.\n *\n * Uses the same IIFE + JSON.stringify envelope pattern as `buildCallSdkExpression`\n * in `src/mcp/tools.ts` to reliably shuttle structured results through\n * `Runtime.evaluate`'s `returnByValue: true` boundary.\n *\n * SECRET-HANDLING: bundle code, relay URLs, and result values are NOT logged.\n */\n\nimport type { CdpConnection } from '../mcp/cdp-connection.js';\nimport type { RunReport } from './runtime.js';\n\n/** Maximum milliseconds to wait for a single evaluate round-trip. */\nconst DEFAULT_TIMEOUT_MS = 30_000;\n\n/**\n * Wraps bundle code in a self-executing IIFE that:\n *   1. Evaluates the bundle (registering describe/it/test).\n *   2. Calls `__testBundle.runTestModule(...)` — the entry the runtime exports.\n *   3. Returns a JSON-serialised `RunReport` string.\n *\n * The double-serialisation (RunReport → JSON string → returnByValue string)\n * is intentional: CDP `returnByValue` reliably transports strings; deeply\n * nested objects can lose fidelity across the Chii relay.\n *\n * SECRET-HANDLING: `bundleCode` MUST NOT be logged by callers.\n */\nexport function buildRunTestsExpression(bundleCode: string): string {\n  // We trust bundleCode is already a self-contained IIFE that installs\n  // `window.__testBundle` (or `globalThis.__testBundle`).\n  // We then call `__testBundle.runTestModule()` and return a JSON string.\n  return (\n    `(async () => {` +\n    // Step 1: evaluate the bundle to register tests\n    `  try { ${bundleCode} } catch(e) {` +\n    `    return JSON.stringify({ok:false,error:'bundle-eval: ' + String(e && e.message || e)});` +\n    `  }` +\n    // Step 2: check that the expected exports are present\n    `  if (typeof globalThis.__testBundle !== 'object' || typeof globalThis.__testBundle.runTestModule !== 'function' || typeof globalThis.__testBundle.__userFactory !== 'function') {` +\n    `    return JSON.stringify({ok:false,error:'bundle-missing-export: __testBundle.runTestModule or __userFactory is not a function'});` +\n    `  }` +\n    // Step 3: run tests — pass the factory so runTestModule installs globals\n    // first, then invokes the factory to register describe/it/test blocks.\n    `  try {` +\n    `    const report = await globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory);` +\n    `    return JSON.stringify({ok:true,value:report});` +\n    `  } catch(e) {` +\n    `    return JSON.stringify({ok:false,error:'test-run: ' + String(e && e.message || e)});` +\n    `  }` +\n    `})()`\n  );\n}\n\n/**\n * Result of `injectAndRunBundle`.\n */\nexport type RpcRunResult = { ok: true; report: RunReport } | { ok: false; error: string };\n\n/**\n * Parses the raw CDP `returnByValue` result from a `buildRunTestsExpression`\n * evaluate call into a typed `RpcRunResult`.\n *\n * Throws only on parse failure — an `ok:false` envelope is a normal result.\n *\n * SECRET-HANDLING: `rawValue` is not included in error messages.\n */\nexport function parseRunTestsResult(rawValue: unknown): RpcRunResult {\n  if (typeof rawValue !== 'string') {\n    throw new Error(\n      `rpc.parseRunTestsResult: unexpected return type \"${typeof rawValue}\" — expected JSON string`,\n    );\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(rawValue);\n  } catch {\n    // Do NOT include rawValue — could contain secrets.\n    throw new Error('rpc.parseRunTestsResult: bridge returned non-JSON string');\n  }\n  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {\n    throw new Error('rpc.parseRunTestsResult: parsed result is not an object');\n  }\n  const obj = parsed as Record<string, unknown>;\n  if (obj.ok === true) {\n    return { ok: true, report: obj.value as RunReport };\n  }\n  if (obj.ok === false) {\n    return {\n      ok: false,\n      error: typeof obj.error === 'string' ? obj.error : String(obj.error),\n    };\n  }\n  throw new Error('rpc.parseRunTestsResult: result missing \"ok\" field');\n}\n\n/**\n * Injects `bundleCode` into the attached page and awaits test execution.\n *\n * Uses `Runtime.evaluate` with `awaitPromise: true` to wait for the\n * async IIFE to settle.  The 30-second CDP command timeout covers even\n * long-running test suites; split into smaller files if you hit it.\n *\n * @param connection   - Active CDP connection (relay or local).\n * @param bundleCode   - IIFE bundle string from `bundleTestFile`.\n * @param timeoutMs    - Override the default 30 s timeout.\n *\n * SECRET-HANDLING: `bundleCode` and the raw CDP result value are never logged.\n */\nexport async function injectAndRunBundle(\n  connection: CdpConnection,\n  bundleCode: string,\n  timeoutMs = DEFAULT_TIMEOUT_MS,\n): Promise<RpcRunResult> {\n  const expression = buildRunTestsExpression(bundleCode);\n\n  // Use AbortSignal-style timeout via Promise.race so we surface a clear\n  // message rather than hanging indefinitely.\n  const timeoutPromise = new Promise<never>((_, reject) =>\n    setTimeout(() => reject(new Error(`rpc: evaluate timed out after ${timeoutMs}ms`)), timeoutMs),\n  );\n\n  const evalPromise = connection.send('Runtime.evaluate', {\n    expression,\n    returnByValue: true,\n    awaitPromise: true,\n  });\n\n  const cdpResult = await Promise.race([evalPromise, timeoutPromise]);\n\n  if (cdpResult.exceptionDetails) {\n    // Surface only the engine error string — not the expression or value.\n    const msg =\n      cdpResult.exceptionDetails.exception?.description ??\n      cdpResult.exceptionDetails.text ??\n      'Runtime.evaluate threw an exception';\n    throw new Error(`rpc.injectAndRunBundle: ${msg}`);\n  }\n\n  return parseRunTestsResult(cdpResult.result.value);\n}\n"],"mappings":";;AAcA,MAAM,qBAAqB;;;;;;;;;;;;;AAc3B,SAAgB,wBAAwB,YAA4B;AAIlE,QACE,yBAEW,WAAW;;;;;;;;;;AAgC1B,SAAgB,oBAAoB,UAAiC;AACnE,KAAI,OAAO,aAAa,SACtB,OAAM,IAAI,MACR,oDAAoD,OAAO,SAAS,0BACrE;CAEH,IAAI;AACJ,KAAI;AACF,WAAS,KAAK,MAAM,SAAS;SACvB;AAEN,QAAM,IAAI,MAAM,2DAA2D;;AAE7E,KAAI,OAAO,WAAW,YAAY,WAAW,QAAQ,MAAM,QAAQ,OAAO,CACxE,OAAM,IAAI,MAAM,0DAA0D;CAE5E,MAAM,MAAM;AACZ,KAAI,IAAI,OAAO,KACb,QAAO;EAAE,IAAI;EAAM,QAAQ,IAAI;EAAoB;AAErD,KAAI,IAAI,OAAO,MACb,QAAO;EACL,IAAI;EACJ,OAAO,OAAO,IAAI,UAAU,WAAW,IAAI,QAAQ,OAAO,IAAI,MAAM;EACrE;AAEH,OAAM,IAAI,MAAM,uDAAqD;;;;;;;;;;;;;;;AAgBvE,eAAsB,mBACpB,YACA,YACA,YAAY,oBACW;CACvB,MAAM,aAAa,wBAAwB,WAAW;CAItD,MAAM,iBAAiB,IAAI,SAAgB,GAAG,WAC5C,iBAAiB,uBAAO,IAAI,MAAM,iCAAiC,UAAU,IAAI,CAAC,EAAE,UAAU,CAC/F;CAED,MAAM,cAAc,WAAW,KAAK,oBAAoB;EACtD;EACA,eAAe;EACf,cAAc;EACf,CAAC;CAEF,MAAM,YAAY,MAAM,QAAQ,KAAK,CAAC,aAAa,eAAe,CAAC;AAEnE,KAAI,UAAU,kBAAkB;EAE9B,MAAM,MACJ,UAAU,iBAAiB,WAAW,eACtC,UAAU,iBAAiB,QAC3B;AACF,QAAM,IAAI,MAAM,2BAA2B,MAAM;;AAGnD,QAAO,oBAAoB,UAAU,OAAO,MAAM"}

package/dist/test-runner/task-graph.d.ts

@@ -0,0 +1,38 @@
+import { t as RunReport } from "../runtime-Wi5d6Ywz.js";
+import { File, TaskEventPack, TaskResultPack } from "@vitest/runner";
+
+//#region src/test-runner/task-graph.d.ts
+/**
+ * Rebuilds a single `File` task graph from one file's flat `RunReport`.
+ *
+ * @param filepath    Absolute path to the test file.
+ * @param root        Project root (used for the file id hash).
+ * @param projectName Vitest project name (or undefined for the default project).
+ * @param pool        Pool name to stamp on the file task (our relay pool name).
+ * @param report      The page-runtime report for this file.
+ */
+declare function synthesizeFileTask(filepath: string, root: string, projectName: string | undefined, pool: string, report: RunReport): File;
+/**
+ * Flattens a File task subtree into the {@link TaskResultPack} tuples Vitest's
+ * `state.updateTasks` consumes: `[id, result, meta]`.
+ *
+ * Includes every task (file, suites, tests). Suites/files without a result
+ * report `undefined` in the result slot — Vitest tolerates that.
+ */
+declare function toTaskResultPacks(file: File): TaskResultPack[];
+/**
+ * Builds the {@link TaskEventPack} sequence reporters expect: a `suite-prepare`
+ * before a suite's children, `test-prepare`/`test-finished` per test, and a
+ * `suite-finished` after. This drives reporter progress output.
+ */
+declare function toTaskEventPacks(file: File): TaskEventPack[];
+/**
+ * Deterministic synthetic id for a file that failed before any task graph could
+ * be built (bundle/inject error). Uses the same `generateHash` Vitest uses, on
+ * the root-relative path + projectName, matching `generateFileHash` semantics so
+ * the id is stable across runs and won't collide with real file ids.
+ */
+declare function syntheticFileId(relativePath: string, projectName: string | undefined): string;
+//#endregion
+export { synthesizeFileTask, syntheticFileId, toTaskEventPacks, toTaskResultPacks };
+//# sourceMappingURL=task-graph.d.ts.map

package/dist/test-runner/task-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph.d.ts","names":[],"sources":["../../src/test-runner/task-graph.ts"],"mappings":";;;;AA6MA;;;;;;;;;AAAA,iBA5DgB,kBAAA,CACd,QAAA,UACA,IAAA,UACA,WAAA,sBACA,IAAA,UACA,MAAA,EAAQ,SAAA,GACP,IAAA;;;;;;;;iBAmCa,iBAAA,CAAkB,IAAA,EAAM,IAAA,GAAO,cAAA;;;;;;iBAmB/B,gBAAA,CAAiB,IAAA,EAAM,IAAA,GAAO,aAAA;;;;;;;iBAgC9B,eAAA,CAAgB,YAAA,UAAsB,WAAA"}