@ait-co/devtools 0.1.108 → 0.1.109

package/dist/bundle-KFs4t-wc.d.ts

@@ -0,0 +1,96 @@
+//#region src/test-runner/bundle.d.ts
+/**
+ * esbuild-based bundler for user test files.
+ *
+ * Bundles a single test file into a self-contained IIFE string that can be
+ * injected into a WebView via `Runtime.evaluate`. The bundle includes the
+ * test runtime (`runtime.ts`), which provides `describe/it/test/expect` and
+ * the `runTestModule(factory)` entry point.
+ *
+ * ## How the wiring works
+ *
+ * The bundle exposes two exports on `globalThis.__testBundle`:
+ *   - `runTestModule` — the runtime's entry function.
+ *   - `__userFactory`  — an async function whose body is the user's top-level
+ *     test registration code (describe/it/test calls).
+ *
+ * The Node-side RPC (`rpc.ts`) calls:
+ *   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
+ *
+ * `runTestModule` then installs `describe/it/test/expect` as globals, invokes
+ * the factory (which registers all tests), runs them, and returns a `RunReport`.
+ *
+ * ## Why a factory wrapper is needed
+ *
+ * Naively adding the runtime to `entryPoints` and bundling the user file would
+ * fail for two reasons:
+ *   1. `describe/it/test/expect` from the runtime are module-local in the IIFE
+ *      scope. The user's top-level `describe(...)` calls expect them as globals —
+ *      they are not globals until `runTestModule` installs them.
+ *   2. Even with globals pre-installed, the user file runs at IIFE-evaluation
+ *      time, before the RPC layer calls `runTestModule` to reset state and start
+ *      the test clock.
+ *
+ * The factory approach solves both: the user's registration code is deferred
+ * into a function that `runTestModule` calls AFTER installing the globals.
+ *
+ * ## Factory extraction algorithm
+ *
+ * The `userFactoryPlugin` reads the user file and splits lines into:
+ *   - **top-level**: `import …` and re-export lines — kept at module scope
+ *     (the only valid position for static `import` in ESM).
+ *   - **body**: all other statements — moved into the body of the exported
+ *     `__userFactory` async function.
+ *
+ * esbuild processes the re-generated module, following each static import
+ * through the normal dependency graph (including the SDK-redirect plugin).
+ *
+ * ## SDK redirect
+ *
+ * Imports of `@apps-in-toss/web-framework` (and sub-paths) are intercepted via
+ * the `sdkRedirectPlugin` and replaced with a virtual `window.__sdk` proxy that
+ * `src/in-app/auto.ts` installs at runtime. This works for both 2.x and 3.x SDK.
+ *
+ * SECRET-HANDLING: the returned bundle code is caller-managed; never log it.
+ */
+/** Options accepted by `bundleTestFile`. */
+interface BundleOptions {
+  /**
+   * Additional esbuild `external` patterns. The SDK package
+   * (`@apps-in-toss/web-framework` and `@apps-in-toss/web-framework/*`) is
+   * always handled by the SDK redirect plugin — callers may add more patterns
+   * to be left as globals.
+   */
+  extraExternals?: string[];
+  /**
+   * Global name for the IIFE output object. Defaults to `__testBundle`.
+   * The runtime entry uses this to call `__testBundle.runTestModule(__userFactory)`.
+   */
+  globalName?: string;
+}
+/**
+ * The result of bundling a test file.
+ * `code` is a self-contained IIFE string ready for `Runtime.evaluate`.
+ */
+interface BundleResult {
+  code: string;
+  warnings: string[];
+}
+/**
+ * Bundles `absPath` into a single IIFE string suitable for `Runtime.evaluate`.
+ *
+ * The IIFE installs `window.__testBundle` (or the custom `globalName`) with:
+ *   - `runTestModule` — the runtime entry (from `runtime.ts`).
+ *   - `__userFactory` — an async function wrapping the user's test registration
+ *     code so it runs AFTER `runTestModule` installs the globals.
+ *
+ * Callers (rpc.ts) invoke:
+ *   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
+ *
+ * @param absPath - Absolute path to the user test file.
+ * @param opts    - Optional bundling overrides.
+ */
+declare function bundleTestFile(absPath: string, opts?: BundleOptions): Promise<BundleResult>;
+//#endregion
+export { BundleResult as n, bundleTestFile as r, BundleOptions as t };
+//# sourceMappingURL=bundle-KFs4t-wc.d.ts.map

