@ait-co/devtools 0.1.143 → 0.2.0

package/dist/test-runner/report.js

@@ -1,198 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-//#region src/test-runner/report.ts
-/**
-* Runner-agnostic report serialisation for env3 test runs (devtools#696).
-*
-* Both env3 execution paths — the Vitest custom pool (`pool.ts`) and the
-* standalone `devtools-test` CLI (`cli.ts`) — call the same core
-* `runTestFilesOverRelay` and so produce the same {@link RelayRunReport}. This
-* module is the single, runner-neutral place that turns that in-memory report
-* into a stable on-disk artifact so a 2.x run and a 3.0 run can be diffed
-* cell-by-cell after the fact.
-*
-* The serialised schema is deliberately MINIMAL and secret-free:
-*
-*   - file paths are stored RELATIVE to `projectRoot` (no absolute `/Users/...`
-*     leakage — see {@link RunnerAgnosticReport.files});
-*   - the cell metadata (sdkLine/platform) is baked INTO the body, not only the
-*     filename, so a moved artifact never loses its provenance;
-*   - NO relay wss / scheme / TOTP / relayUrl fields exist in the schema at all
-*     (enforced by the type + this comment) — error strings are the matcher
-*     message only, inherited from rpc.ts which already strips expression/value.
-*
-* react-free — depends only on the type-level `RelayRunReport` and `node:fs` /
-* `node:path`. Safe to bundle without pulling the chii/cloudflared graph.
-*/
-/**
-* Converts an absolute (or already-relative) file path to a projectRoot-relative
-* one. `path.relative` returns `''` when the paths are equal — guard that to the
-* basename so the field is never empty.
-*
-* SECRET-HANDLING: this is the single choke point that strips absolute project
-* paths from the artifact.
-*/
-function relativise(projectRoot, file) {
-	const rel = path.relative(projectRoot, file);
-	if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel)) return path.basename(file);
-	return rel;
-}
-/**
-* Serialises a {@link RelayRunReport} into the runner-agnostic, secret-free
-* on-disk shape. Pure — no IO; testable with a plain report + meta.
-*
-* @param report - The core relay run report.
-* @param meta   - Cell axes + projectRoot (projectRoot is consumed, not stored).
-*/
-function serializeRelayReport(report, meta) {
-	return {
-		cell: {
-			sdkLine: meta.sdkLine,
-			platform: meta.platform
-		},
-		startedAt: report.startedAt,
-		duration: report.duration,
-		totals: report.totals,
-		...report.preflight ? { preflight: report.preflight } : {},
-		files: report.files.map((f) => {
-			const file = relativise(meta.projectRoot, f.file);
-			const modeField = f.mode === "manual" || f.mode === "stubbed" ? { mode: f.mode } : {};
-			if ("error" in f.result) return {
-				file,
-				error: f.result.error,
-				...modeField
-			};
-			return {
-				file,
-				duration: f.result.duration,
-				passed: f.result.passed,
-				failed: f.result.failed,
-				skipped: f.result.skipped,
-				tests: f.result.tests,
-				...modeField
-			};
-		})
-	};
-}
-/**
-* Writes the serialised report to `<dir>/<sdkLine>.<platform>.json`, creating
-* `dir` if needed. Returns the absolute path(s) written.
-*
-* The cell-suffixed filename keeps 2.x and 3.0 (and per-platform) runs as
-* distinct artifacts in the same directory; the same cell metadata is also baked
-* into the body so a renamed/moved file still carries its provenance.
-*
-* Manual-run provenance (devtools#741): when `report.files` contains ANY
-* `mode: 'manual'` entry (i.e. this run included `--manual-blocking` files),
-* the manual-tagged files are written to a SEPARATE
-* `<dir>/<sdkLine>.<platform>.manual.json` artifact instead of the standard
-* one — the standard `<sdkLine>.<platform>.json` filename is reserved for the
-* regular (unattended) files only, so a manual run's presence never mutates
-* what the unattended-baseline filename means.
-*
-* Stub-blocking provenance (devtools#740, DT-2): `mode: 'stubbed'` files are
-* written to a THIRD, separate `<dir>/<sdkLine>.<platform>.stubbed.json`
-* artifact — never merged into the standard file (it is unattended, like the
-* standard file, so a naive filename split could conflate the two) and never
-* merged into `.manual.json` (it did NOT have a human present). Its body is
-* ALSO stamped `cell.bridgeStub: true` — the mandatory HYBRID-cell provenance
-* from the issue: a stubbed result must never be silently mixed into the
-* real-device baseline report.
-*
-* If ALL files in the run are regular, only the standard artifact is written
-* (today's behavior, unchanged). Any combination of the three modes present
-* in a single run writes ONLY the corresponding artifacts — each is additive,
-* never replacing another.
-*
-* SECRET-HANDLING: the written body contains no relay/secret fields (the schema
-* has none). `dir`/`projectRoot` are local filesystem paths, never logged here.
-*
-* @param report - The core relay run report.
-* @param dir    - Output directory (created recursively if missing).
-* @param meta   - Cell axes + projectRoot.
-* @returns The absolute path(s) written, in order: standard first (if any
-*   regular files ran), then manual (if any manual files ran), then stubbed
-*   (if any stubbed files ran). At least one path is always returned when
-*   `report.files` is non-empty.
-*/
-async function writeReportArtifact(report, dir, meta) {
-	const serialised = serializeRelayReport(report, meta);
-	await mkdir(dir, { recursive: true });
-	const regularFiles = serialised.files.filter((f) => f.mode === void 0);
-	const manualFiles = serialised.files.filter((f) => f.mode === "manual");
-	const stubbedFiles = serialised.files.filter((f) => f.mode === "stubbed");
-	const written = [];
-	if (regularFiles.length > 0 || serialised.files.length === 0) {
-		const outFile = path.join(dir, `${meta.sdkLine}.${meta.platform}.json`);
-		await writeFile(outFile, `${JSON.stringify({
-			...serialised,
-			files: regularFiles
-		}, null, 2)}\n`, "utf8");
-		written.push(outFile);
-	}
-	if (manualFiles.length > 0) {
-		const manualOutFile = path.join(dir, `${meta.sdkLine}.${meta.platform}.manual.json`);
-		await writeFile(manualOutFile, `${JSON.stringify({
-			...serialised,
-			files: manualFiles
-		}, null, 2)}\n`, "utf8");
-		written.push(manualOutFile);
-	}
-	if (stubbedFiles.length > 0) {
-		const stubbedOutFile = path.join(dir, `${meta.sdkLine}.${meta.platform}.stubbed.json`);
-		await writeFile(stubbedOutFile, `${JSON.stringify({
-			...serialised,
-			cell: {
-				...serialised.cell,
-				bridgeStub: true
-			},
-			files: stubbedFiles
-		}, null, 2)}\n`, "utf8");
-		written.push(stubbedOutFile);
-	}
-	return written;
-}
-/**
-* Writes harvested `__AIT_CAPTURE__` lines to per-category files under `dir`,
-* named `<category>.<sdkLine>.<platform>.json` — the SAME convention
-* sdk-example's env1 `flushCapture` uses on the filesystem, so env1 and env3
-* capture artifacts line up for diffing.
-*
-* Each line's `json` payload is an opaque JSON array of capture records. Lines
-* sharing a category are concatenated into one array, in harvest order.
-*
-* SECRET-HANDLING: only allowlist-prefixed capture lines reach here (the parser
-* dropped wss/scheme noise); the `json` payload is written verbatim but is a
-* capture record array, not a relay/secret.
-*
-* @param captures - Parsed capture lines (from `RelayRunReport.captures`).
-* @param dir      - Output directory (created recursively if missing).
-* @param cell     - Cell axes for the filename suffix.
-* @returns The absolute paths written (one per category), in category order.
-*/
-async function writeCaptureArtifacts(captures, dir, cell) {
-	if (captures.length === 0) return [];
-	const byCategory = /* @__PURE__ */ new Map();
-	for (const { category, json } of captures) {
-		let merged = byCategory.get(category);
-		if (!merged) {
-			merged = [];
-			byCategory.set(category, merged);
-		}
-		const parsed = JSON.parse(json);
-		if (Array.isArray(parsed)) merged.push(...parsed);
-		else merged.push(parsed);
-	}
-	await mkdir(dir, { recursive: true });
-	const written = [];
-	for (const [category, records] of byCategory) {
-		const outFile = path.join(dir, `${category}.${cell.sdkLine}.${cell.platform}.json`);
-		await writeFile(outFile, `${JSON.stringify(records, null, 2)}\n`, "utf8");
-		written.push(outFile);
-	}
-	return written;
-}
-//#endregion
-export { serializeRelayReport, writeCaptureArtifacts, writeReportArtifact };
-
-//# sourceMappingURL=report.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"report.js","names":[],"sources":["../../src/test-runner/report.ts"],"sourcesContent":["/**\n * Runner-agnostic report serialisation for env3 test runs (devtools#696).\n *\n * Both env3 execution paths — the Vitest custom pool (`pool.ts`) and the\n * standalone `devtools-test` CLI (`cli.ts`) — call the same core\n * `runTestFilesOverRelay` and so produce the same {@link RelayRunReport}. This\n * module is the single, runner-neutral place that turns that in-memory report\n * into a stable on-disk artifact so a 2.x run and a 3.0 run can be diffed\n * cell-by-cell after the fact.\n *\n * The serialised schema is deliberately MINIMAL and secret-free:\n *\n *   - file paths are stored RELATIVE to `projectRoot` (no absolute `/Users/...`\n *     leakage — see {@link RunnerAgnosticReport.files});\n *   - the cell metadata (sdkLine/platform) is baked INTO the body, not only the\n *     filename, so a moved artifact never loses its provenance;\n *   - NO relay wss / scheme / TOTP / relayUrl fields exist in the schema at all\n *     (enforced by the type + this comment) — error strings are the matcher\n *     message only, inherited from rpc.ts which already strips expression/value.\n *\n * react-free — depends only on the type-level `RelayRunReport` and `node:fs` /\n * `node:path`. Safe to bundle without pulling the chii/cloudflared graph.\n */\n\nimport { mkdir, writeFile } from 'node:fs/promises';\nimport path from 'node:path';\nimport type { AitCaptureLine } from './capture.js';\nimport type { RelayRunReport } from './relay-worker.js';\nimport type { TestResult } from './runtime.js';\n\n/** The cell axes a report is stamped with — the test-matrix coordinates. */\nexport interface ReportCellMeta {\n  /** SDK line under test (e.g. `'2.x'` / `'3.x'`). */\n  sdkLine: string;\n  /** Platform under test (e.g. `'ios'` / `'android'` / `'mock'`). */\n  platform: string;\n  /**\n   * Project root the run was launched from. Used ONLY to relativise file paths\n   * out of the serialised report — never stored in the output. SECRET-HANDLING:\n   * absolute project paths must not leak into artifacts.\n   */\n  projectRoot: string;\n}\n\n/** Per-file slice of a {@link RunnerAgnosticReport}. */\nexport interface RunnerAgnosticFileReport {\n  /**\n   * Test file path, RELATIVE to `projectRoot`. Never absolute — `path.relative`\n   * strips the machine-specific prefix so the artifact is portable and leaks no\n   * local filesystem layout.\n   */\n  file: string;\n  /** Whole-file bundle/inject error (matcher message only), when the file failed. */\n  error?: string;\n  /** In-page run duration (ms) for this file, when it ran. */\n  duration?: number;\n  passed?: number;\n  failed?: number;\n  skipped?: number;\n  /** Per-test results, when the file ran. Error strings are matcher messages only. */\n  tests?: TestResult[];\n  /**\n   * Present only when this file ran under `--manual-blocking` or\n   * `--stub-blocking`. Absent (never `false`) for unattended files:\n   * absence-means-unattended is the contract, mirroring `FileResult.mode` in\n   * relay-worker.ts.\n   *\n   *   - `'manual'`  — devtools#741, human-attended, real native envelopes.\n   *   - `'stubbed'` — devtools#740 (DT-2), unattended, blocking-UI calls\n   *     answered from fixtures. A manual/stubbed-stamped record must never be\n   *     diffed against an unattended (or each other's) baseline as if\n   *     equivalent.\n   */\n  mode?: 'manual' | 'stubbed';\n}\n\n/**\n * The runner-neutral, secret-free report written to disk. There are\n * intentionally NO wss/scheme/TOTP/relayUrl fields on this type — the absence is\n * load-bearing (SECRET-HANDLING) and must not be \"completed\" by a future edit.\n */\nexport interface RunnerAgnosticReport {\n  /**\n   * Cell axes this run belongs to — baked into the body for portability.\n   * `bridgeStub` is present + `true` ONLY on the artifact written for\n   * stub-blocking files (devtools#740, DT-2) — see `writeReportArtifact`'s\n   * doc for why this is a SEPARATE `.stubbed.json` artifact rather than a\n   * flag inside the standard/`.manual.json` report. Absent (never `false`)\n   * on every other artifact — this is the mandatory HYBRID-cell provenance\n   * stamp the issue calls for: a stubbed run must never be silently mixed\n   * into the real-device baseline report.\n   */\n  cell: { sdkLine: string; platform: string; bridgeStub?: true };\n  /** ISO timestamp of when the run started (from the core report). */\n  startedAt: string;\n  /** Total wall-clock ms (bundling + sequential injection). */\n  duration: number;\n  /** Flattened totals across all files. */\n  totals: RelayRunReport['totals'];\n  /** Per-file results with projectRoot-relative paths. */\n  files: RunnerAgnosticFileReport[];\n  /**\n   * Permission-state preflight result (devtools#739), mirrored verbatim from\n   * `RelayRunReport.preflight` — see that field's docblock. Absent when the\n   * preflight did not complete (non-fatal; the run still succeeds). No\n   * secrets — permission-state strings only.\n   */\n  preflight?: { permissions: Record<string, string> };\n}\n\n/**\n * Converts an absolute (or already-relative) file path to a projectRoot-relative\n * one. `path.relative` returns `''` when the paths are equal — guard that to the\n * basename so the field is never empty.\n *\n * SECRET-HANDLING: this is the single choke point that strips absolute project\n * paths from the artifact.\n */\nfunction relativise(projectRoot: string, file: string): string {\n  const rel = path.relative(projectRoot, file);\n  if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) {\n    // Outside the project root (or equal) — fall back to the basename rather\n    // than emitting an absolute or `../../..` traversal path.\n    return path.basename(file);\n  }\n  return rel;\n}\n\n/**\n * Serialises a {@link RelayRunReport} into the runner-agnostic, secret-free\n * on-disk shape. Pure — no IO; testable with a plain report + meta.\n *\n * @param report - The core relay run report.\n * @param meta   - Cell axes + projectRoot (projectRoot is consumed, not stored).\n */\nexport function serializeRelayReport(\n  report: RelayRunReport,\n  meta: ReportCellMeta,\n): RunnerAgnosticReport {\n  return {\n    cell: { sdkLine: meta.sdkLine, platform: meta.platform },\n    startedAt: report.startedAt,\n    duration: report.duration,\n    totals: report.totals,\n    ...(report.preflight ? { preflight: report.preflight } : {}),\n    files: report.files.map((f): RunnerAgnosticFileReport => {\n      const file = relativise(meta.projectRoot, f.file);\n      const modeField =\n        f.mode === 'manual' || f.mode === 'stubbed' ? ({ mode: f.mode } as const) : {};\n      if ('error' in f.result) {\n        // Matcher/inject error message only — rpc.ts already stripped the\n        // expression/value upstream.\n        return { file, error: f.result.error, ...modeField };\n      }\n      return {\n        file,\n        duration: f.result.duration,\n        passed: f.result.passed,\n        failed: f.result.failed,\n        skipped: f.result.skipped,\n        tests: f.result.tests,\n        ...modeField,\n      };\n    }),\n  };\n}\n\n/**\n * Writes the serialised report to `<dir>/<sdkLine>.<platform>.json`, creating\n * `dir` if needed. Returns the absolute path(s) written.\n *\n * The cell-suffixed filename keeps 2.x and 3.0 (and per-platform) runs as\n * distinct artifacts in the same directory; the same cell metadata is also baked\n * into the body so a renamed/moved file still carries its provenance.\n *\n * Manual-run provenance (devtools#741): when `report.files` contains ANY\n * `mode: 'manual'` entry (i.e. this run included `--manual-blocking` files),\n * the manual-tagged files are written to a SEPARATE\n * `<dir>/<sdkLine>.<platform>.manual.json` artifact instead of the standard\n * one — the standard `<sdkLine>.<platform>.json` filename is reserved for the\n * regular (unattended) files only, so a manual run's presence never mutates\n * what the unattended-baseline filename means.\n *\n * Stub-blocking provenance (devtools#740, DT-2): `mode: 'stubbed'` files are\n * written to a THIRD, separate `<dir>/<sdkLine>.<platform>.stubbed.json`\n * artifact — never merged into the standard file (it is unattended, like the\n * standard file, so a naive filename split could conflate the two) and never\n * merged into `.manual.json` (it did NOT have a human present). Its body is\n * ALSO stamped `cell.bridgeStub: true` — the mandatory HYBRID-cell provenance\n * from the issue: a stubbed result must never be silently mixed into the\n * real-device baseline report.\n *\n * If ALL files in the run are regular, only the standard artifact is written\n * (today's behavior, unchanged). Any combination of the three modes present\n * in a single run writes ONLY the corresponding artifacts — each is additive,\n * never replacing another.\n *\n * SECRET-HANDLING: the written body contains no relay/secret fields (the schema\n * has none). `dir`/`projectRoot` are local filesystem paths, never logged here.\n *\n * @param report - The core relay run report.\n * @param dir    - Output directory (created recursively if missing).\n * @param meta   - Cell axes + projectRoot.\n * @returns The absolute path(s) written, in order: standard first (if any\n *   regular files ran), then manual (if any manual files ran), then stubbed\n *   (if any stubbed files ran). At least one path is always returned when\n *   `report.files` is non-empty.\n */\nexport async function writeReportArtifact(\n  report: RelayRunReport,\n  dir: string,\n  meta: ReportCellMeta,\n): Promise<string[]> {\n  const serialised = serializeRelayReport(report, meta);\n  await mkdir(dir, { recursive: true });\n\n  const regularFiles = serialised.files.filter((f) => f.mode === undefined);\n  const manualFiles = serialised.files.filter((f) => f.mode === 'manual');\n  const stubbedFiles = serialised.files.filter((f) => f.mode === 'stubbed');\n\n  const written: string[] = [];\n\n  // Standard artifact: written whenever there are regular files, OR when the\n  // whole run is empty (preserves the pre-#741 \"always write one file\"\n  // behavior for a run with zero files, e.g. an empty glob match).\n  if (regularFiles.length > 0 || serialised.files.length === 0) {\n    const outFile = path.join(dir, `${meta.sdkLine}.${meta.platform}.json`);\n    await writeFile(\n      outFile,\n      `${JSON.stringify({ ...serialised, files: regularFiles }, null, 2)}\\n`,\n      'utf8',\n    );\n    written.push(outFile);\n  }\n\n  if (manualFiles.length > 0) {\n    const manualOutFile = path.join(dir, `${meta.sdkLine}.${meta.platform}.manual.json`);\n    await writeFile(\n      manualOutFile,\n      `${JSON.stringify({ ...serialised, files: manualFiles }, null, 2)}\\n`,\n      'utf8',\n    );\n    written.push(manualOutFile);\n  }\n\n  if (stubbedFiles.length > 0) {\n    const stubbedOutFile = path.join(dir, `${meta.sdkLine}.${meta.platform}.stubbed.json`);\n    await writeFile(\n      stubbedOutFile,\n      `${JSON.stringify(\n        {\n          ...serialised,\n          cell: { ...serialised.cell, bridgeStub: true as const },\n          files: stubbedFiles,\n        },\n        null,\n        2,\n      )}\\n`,\n      'utf8',\n    );\n    written.push(stubbedOutFile);\n  }\n\n  return written;\n}\n\n/**\n * Writes harvested `__AIT_CAPTURE__` lines to per-category files under `dir`,\n * named `<category>.<sdkLine>.<platform>.json` — the SAME convention\n * sdk-example's env1 `flushCapture` uses on the filesystem, so env1 and env3\n * capture artifacts line up for diffing.\n *\n * Each line's `json` payload is an opaque JSON array of capture records. Lines\n * sharing a category are concatenated into one array, in harvest order.\n *\n * SECRET-HANDLING: only allowlist-prefixed capture lines reach here (the parser\n * dropped wss/scheme noise); the `json` payload is written verbatim but is a\n * capture record array, not a relay/secret.\n *\n * @param captures - Parsed capture lines (from `RelayRunReport.captures`).\n * @param dir      - Output directory (created recursively if missing).\n * @param cell     - Cell axes for the filename suffix.\n * @returns The absolute paths written (one per category), in category order.\n */\nexport async function writeCaptureArtifacts(\n  captures: ReadonlyArray<AitCaptureLine>,\n  dir: string,\n  cell: { sdkLine: string; platform: string },\n): Promise<string[]> {\n  if (captures.length === 0) return [];\n\n  // Group payloads by category, preserving harvest order. Each payload is an\n  // opaque JSON array string; concatenate parsed arrays under the same category.\n  const byCategory = new Map<string, unknown[]>();\n  for (const { category, json } of captures) {\n    let merged = byCategory.get(category);\n    if (!merged) {\n      merged = [];\n      byCategory.set(category, merged);\n    }\n    // The parser already validated `json` parses; an array payload is expected.\n    const parsed = JSON.parse(json) as unknown;\n    if (Array.isArray(parsed)) {\n      merged.push(...parsed);\n    } else {\n      merged.push(parsed);\n    }\n  }\n\n  await mkdir(dir, { recursive: true });\n  const written: string[] = [];\n  for (const [category, records] of byCategory) {\n    const outFile = path.join(dir, `${category}.${cell.sdkLine}.${cell.platform}.json`);\n    await writeFile(outFile, `${JSON.stringify(records, null, 2)}\\n`, 'utf8');\n    written.push(outFile);\n  }\n  return written;\n}\n"],"mappings":"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"}

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

@@ -1,56 +0,0 @@
-import { t as CdpConnection } from "../cdp-connection-rP1WdnH5.js";
-import { t as RunReport } from "../runtime-kn9DxOeg.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. `timeoutMs` (default 60s) is the authoritative file
- * timeout — this function races it against the evaluate call AND (devtools#747)
- * threads it down to the underlying `CdpConnection`'s own per-command watchdog
- * (plus a small margin) so that watchdog can never undercut this race. Split
- * into smaller files if you hit the timeout.
- *
- * @param connection   - Active CDP connection (relay or local).
- * @param bundleCode   - IIFE bundle string from `bundleTestFile`.
- * @param timeoutMs    - Override the default 60 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

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

package/dist/test-runner/rpc.js

@@ -1,98 +0,0 @@
-//#region src/test-runner/rpc.ts
-/** Maximum milliseconds to wait for a single evaluate round-trip. */
-const DEFAULT_TIMEOUT_MS = 6e4;
-/**
-* Extra headroom (ms) added on top of the rpc-level `timeoutMs` when telling
-* the underlying `CdpConnection` its per-command watchdog budget (devtools#747).
-* The rpc-level race above is the authoritative file timeout — this margin
-* only ensures the connection's own (shorter-by-default) watchdog never fires
-* first and masks the rpc-level timeout error with a connection-level one.
-*/
-const CONNECTION_TIMEOUT_MARGIN_MS = 5e3;
-/**
-* 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. `timeoutMs` (default 60s) is the authoritative file
-* timeout — this function races it against the evaluate call AND (devtools#747)
-* threads it down to the underlying `CdpConnection`'s own per-command watchdog
-* (plus a small margin) so that watchdog can never undercut this race. Split
-* into smaller files if you hit the timeout.
-*
-* @param connection   - Active CDP connection (relay or local).
-* @param bundleCode   - IIFE bundle string from `bundleTestFile`.
-* @param timeoutMs    - Override the default 60 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 TIMEOUT_SENTINEL = Symbol("timeout");
-	const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs));
-	const evalPromise = connection.send("Runtime.evaluate", {
-		expression,
-		returnByValue: true,
-		awaitPromise: true
-	}, { timeoutMs: timeoutMs + CONNECTION_TIMEOUT_MARGIN_MS });
-	const raceResult = await Promise.race([evalPromise.then((v) => ({
-		tag: "eval",
-		v
-	})), timeoutPromise.then(() => ({ tag: "timeout" }))]);
-	if (raceResult.tag === "timeout") return {
-		ok: false,
-		error: `rpc: evaluate timed out after ${timeoutMs}ms`
-	};
-	const cdpResult = raceResult.v;
-	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

@@ -1 +0,0 @@
-{"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 = 60_000;\n\n/**\n * Extra headroom (ms) added on top of the rpc-level `timeoutMs` when telling\n * the underlying `CdpConnection` its per-command watchdog budget (devtools#747).\n * The rpc-level race above is the authoritative file timeout — this margin\n * only ensures the connection's own (shorter-by-default) watchdog never fires\n * first and masks the rpc-level timeout error with a connection-level one.\n */\nconst CONNECTION_TIMEOUT_MARGIN_MS = 5_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. `timeoutMs` (default 60s) is the authoritative file\n * timeout — this function races it against the evaluate call AND (devtools#747)\n * threads it down to the underlying `CdpConnection`'s own per-command watchdog\n * (plus a small margin) so that watchdog can never undercut this race. Split\n * into smaller files if you hit the timeout.\n *\n * @param connection   - Active CDP connection (relay or local).\n * @param bundleCode   - IIFE bundle string from `bundleTestFile`.\n * @param timeoutMs    - Override the default 60 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 a tagged race so we can distinguish \"timeout won\" from \"evaluate won\"\n  // without relying on exception identity.  The timeout arm RETURNS a typed\n  // RpcRunResult (ok:false + EVALUATE_TIMEOUT_MARKER) so the caller (relay-\n  // worker's attempt()) can detect it via `.error.includes(EVALUATE_TIMEOUT_MARKER)`\n  // and trigger the one-retry path.\n  //\n  // Genuine CDP `exceptionDetails` (engine exceptions thrown inside the page)\n  // still THROW — those are deterministic failures that a retry cannot fix and\n  // relay-worker's catch block finalises them correctly.\n  //\n  // DO NOT change the literal string below — relay-worker.ts imports\n  // EVALUATE_TIMEOUT_MARKER = 'rpc: evaluate timed out after' and uses\n  // `.includes()` to recognise this exact prefix.\n  const TIMEOUT_SENTINEL = Symbol('timeout');\n  const timeoutPromise = new Promise<typeof TIMEOUT_SENTINEL>((resolve) =>\n    setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs),\n  );\n\n  // devtools#747: thread our own timeout budget down to the connection's\n  // per-command watchdog (ChiiCdpConnection's default is 30s and used to fire\n  // before this rpc-level race no matter how large `timeoutMs` was). A small\n  // margin keeps the connection watchdog from firing a beat before our own\n  // race settles — the rpc-level race above remains the authoritative file\n  // timeout; this override only ensures the connection layer never undercuts\n  // it. `LocalCdpConnection` ignores the option (no watchdog of its own).\n  const evalPromise = connection.send(\n    'Runtime.evaluate',\n    {\n      expression,\n      returnByValue: true,\n      awaitPromise: true,\n    },\n    { timeoutMs: timeoutMs + CONNECTION_TIMEOUT_MARGIN_MS },\n  );\n\n  const raceResult = await Promise.race([\n    evalPromise.then((v) => ({ tag: 'eval' as const, v })),\n    timeoutPromise.then(() => ({ tag: 'timeout' as const })),\n  ]);\n\n  if (raceResult.tag === 'timeout') {\n    return { ok: false, error: `rpc: evaluate timed out after ${timeoutMs}ms` };\n  }\n\n  const cdpResult = raceResult.v;\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;;;;;;;;AAS3B,MAAM,+BAA+B;;;;;;;;;;;;;AAcrC,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;;;;;;;;;;;;;;;;;;AAmBvE,eAAsB,mBACpB,YACA,YACA,YAAY,oBACW;CACvB,MAAM,aAAa,wBAAwB,WAAW;CAetD,MAAM,mBAAmB,OAAO,UAAU;CAC1C,MAAM,iBAAiB,IAAI,SAAkC,YAC3D,iBAAiB,QAAQ,iBAAiB,EAAE,UAAU,CACvD;CASD,MAAM,cAAc,WAAW,KAC7B,oBACA;EACE;EACA,eAAe;EACf,cAAc;EACf,EACD,EAAE,WAAW,YAAY,8BAA8B,CACxD;CAED,MAAM,aAAa,MAAM,QAAQ,KAAK,CACpC,YAAY,MAAM,OAAO;EAAE,KAAK;EAAiB;EAAG,EAAE,EACtD,eAAe,YAAY,EAAE,KAAK,WAAoB,EAAE,CACzD,CAAC;AAEF,KAAI,WAAW,QAAQ,UACrB,QAAO;EAAE,IAAI;EAAO,OAAO,iCAAiC,UAAU;EAAK;CAG7E,MAAM,YAAY,WAAW;AAE7B,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/runtime.d.ts

@@ -1,2 +0,0 @@
-import { a as runTestModule, i as TestResult, n as RunTestModuleOptions, o as runtimeGlobals, r as TestContext, t as RunReport } from "../runtime-kn9DxOeg.js";
-export { RunReport, RunTestModuleOptions, TestContext, TestResult, runTestModule, runtimeGlobals };