package/dist/bundle-KFs4t-wc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-KFs4t-wc.d.ts","names":[],"sources":["../src/test-runner/bundle.ts"],"mappings":";;AAqEA;;;;;AAmBA;;;;;AA2LA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA9MiB,aAAA;;;;;;;EAOf,cAAA;;;;;EAKA,UAAA;AAAA;;;;;UAOe,YAAA;EACf,IAAA;EACA,QAAA;AAAA;;;;;;;;;;;;;;;iBAyLoB,cAAA,CAAe,OAAA,UAAiB,IAAA,GAAO,aAAA,GAAgB,OAAA,CAAQ,YAAA"}

package/dist/mcp/cli.js

@@ -2,13 +2,14 @@
 import { i as generateTotp, n as assertRelayAuthConfigured, r as buildRelayVerifyAuth } from "../totp-WY6l0ysP.js";
 import { t as loadRelaySecretReadOnly } from "../relay-secret-store-DhzAnnj-.js";
 import { createRequire } from "node:module";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { accessSync, existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { argv } from "node:process";
 import { fileURLToPath } from "node:url";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { parseArgs } from "node:util";
+import * as fs from "node:fs/promises";
 import { glob } from "node:fs/promises";
 import * as path from "node:path";
 import { isAbsolute, join, resolve } from "node:path";
@@ -158,11 +159,53 @@ async function discoverTestFiles(patterns, cwd) {
 * esbuild-based bundler for user test files.
 *
 * Bundles a single test file into a self-contained IIFE string that can be
-* injected into a WebView via `Runtime.evaluate`. The user's SDK imports
-* (`@apps-in-toss/web-framework` and sub-paths) are intercepted via an
-* esbuild plugin that redirects them to `window.__sdk`, which the in-app
-* debug gate (`src/in-app/auto.ts`) installs as a namespace mirror of the
-* SDK exports (works for both 2.x and 3.x SDK).
+* injected into a WebView via `Runtime.evaluate`. The bundle includes the
+* test runtime (`runtime.ts`), which provides `describe/it/test/expect` and
+* the `runTestModule(factory)` entry point.
+*
+* ## How the wiring works
+*
+* The bundle exposes two exports on `globalThis.__testBundle`:
+*   - `runTestModule` — the runtime's entry function.
+*   - `__userFactory`  — an async function whose body is the user's top-level
+*     test registration code (describe/it/test calls).
+*
+* The Node-side RPC (`rpc.ts`) calls:
+*   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
+*
+* `runTestModule` then installs `describe/it/test/expect` as globals, invokes
+* the factory (which registers all tests), runs them, and returns a `RunReport`.
+*
+* ## Why a factory wrapper is needed
+*
+* Naively adding the runtime to `entryPoints` and bundling the user file would
+* fail for two reasons:
+*   1. `describe/it/test/expect` from the runtime are module-local in the IIFE
+*      scope. The user's top-level `describe(...)` calls expect them as globals —
+*      they are not globals until `runTestModule` installs them.
+*   2. Even with globals pre-installed, the user file runs at IIFE-evaluation
+*      time, before the RPC layer calls `runTestModule` to reset state and start
+*      the test clock.
+*
+* The factory approach solves both: the user's registration code is deferred
+* into a function that `runTestModule` calls AFTER installing the globals.
+*
+* ## Factory extraction algorithm
+*
+* The `userFactoryPlugin` reads the user file and splits lines into:
+*   - **top-level**: `import …` and re-export lines — kept at module scope
+*     (the only valid position for static `import` in ESM).
+*   - **body**: all other statements — moved into the body of the exported
+*     `__userFactory` async function.
+*
+* esbuild processes the re-generated module, following each static import
+* through the normal dependency graph (including the SDK-redirect plugin).
+*
+* ## SDK redirect
+*
+* Imports of `@apps-in-toss/web-framework` (and sub-paths) are intercepted via
+* the `sdkRedirectPlugin` and replaced with a virtual `window.__sdk` proxy that
+* `src/in-app/auto.ts` installs at runtime. This works for both 2.x and 3.x SDK.
 *
 * SECRET-HANDLING: the returned bundle code is caller-managed; never log it.
 */
@@ -212,10 +255,90 @@ module.exports = __proxy;
 	};
 }
 /**
+* esbuild plugin that transforms the user test file into a module that exports
+* an async `__userFactory` function. The factory defers the user's top-level
+* test registration code (describe/it/test calls) so it only runs when
+* `runTestModule(__userFactory)` explicitly invokes it — AFTER the runtime has
+* installed describe/it/test/expect as globals.
+*
+* Algorithm:
+*   - Lines matching import declarations or re-export statements are kept at
+*     module top-level (the only valid ESM position for static `import`).
+*   - All other lines (describe/it/test calls, local declarations, etc.) are
+*     moved into the body of the exported async factory function.
+*
+* This preserves SDK import resolution (the sdk-redirect plugin processes
+* top-level imports normally) while deferring test registration to the factory.
+*/
+function userFactoryPlugin(absPath) {
+	const NAMESPACE = "user-test-factory";
+	return {
+		name: "user-test-factory",
+		setup(build) {
+			build.onResolve({ filter: /^user-test-factory$/ }, () => ({
+				path: absPath,
+				namespace: NAMESPACE
+			}));
+			build.onLoad({
+				filter: /.*/,
+				namespace: NAMESPACE
+			}, async (args) => {
+				const lines = (await fs.readFile(args.path, "utf8")).split("\n");
+				const topLevelLines = [];
+				const bodyLines = [];
+				const EXPORT_DECLARATION_RE = /^(export\s+)(default\s+|async\s+function\s+|function\s+|class\s+|const\s+|let\s+|var\s+)/;
+				for (const line of lines) {
+					const trimmed = line.trimStart();
+					const indent = line.slice(0, line.length - trimmed.length);
+					if (trimmed.startsWith("import ") || trimmed.startsWith("import{") || trimmed.startsWith("import'") || trimmed.startsWith("import\"")) topLevelLines.push(line);
+					else if (trimmed.startsWith("export ")) if (trimmed.match(EXPORT_DECLARATION_RE)) bodyLines.push(indent + trimmed.slice(7));
+					else topLevelLines.push(line);
+					else bodyLines.push(line);
+				}
+				return {
+					contents: [
+						...topLevelLines,
+						"",
+						"// biome-ignore lint: generated factory wrapper",
+						"export default async function __userFactory(): Promise<void> {",
+						...bodyLines.map((l) => `  ${l}`),
+						"}"
+					].join("\n"),
+					loader: "ts",
+					resolveDir: path.dirname(absPath)
+				};
+			});
+		}
+	};
+}
+/**
+* Returns the absolute path to the co-located runtime module.
+*
+* In the source tree (running via tsx / ts-node) the file is `runtime.ts`.
+* After `tsdown` compiles to `dist/test-runner/`, it becomes `runtime.js`.
+* We try both extensions to support both environments.
+*/
+function getRuntimePath() {
+	const dir = path.dirname(fileURLToPath(import.meta.url));
+	for (const ext of [".ts", ".js"]) {
+		const candidate = path.join(dir, `runtime${ext}`);
+		try {
+			accessSync(candidate);
+			return candidate;
+		} catch {}
+	}
+	return path.join(dir, "runtime.js");
+}
+/**
 * Bundles `absPath` into a single IIFE string suitable for `Runtime.evaluate`.
 *
-* The IIFE installs `window.__testBundle` (or the custom `globalName`) with
-* `runTestModule` as the callable entry point.
+* The IIFE installs `window.__testBundle` (or the custom `globalName`) with:
+*   - `runTestModule` — the runtime entry (from `runtime.ts`).
+*   - `__userFactory` — an async function wrapping the user's test registration
+*     code so it runs AFTER `runTestModule` installs the globals.
+*
+* Callers (rpc.ts) invoke:
+*   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`
 *
 * @param absPath - Absolute path to the user test file.
 * @param opts    - Optional bundling overrides.
@@ -223,17 +346,29 @@ module.exports = __proxy;
 async function bundleTestFile(absPath, opts) {
 	const globalName = opts?.globalName ?? "__testBundle";
 	const extraExternals = opts?.extraExternals ?? [];
-	const result = await (await import("esbuild")).build({
-		entryPoints: [absPath],
+	const esbuild = await import("esbuild");
+	const runtimePath = getRuntimePath();
+	const wrapperContent = [
+		`import { runTestModule } from ${JSON.stringify(runtimePath)};`,
+		`import __userFactory from "user-test-factory";`,
+		`export { runTestModule, __userFactory };`
+	].join("\n");
+	const result = await esbuild.build({
+		stdin: {
+			contents: wrapperContent,
+			loader: "ts",
+			resolveDir: path.dirname(absPath)
+		},
 		bundle: true,
 		format: "iife",
 		globalName,
 		platform: "browser",
 		target: "es2022",
 		write: false,
-		plugins: [sdkRedirectPlugin()],
+		plugins: [userFactoryPlugin(absPath), sdkRedirectPlugin()],
 		external: extraExternals,
-		treeShaking: true
+		treeShaking: true,
+		footer: { js: `globalThis[${JSON.stringify(globalName)}] = ${globalName};` }
 	});
 	const warnings = result.warnings.map((w) => `${path.relative(process.cwd(), w.location?.file ?? "")}:${w.location?.line ?? "?"}: ${w.text}`);
 	const outputFile = result.outputFiles?.[0];
@@ -260,7 +395,7 @@ const DEFAULT_TIMEOUT_MS = 3e4;
 * 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') {    return JSON.stringify({ok:false,error:'bundle-missing-export: __testBundle.runTestModule is not a function'});  }  try {    const report = await globalThis.__testBundle.runTestModule();    return JSON.stringify({ok:true,value:report});  } catch(e) {    return JSON.stringify({ok:false,error:'test-run: ' + String(e && e.message || e)});  }})()`;
+	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`
@@ -393,14 +528,15 @@ async function runTestFilesOverRelay(connection, files, opts) {
 //#endregion
 //#region src/test-runner/cli.ts
 /**
-* `devtools-test` CLI — MVP skeleton.
-*
-* Parses argv, prints usage, and delegates to `runTestFilesOverRelay` when
-* a live CDP connection is provided. The relay connection wiring
-* (attach → run → detach) is tracked in issue #645 / #646.
+* `devtools-test` CLI.
 *
-* MVP contract: `--help` works, `runWithConnection` is a testable pure
-* function, and the binary entry exists in package.json.
+* Shares test-file discovery with the `run_tests` MCP tool (`discoverTestFiles`)
+* and exposes `runWithConnection` — the pure run core that bundles, injects, and
+* collects each file over a CDP connection. Today the run path that has a live
+* connection is the `run_tests` MCP tool (it runs these files against the
+* daemon's attached page); the CLI's own standalone relay attach (resolve CDP
+* URL → attach → run → close) is not wired yet, so `main()` resolves the matched
+* files and points the operator at the MCP tool.
 *
 * NOTE: no shebang in this source file — the tsdown entry's `banner` option
 * injects `#!/usr/bin/env node` into the compiled output (same pattern as
@@ -421,12 +557,10 @@ DESCRIPTION
   window.__sdk), injects the bundle into the attached WebView via
   Runtime.evaluate, and returns a RunReport.
 
-  A live CDP relay connection must be active before running tests.
-  Use \`/ait debug\` (devtools-mcp) to attach and then call this CLI from
-  the same process context.
-
-  Full Vitest pool integration and the \`run_tests\` MCP tool are tracked in
-  issues #645 and #646 respectively. This MVP provides the transport layer.
+  A live CDP relay connection must be active before running tests. Use the
+  \`run_tests\` MCP tool (via \`devtools-mcp\` / \`/ait debug\`) to run these files
+  against an attached page — the CLI's own standalone relay attach is not wired
+  yet (it currently resolves the matched files and defers to that tool).
 
 EXAMPLE
   devtools-test 'src/**/*.phone.test.ts' --timeout 60000
@@ -434,11 +568,12 @@ EXAMPLE
 `.trimStart();
 /**
 * Runs `files` over `connection` and returns the aggregate report.
-* This pure function is the testable core of the CLI; it is separate from
-* `main()` so tests can call it without spawning a subprocess.
+* This pure function is the testable core of the CLI (and is what the
+* `run_tests` MCP tool calls against the daemon's attached connection); it is
+* separate from `main()` so tests can call it without spawning a subprocess.
 *
-* TODO (#645): add real relay attach/detach lifecycle here (connect via
-* Chii relay URL, call enableDomains, run, then close).
+* A standalone CLI relay attach/detach lifecycle (connect via Chii relay URL,
+* `enableDomains`, run, then close) is not wired into `main()` yet.
 */
 async function runWithConnection(connection, files, opts) {
 	const report = await runTestFilesOverRelay(connection, files, opts);
@@ -451,8 +586,10 @@ async function runWithConnection(connection, files, opts) {
 /**
 * CLI entry point.
 *
-* MVP: prints usage and a "relay attach required" notice. Real relay wiring
-* (resolve CDP URL, attach, run, close) is tracked in issues #645 / #646.
+* Resolves the matched test files and prints a "relay attach required" notice:
+* the CLI's own standalone relay attach (resolve CDP URL, attach, run, close) is
+* not wired yet, so today these files run via the `run_tests` MCP tool against
+* the daemon's attached page.
 */
 async function main$1(argv = process.argv.slice(2)) {
 	let parsed;
@@ -483,7 +620,7 @@ async function main$1(argv = process.argv.slice(2)) {
 		process.exitCode = 1;
 		return;
 	}
-	process.stderr.write(`devtools-test: matched ${files.length} test file(s), but direct CLI relay attach is not yet wired.\n  Use the devtools-mcp server (\`devtools-mcp\`) to start a debug session,\n  then the \`run_tests\` MCP tool to run these files against the attached page.\n  Direct CLI relay wiring is tracked in issue #645.\n`);
+	process.stderr.write(`devtools-test: matched ${files.length} test file(s), but direct CLI relay attach is not yet wired.\n  Use the devtools-mcp server (\`devtools-mcp\`) to start a debug session,\n  then the \`run_tests\` MCP tool to run these files against the attached page.\n`);
 	process.exitCode = 1;
 }
 if (import.meta.url === new URL(process.argv[1], "file://").href) main$1().catch((e) => {
@@ -4412,7 +4549,7 @@ const DEBUG_TOOL_DEFINITIONS = [
 	},
 	{
 		name: "run_tests",
-		description: "Runs mini-app test files on the attached page over CDP (Runtime.evaluate). Each matched file is bundled with esbuild (SDK imports redirected to the live mock/SDK), injected into the attached WebView, and executed; returns per-file results plus flattened totals (passed/failed/skipped/total). Requires an attached page — call list_pages first to confirm one is attached. Files run SEQUENTIALLY (single-attach model: the relay/local target serves one page), and one run_tests call runs at a time (a concurrent call is rejected). Test verification (assert/snapshot) is delegated to the in-page Vitest runtime; this tool is the transport + report. The per-file results array is the progress record — on partial failure you see exactly which files passed/failed/timed-out. In a relay-live session this is a state-mutating injection and is blocked unless confirm=true (ignored in mock/local/relay-dev/relay-mobile). debug-mode only — dev-mode (--mode=dev) has no CDP. Tier C (both mock/local and relay). Use the test-runner CLI (devtools-test) for the same run outside MCP.",
+		description: "Runs mini-app test files on the attached page over CDP (Runtime.evaluate). Each matched file is bundled with esbuild (SDK imports redirected to the live mock/SDK), injected into the attached WebView, and executed; returns per-file results plus flattened totals (passed/failed/skipped/total). Requires an attached page — call list_pages first to confirm one is attached. Files run SEQUENTIALLY (single-attach model: the relay/local target serves one page), and one run_tests call runs at a time (a concurrent call is rejected). Test verification (assert/snapshot) is delegated to the in-page Vitest runtime; this tool is the transport + report. The per-file results array is the progress record — on partial failure you see exactly which files passed/failed/timed-out. In a relay-live session this is a state-mutating injection and is blocked unless confirm=true (confirm is ignored in every non-live session: mock/local, relay-dev, relay-mobile). debug-mode only — dev-mode (--mode=dev) has no CDP. Tier C (both mock/local and relay). The devtools-test CLI shares this run core and file discovery, but its standalone relay attach is not wired yet — run via this tool for now.",
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -4431,7 +4568,7 @@ const DEBUG_TOOL_DEFINITIONS = [
 				},
 				confirm: {
 					type: "boolean",
-					description: "Required (true) to run in a relay-live session — test injection mutates page state. Ignored in mock/local/relay-dev/relay-mobile sessions."
+					description: "Required (true) to run in a relay-live session — test injection mutates page state. Ignored in every non-live session (mock/local, relay-dev, relay-mobile)."
 				}
 			},
 			required: ["files"]
@@ -5259,7 +5396,7 @@ async function readMcpSdkVersion() {
 * some test environments that skip the build step).
 */
 function readDevtoolsVersion() {
-	return "0.1.108";
+	return "0.1.109";
 }
 /**
 * Derives the next recommended action from a completed diagnostics snapshot.
@@ -5507,9 +5644,11 @@ async function renderQr(text) {
 	return `${lines.join("\n")}\n`;
 }
 /**
-* Renders the attach banner (relay URL + ASCII QR) as a string.
+* Renders the attach banner (relay URL + unicode half-block QR) as a string.
 *
-* The QR encodes the base `wssUrl` only. When `totpEnabled` is true, a note
+* The QR is produced by `renderQr` (a half-block matrix, not the
+* `qrcode-terminal` ASCII art used by the unplugin banner) and encodes the
+* base `wssUrl` only. When `totpEnabled` is true, a note
 * is added that attach URLs generated by `build_attach_url` will include a
 * live TOTP code (`at=`) appended at call time.
 *
@@ -5809,6 +5948,12 @@ let runTestsInFlight = false;
 * to resolve before the relay had observed the first inbound CDP message from
 * the phone.
 *
+* Timeout note: callers (e.g. the `build_attach_url` path) always pass an
+* explicit `timeoutMs`, sourced from the factory's `waitForAttachTimeoutMs`
+* (default 60 000). That value is forwarded to `waitForFirstTarget`, so it
+* overrides that method's own 90 000 signature default — the effective
+* wait on the tool path is 60 s, not 90 s.
+*
 * @param connection - The CDP connection (production or fake).
 * @param filterFn   - Resolves when this predicate is satisfied.
 * @param timeoutMs  - Maximum wait time in ms.
@@ -5861,7 +6006,7 @@ function createDebugServer(deps) {
 	const collector = collectorDep ?? new InMemoryDiagnosticsCollector();
 	const server = new Server({
 		name: "ait-debug",
-		version: "0.1.108"
+		version: "0.1.109"
 	}, { capabilities: { tools: { listChanged: true } } });
 	server.setRequestHandler(ListToolsRequestSchema, () => {
 		const conn = router.active;
@@ -6495,6 +6640,7 @@ function toRunTestsResult(report) {
 			error: f.result.error
 		} : {
 			file: f.file,
+			duration: f.result.duration,
 			passed: f.result.passed,
 			failed: f.result.failed,
 			skipped: f.result.skipped,
@@ -8081,7 +8227,7 @@ function createDevServer(deps = {}) {
 	const aitSource = deps.aitSource ?? new HttpAitSource({ stateEndpoint });
 	const server = new Server({
 		name: "ait-devtools",
-		version: "0.1.108"
+		version: "0.1.109"
 	}, { capabilities: { tools: {} } });
 	server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: DEV_TOOL_DEFINITIONS.map((tool) => ({ ...tool })) }));
 	server.setRequestHandler(CallToolRequestSchema, async (request) => {