@ait-co/devtools 0.1.143 → 0.2.0

package/dist/test-runner/bundle.js

@@ -1,439 +0,0 @@
-import { accessSync } from "node:fs";
-import * as fs from "node:fs/promises";
-import * as path$1 from "node:path";
-import { fileURLToPath } from "node:url";
-//#region src/test-runner/bundle.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.
-*/
-/** The SDK package name that mini-app test code imports from. */
-const SDK_PACKAGE = "@apps-in-toss/web-framework";
-/**
-* Names the runtime installs as globals before invoking the user factory.
-* The `vitest` virtual module re-exports each as a lazy getter that reads from
-* `globalThis` at access time. Keep in sync with the globals installed in
-* `runtime.ts#runTestModule`.
-*/
-const VITEST_GLOBAL_NAMES = [
-	"describe",
-	"it",
-	"test",
-	"expect",
-	"beforeAll",
-	"afterAll",
-	"beforeEach",
-	"afterEach",
-	"vi"
-];
-/**
-* Matches the bare SDK package and any sub-path import
-* (`@apps-in-toss/web-framework`, `@apps-in-toss/web-framework/foo`).
-* Built from {@link SDK_PACKAGE} so the package name has a single source.
-*/
-const SDK_IMPORT_FILTER = new RegExp(`^${SDK_PACKAGE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`);
-/**
-* esbuild plugin that intercepts SDK imports and redirects them to the
-* `window.__sdk` proxy that `src/in-app/auto.ts` installs at runtime.
-*
-* Strategy: for every import of `@apps-in-toss/web-framework` (or sub-paths),
-* esbuild resolves it to a virtual module that re-exports all named exports
-* via `window.__sdk[name]`. This avoids bundling the real SDK (which may not
-* be available in the test environment) while still making named imports work.
-*
-* If `window.__sdk` is absent (non-dog-food build), every access throws a
-* descriptive error rather than returning `undefined` silently.
-*
-* Bridge-stub interception (devtools#740, DT-2): the virtual module runs the
-* resolved `window.__sdk` object through `wrapSdkWithStub` before exporting
-* it. `wrapSdkWithStub` is a pass-through (returns the same object,
-* unwrapped) unless `isStubBlockingEnabled()` reads `true` off
-* `globalThis.__AIT_STUB_BLOCKING__` — an opt-in flag injected the same way
-* `__AIT_CELL__` is (`cell.ts#injectGlobals`, wired from the CLI's
-* `--stub-blocking` flag). Default off => zero behavior change: every existing
-* (non-stub) test run resolves the exact same `window.__sdk` reference it did
-* before this plugin learned about stubbing.
-*
-* Per-method pacing (devtools#769): BEFORE the stub wrap, `window.__sdk` is
-* run through `wrapWithMethodPacing`, which enforces a minimum interval
-* between calls to the SAME named SDK function (`getPaceMethodMs()` reads the
-* `__AIT_PACE_METHOD_MS__` page global — see `method-pace.ts`). Composition
-* order is pacing INSIDE the stub (`wrapSdkWithStub(wrapWithMethodPacing(sdk,
-* gap), enabled)`): a stubbed name resolves instantly from
-* `bridge-stub.ts`'s fixtures without ever reaching the paced wrapper, and
-* only calls that fall through to the real bridge — the ones that can
-* actually trigger `APP_BRIDGE_THROTTLED` — pay the pacing cost. `gapMs <= 0`
-* (default, no `--pace-method` / non-2.x cell) is a no-op fast path — see
-* `method-pace.ts#wrapWithMethodPacing`'s doc for the full contract.
-*/
-/**
-* Builds the virtual CommonJS-style module contents the `sdk-redirect`
-* esbuild plugin loads for every `@apps-in-toss/web-framework` import.
-*
-* Pulled out to a pure, exported function (rather than inlined at the
-* `build.onLoad` call site) so unit tests can assert the exact composition
-* order (pacing wraps the raw SDK; the stub wraps the paced result) as a
-* string-level contract, independent of esbuild — esbuild cannot run inside
-* this repo's jsdom vitest environment (see `bundleTestFile`'s module doc's
-* lazy-import note), so a real bundling round-trip is out of unit-test reach
-* here; `wrapSdkWithStub`/`wrapWithMethodPacing`'s own composed-call behavior
-* is covered directly (see `bundle.test.ts`).
-*
-* Generates a virtual CommonJS-style module so that esbuild does NOT perform
-* strict named-export matching. When `format:'iife'` bundles a CJS module, it
-* wraps it with its own `__toCommonJS` helper and satisfies named imports via
-* property access on the `module.exports` object — which is our Proxy. This
-* means `import { getPlatformOS } from '...'` becomes
-* `__proxy.getPlatformOS` at runtime, which correctly reads from
-* `window.__sdk`.
-*
-* The bridge-stub and method-pace imports are STATIC imports of the real
-* `bridge-stub.ts`/`method-pace.ts` modules (not inlined JS) so esbuild
-* bundles each once and the fixture registry / pacing registry have a single
-* source of truth shared with their own unit tests.
-*
-* Exported for unit testing.
-*/
-function buildSdkRedirectModuleContents() {
-	return `
-import { wrapSdkWithStub, isStubBlockingEnabled } from ${JSON.stringify(getBridgeStubPath())};
-import { wrapWithMethodPacing, getPaceMethodMs } from ${JSON.stringify(getMethodPacePath())};
-var __rawSdk = (typeof window !== 'undefined' && window.__sdk)
-  ? window.__sdk
-  : new Proxy({}, {
-      get: function(_t, p) {
-        throw new Error('window.__sdk is not installed — run in a dog-food build. Missing: ' + String(p));
-      }
-    });
-var __pacedSdk = wrapWithMethodPacing(__rawSdk, getPaceMethodMs());
-var __proxy = wrapSdkWithStub(__pacedSdk, isStubBlockingEnabled());
-module.exports = __proxy;
-`;
-}
-function sdkRedirectPlugin() {
-	return {
-		name: "sdk-redirect",
-		setup(build) {
-			build.onResolve({ filter: SDK_IMPORT_FILTER }, (args) => ({
-				path: args.path,
-				namespace: "sdk-redirect"
-			}));
-			build.onLoad({
-				filter: /.*/,
-				namespace: "sdk-redirect"
-			}, () => ({
-				contents: buildSdkRedirectModuleContents(),
-				loader: "js",
-				resolveDir: process.cwd()
-			}));
-		}
-	};
-}
-/**
-* esbuild plugin that intercepts `import … from 'vitest'` and replaces it with
-* a virtual module that delegates every named import to `globalThis` at ACCESS
-* time (not at bundle-evaluation time).
-*
-* The runtime installs `describe/it/test/expect/beforeAll/afterAll/beforeEach/
-* afterEach/vi` as globals inside `runTestModule`, which runs AFTER the bundle
-* IIFE is evaluated. A value-copy redirect (`export var describe =
-* globalThis.describe`) would therefore capture `undefined` at evaluation time
-* and the user's `describe(...)` calls would be no-ops — registering zero tests.
-*
-* The fix defers the lookup to call time using per-name **getter** exports.
-* We emit a CommonJS module that:
-*   1. sets `__esModule = true` so esbuild's `__toESM` interop maps each named
-*      import directly to a property access on the module (NOT wrapped under a
-*      `default` shim — which is what happens for a bare Proxy whose own-keys
-*      are empty, leaving every named import `undefined`);
-*   2. defines each global name as a getter that reads `globalThis[name]` on
-*      every access. So `import { describe } from 'vitest'` compiles to
-*      `import_vitest.describe`, whose getter returns the real `describe` only
-*      when the factory calls it — after `runTestModule` installs the globals.
-*
-* A plain `module.exports = new Proxy(...)` does NOT work here: esbuild routes
-* the virtual module through `__toESM`, which enumerates own-keys (none on an
-* empty Proxy target) and therefore exposes zero named exports. Explicit getter
-* properties give `__toESM` real keys to map while keeping access lazy.
-*/
-function vitestRedirectPlugin() {
-	return {
-		name: "vitest-redirect",
-		setup(build) {
-			build.onResolve({ filter: /^vitest$/ }, () => ({
-				path: "vitest",
-				namespace: "vitest-redirect"
-			}));
-			build.onLoad({
-				filter: /^vitest$/,
-				namespace: "vitest-redirect"
-			}, () => {
-				return {
-					contents: `Object.defineProperty(exports, '__esModule', { value: true });\n${VITEST_GLOBAL_NAMES.map((name) => `Object.defineProperty(exports, ${JSON.stringify(name)}, { enumerable: true, get: function() { return globalThis[${JSON.stringify(name)}]; } });`).join("\n")}\n`,
-					loader: "js"
-				};
-			});
-		}
-	};
-}
-/**
-* 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:
-*   - Import declarations and re-export statements are kept at module top-level
-*     (the only valid ESM position for static `import`). A statement that spans
-*     multiple lines — e.g. a named import with one member per line:
-*       import {
-*         appLogin,
-*         getAnonymousKey,
-*       } from '@apps-in-toss/web-framework';
-*     is tracked as a single block: every line from the opening `import {` /
-*     `export {` through the closing `from '…'` (or side-effect `'…'`) line is
-*     kept together at top-level. This prevents the member lines and the
-*     closing `} from '…'` line from leaking into the factory body, which would
-*     leave an unterminated `import {` at module scope (the #678 env3 failure:
-*     esbuild threw `Expected "as" but found "{"` on multi-line SDK imports).
-*   - 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+)/;
-				const isImportStart = (trimmed) => trimmed.startsWith("import ") || trimmed.startsWith("import{") || trimmed.startsWith("import'") || trimmed.startsWith("import\"");
-				const endsStatement = (trimmed) => /['"]\s*;?\s*$/.test(trimmed.replace(/\/\/.*$/, "").trimEnd());
-				let inImportBlock = false;
-				for (const line of lines) {
-					const trimmed = line.trimStart();
-					const indent = line.slice(0, line.length - trimmed.length);
-					if (inImportBlock) {
-						topLevelLines.push(line);
-						if (endsStatement(trimmed)) inImportBlock = false;
-						continue;
-					}
-					if (isImportStart(trimmed)) {
-						topLevelLines.push(line);
-						if (!endsStatement(trimmed)) inImportBlock = true;
-					} else if (trimmed.startsWith("export ")) if (trimmed.match(EXPORT_DECLARATION_RE)) bodyLines.push(indent + trimmed.slice(7));
-					else {
-						topLevelLines.push(line);
-						if (/\bfrom\b/.test(trimmed) ? !endsStatement(trimmed) : trimmed.endsWith("{")) inImportBlock = true;
-					}
-					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$1.dirname(absPath)
-				};
-			});
-		}
-	};
-}
-/**
-* Returns the absolute filesystem path to a page-side leaf module shipped
-* alongside `bundle.ts` in dist (e.g. `runtime.js`, `bridge-stub.js`) — a
-* fully self-contained module with no further page-side deps of its own.
-*
-* Rolldown code-splitting duplicates this bundling logic into shared chunks
-* emitted at ARBITRARY dist depths: the `devtools-test` CLI pulls it from
-* dist/test-runner/bundle.js (dir = dist/test-runner/), while the `devtools-mcp`
-* daemon (dist/mcp/cli.js) pulls it through a ROOT chunk
-* (dist/debug-server-<hash>.js, dir = dist/). A fixed `..`-hop candidate list
-* is therefore wrong from at least one chunk — the live #697 regression.
-*
-* This resolves WITHOUT assuming chunk depth: from `import.meta.url`'s dir it
-* probes the co-located `<name>.js` and the nested `test-runner/<name>.js`,
-* then ascends one directory at a time (bounded) repeating both probes. The
-* nested probe catches dist/test-runner/<name>.js from the dist/ root level no
-* matter which depth the chunk was hoisted to (root, dist/mcp/, or a future
-* relocation). The build always emits dist/test-runner/<name>.js (tsdown entry
-* `'test-runner/<name>'`; guarded by scripts/check-test-runner-dist.sh for
-* `runtime`).
-*
-* An ABSOLUTE path is returned deliberately: esbuild loads it as a literal file
-* read, bypassing Node module resolution entirely, so this works identically in
-* the npx-daemon context (its own dist tree) and the consumer-CLI context
-* (the mini-app's installed @ait-co/devtools dist) — neither needs the package
-* to be node-resolvable from the caller.
-*
-* @param moduleName - The leaf module's basename without extension, e.g.
-*   `'runtime'` or `'bridge-stub'`.
-*/
-function getPageSideModulePath(moduleName) {
-	const startDir = path$1.dirname(fileURLToPath(import.meta.url));
-	const RELATIVE_PROBES = [
-		[`${moduleName}.js`],
-		["test-runner", `${moduleName}.js`],
-		[`${moduleName}.ts`],
-		["test-runner", `${moduleName}.ts`]
-	];
-	let dir = startDir;
-	for (let i = 0; i < 12; i++) {
-		for (const segs of RELATIVE_PROBES) {
-			const candidate = path$1.join(dir, ...segs);
-			try {
-				accessSync(candidate);
-				return candidate;
-			} catch {}
-		}
-		const parent = path$1.dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-	return path$1.join(startDir, `${moduleName}.js`);
-}
-/** Absolute path to the test-runner page-side runtime (describe/it/test/expect). */
-function getRuntimePath() {
-	return getPageSideModulePath("runtime");
-}
-/**
-* Absolute path to the bridge-stub interceptor (devtools#740, DT-2) —
-* `wrapSdkWithStub`/`isStubBlockingEnabled`, statically imported by the
-* `sdk-redirect` virtual module.
-*/
-function getBridgeStubPath() {
-	return getPageSideModulePath("bridge-stub");
-}
-/**
-* Absolute path to the per-method pacing wrapper (devtools#769) —
-* `wrapWithMethodPacing`/`getPaceMethodMs`, statically imported by the
-* `sdk-redirect` virtual module.
-*/
-function getMethodPacePath() {
-	return getPageSideModulePath("method-pace");
-}
-/**
-* 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.
-*/
-async function bundleTestFile(absPath, opts) {
-	const globalName = opts?.globalName ?? "__testBundle";
-	const extraExternals = opts?.extraExternals ?? [];
-	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$1.dirname(absPath)
-		},
-		bundle: true,
-		format: "iife",
-		globalName,
-		platform: "browser",
-		target: "es2022",
-		write: false,
-		plugins: [
-			userFactoryPlugin(absPath),
-			vitestRedirectPlugin(),
-			sdkRedirectPlugin()
-		],
-		external: extraExternals,
-		treeShaking: true,
-		footer: { js: `globalThis[${JSON.stringify(globalName)}] = ${globalName};` }
-	});
-	const warnings = result.warnings.map((w) => `${path$1.relative(process.cwd(), w.location?.file ?? "")}:${w.location?.line ?? "?"}: ${w.text}`);
-	const outputFile = result.outputFiles?.[0];
-	if (!outputFile) throw new Error("bundleTestFile: esbuild produced no output — check entryPoints");
-	return {
-		code: outputFile.text,
-		warnings
-	};
-}
-//#endregion
-export { buildSdkRedirectModuleContents, bundleTestFile };
-
-//# sourceMappingURL=bundle.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.js","names":["path"],"sources":["../../src/test-runner/bundle.ts"],"sourcesContent":["/**\n * esbuild-based bundler for user test files.\n *\n * Bundles a single test file into a self-contained IIFE string that can be\n * injected into a WebView via `Runtime.evaluate`. The bundle includes the\n * test runtime (`runtime.ts`), which provides `describe/it/test/expect` and\n * the `runTestModule(factory)` entry point.\n *\n * ## How the wiring works\n *\n * The bundle exposes two exports on `globalThis.__testBundle`:\n *   - `runTestModule` — the runtime's entry function.\n *   - `__userFactory`  — an async function whose body is the user's top-level\n *     test registration code (describe/it/test calls).\n *\n * The Node-side RPC (`rpc.ts`) calls:\n *   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`\n *\n * `runTestModule` then installs `describe/it/test/expect` as globals, invokes\n * the factory (which registers all tests), runs them, and returns a `RunReport`.\n *\n * ## Why a factory wrapper is needed\n *\n * Naively adding the runtime to `entryPoints` and bundling the user file would\n * fail for two reasons:\n *   1. `describe/it/test/expect` from the runtime are module-local in the IIFE\n *      scope. The user's top-level `describe(...)` calls expect them as globals —\n *      they are not globals until `runTestModule` installs them.\n *   2. Even with globals pre-installed, the user file runs at IIFE-evaluation\n *      time, before the RPC layer calls `runTestModule` to reset state and start\n *      the test clock.\n *\n * The factory approach solves both: the user's registration code is deferred\n * into a function that `runTestModule` calls AFTER installing the globals.\n *\n * ## Factory extraction algorithm\n *\n * The `userFactoryPlugin` reads the user file and splits lines into:\n *   - **top-level**: `import …` and re-export lines — kept at module scope\n *     (the only valid position for static `import` in ESM).\n *   - **body**: all other statements — moved into the body of the exported\n *     `__userFactory` async function.\n *\n * esbuild processes the re-generated module, following each static import\n * through the normal dependency graph (including the SDK-redirect plugin).\n *\n * ## SDK redirect\n *\n * Imports of `@apps-in-toss/web-framework` (and sub-paths) are intercepted via\n * the `sdkRedirectPlugin` and replaced with a virtual `window.__sdk` proxy that\n * `src/in-app/auto.ts` installs at runtime. This works for both 2.x and 3.x SDK.\n *\n * SECRET-HANDLING: the returned bundle code is caller-managed; never log it.\n */\n\nimport { accessSync } from 'node:fs';\nimport * as fs from 'node:fs/promises';\nimport * as path from 'node:path';\nimport { fileURLToPath } from 'node:url';\n// esbuild is imported for TYPES only at module scope; the runtime module is\n// loaded lazily inside `bundleTestFile` via dynamic import. esbuild runs a\n// startup invariant check (`TextEncoder().encode('') instanceof Uint8Array`)\n// that fails in a jsdom realm — a static import would break every MCP/test\n// module that merely *imports* this file's transitive graph (e.g. debug-server →\n// run_tests). Lazy load keeps esbuild off the import graph until a bundle is\n// actually built, and mirrors the cloudflared/chii dynamic-import precedent.\nimport type * as esbuild from 'esbuild';\n\n/** Options accepted by `bundleTestFile`. */\nexport interface BundleOptions {\n  /**\n   * Additional esbuild `external` patterns. The SDK package\n   * (`@apps-in-toss/web-framework` and `@apps-in-toss/web-framework/*`) is\n   * always handled by the SDK redirect plugin — callers may add more patterns\n   * to be left as globals.\n   */\n  extraExternals?: string[];\n  /**\n   * Global name for the IIFE output object. Defaults to `__testBundle`.\n   * The runtime entry uses this to call `__testBundle.runTestModule(__userFactory)`.\n   */\n  globalName?: string;\n}\n\n/**\n * The result of bundling a test file.\n * `code` is a self-contained IIFE string ready for `Runtime.evaluate`.\n */\nexport interface BundleResult {\n  code: string;\n  warnings: string[];\n}\n\n/** The SDK package name that mini-app test code imports from. */\nconst SDK_PACKAGE = '@apps-in-toss/web-framework';\n\n/**\n * Names the runtime installs as globals before invoking the user factory.\n * The `vitest` virtual module re-exports each as a lazy getter that reads from\n * `globalThis` at access time. Keep in sync with the globals installed in\n * `runtime.ts#runTestModule`.\n */\nconst VITEST_GLOBAL_NAMES = [\n  'describe',\n  'it',\n  'test',\n  'expect',\n  'beforeAll',\n  'afterAll',\n  'beforeEach',\n  'afterEach',\n  'vi',\n] as const;\n\n/**\n * Matches the bare SDK package and any sub-path import\n * (`@apps-in-toss/web-framework`, `@apps-in-toss/web-framework/foo`).\n * Built from {@link SDK_PACKAGE} so the package name has a single source.\n */\nconst SDK_IMPORT_FILTER = new RegExp(`^${SDK_PACKAGE.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')}`);\n\n/**\n * esbuild plugin that intercepts SDK imports and redirects them to the\n * `window.__sdk` proxy that `src/in-app/auto.ts` installs at runtime.\n *\n * Strategy: for every import of `@apps-in-toss/web-framework` (or sub-paths),\n * esbuild resolves it to a virtual module that re-exports all named exports\n * via `window.__sdk[name]`. This avoids bundling the real SDK (which may not\n * be available in the test environment) while still making named imports work.\n *\n * If `window.__sdk` is absent (non-dog-food build), every access throws a\n * descriptive error rather than returning `undefined` silently.\n *\n * Bridge-stub interception (devtools#740, DT-2): the virtual module runs the\n * resolved `window.__sdk` object through `wrapSdkWithStub` before exporting\n * it. `wrapSdkWithStub` is a pass-through (returns the same object,\n * unwrapped) unless `isStubBlockingEnabled()` reads `true` off\n * `globalThis.__AIT_STUB_BLOCKING__` — an opt-in flag injected the same way\n * `__AIT_CELL__` is (`cell.ts#injectGlobals`, wired from the CLI's\n * `--stub-blocking` flag). Default off => zero behavior change: every existing\n * (non-stub) test run resolves the exact same `window.__sdk` reference it did\n * before this plugin learned about stubbing.\n *\n * Per-method pacing (devtools#769): BEFORE the stub wrap, `window.__sdk` is\n * run through `wrapWithMethodPacing`, which enforces a minimum interval\n * between calls to the SAME named SDK function (`getPaceMethodMs()` reads the\n * `__AIT_PACE_METHOD_MS__` page global — see `method-pace.ts`). Composition\n * order is pacing INSIDE the stub (`wrapSdkWithStub(wrapWithMethodPacing(sdk,\n * gap), enabled)`): a stubbed name resolves instantly from\n * `bridge-stub.ts`'s fixtures without ever reaching the paced wrapper, and\n * only calls that fall through to the real bridge — the ones that can\n * actually trigger `APP_BRIDGE_THROTTLED` — pay the pacing cost. `gapMs <= 0`\n * (default, no `--pace-method` / non-2.x cell) is a no-op fast path — see\n * `method-pace.ts#wrapWithMethodPacing`'s doc for the full contract.\n */\n/**\n * Builds the virtual CommonJS-style module contents the `sdk-redirect`\n * esbuild plugin loads for every `@apps-in-toss/web-framework` import.\n *\n * Pulled out to a pure, exported function (rather than inlined at the\n * `build.onLoad` call site) so unit tests can assert the exact composition\n * order (pacing wraps the raw SDK; the stub wraps the paced result) as a\n * string-level contract, independent of esbuild — esbuild cannot run inside\n * this repo's jsdom vitest environment (see `bundleTestFile`'s module doc's\n * lazy-import note), so a real bundling round-trip is out of unit-test reach\n * here; `wrapSdkWithStub`/`wrapWithMethodPacing`'s own composed-call behavior\n * is covered directly (see `bundle.test.ts`).\n *\n * Generates a virtual CommonJS-style module so that esbuild does NOT perform\n * strict named-export matching. When `format:'iife'` bundles a CJS module, it\n * wraps it with its own `__toCommonJS` helper and satisfies named imports via\n * property access on the `module.exports` object — which is our Proxy. This\n * means `import { getPlatformOS } from '...'` becomes\n * `__proxy.getPlatformOS` at runtime, which correctly reads from\n * `window.__sdk`.\n *\n * The bridge-stub and method-pace imports are STATIC imports of the real\n * `bridge-stub.ts`/`method-pace.ts` modules (not inlined JS) so esbuild\n * bundles each once and the fixture registry / pacing registry have a single\n * source of truth shared with their own unit tests.\n *\n * Exported for unit testing.\n */\nexport function buildSdkRedirectModuleContents(): string {\n  return `\nimport { wrapSdkWithStub, isStubBlockingEnabled } from ${JSON.stringify(getBridgeStubPath())};\nimport { wrapWithMethodPacing, getPaceMethodMs } from ${JSON.stringify(getMethodPacePath())};\nvar __rawSdk = (typeof window !== 'undefined' && window.__sdk)\n  ? window.__sdk\n  : new Proxy({}, {\n      get: function(_t, p) {\n        throw new Error('window.__sdk is not installed — run in a dog-food build. Missing: ' + String(p));\n      }\n    });\nvar __pacedSdk = wrapWithMethodPacing(__rawSdk, getPaceMethodMs());\nvar __proxy = wrapSdkWithStub(__pacedSdk, isStubBlockingEnabled());\nmodule.exports = __proxy;\n`;\n}\n\nfunction sdkRedirectPlugin(): esbuild.Plugin {\n  return {\n    name: 'sdk-redirect',\n    setup(build) {\n      // Match the bare package and any sub-path imports\n      build.onResolve({ filter: SDK_IMPORT_FILTER }, (args) => ({\n        path: args.path,\n        namespace: 'sdk-redirect',\n      }));\n\n      build.onLoad({ filter: /.*/, namespace: 'sdk-redirect' }, () => ({\n        contents: buildSdkRedirectModuleContents(),\n        loader: 'js',\n        // resolveDir is required so esbuild can resolve the absolute\n        // getBridgeStubPath()/getMethodPacePath() imports above from a\n        // filesystem base — a virtual module has no implicit directory of\n        // its own. process.cwd() is a safe base for an ABSOLUTE import\n        // specifier (it is never used to resolve anything relative).\n        resolveDir: process.cwd(),\n      }));\n    },\n  };\n}\n\n/**\n * esbuild plugin that intercepts `import … from 'vitest'` and replaces it with\n * a virtual module that delegates every named import to `globalThis` at ACCESS\n * time (not at bundle-evaluation time).\n *\n * The runtime installs `describe/it/test/expect/beforeAll/afterAll/beforeEach/\n * afterEach/vi` as globals inside `runTestModule`, which runs AFTER the bundle\n * IIFE is evaluated. A value-copy redirect (`export var describe =\n * globalThis.describe`) would therefore capture `undefined` at evaluation time\n * and the user's `describe(...)` calls would be no-ops — registering zero tests.\n *\n * The fix defers the lookup to call time using per-name **getter** exports.\n * We emit a CommonJS module that:\n *   1. sets `__esModule = true` so esbuild's `__toESM` interop maps each named\n *      import directly to a property access on the module (NOT wrapped under a\n *      `default` shim — which is what happens for a bare Proxy whose own-keys\n *      are empty, leaving every named import `undefined`);\n *   2. defines each global name as a getter that reads `globalThis[name]` on\n *      every access. So `import { describe } from 'vitest'` compiles to\n *      `import_vitest.describe`, whose getter returns the real `describe` only\n *      when the factory calls it — after `runTestModule` installs the globals.\n *\n * A plain `module.exports = new Proxy(...)` does NOT work here: esbuild routes\n * the virtual module through `__toESM`, which enumerates own-keys (none on an\n * empty Proxy target) and therefore exposes zero named exports. Explicit getter\n * properties give `__toESM` real keys to map while keeping access lazy.\n */\nfunction vitestRedirectPlugin(): esbuild.Plugin {\n  return {\n    name: 'vitest-redirect',\n    setup(build) {\n      build.onResolve({ filter: /^vitest$/ }, () => ({\n        path: 'vitest',\n        namespace: 'vitest-redirect',\n      }));\n\n      build.onLoad({ filter: /^vitest$/, namespace: 'vitest-redirect' }, () => {\n        const getters = VITEST_GLOBAL_NAMES.map(\n          (name) =>\n            `Object.defineProperty(exports, ${JSON.stringify(name)}, { enumerable: true, get: function() { return globalThis[${JSON.stringify(name)}]; } });`,\n        ).join('\\n');\n        // __esModule lets esbuild __toESM map named imports to these getters\n        // directly. Each getter reads globalThis lazily so the value resolves at\n        // call time — after runTestModule installs the globals.\n        return {\n          contents: `Object.defineProperty(exports, '__esModule', { value: true });\\n${getters}\\n`,\n          loader: 'js',\n        };\n      });\n    },\n  };\n}\n\n/**\n * esbuild plugin that transforms the user test file into a module that exports\n * an async `__userFactory` function. The factory defers the user's top-level\n * test registration code (describe/it/test calls) so it only runs when\n * `runTestModule(__userFactory)` explicitly invokes it — AFTER the runtime has\n * installed describe/it/test/expect as globals.\n *\n * Algorithm:\n *   - Import declarations and re-export statements are kept at module top-level\n *     (the only valid ESM position for static `import`). A statement that spans\n *     multiple lines — e.g. a named import with one member per line:\n *       import {\n *         appLogin,\n *         getAnonymousKey,\n *       } from '@apps-in-toss/web-framework';\n *     is tracked as a single block: every line from the opening `import {` /\n *     `export {` through the closing `from '…'` (or side-effect `'…'`) line is\n *     kept together at top-level. This prevents the member lines and the\n *     closing `} from '…'` line from leaking into the factory body, which would\n *     leave an unterminated `import {` at module scope (the #678 env3 failure:\n *     esbuild threw `Expected \"as\" but found \"{\"` on multi-line SDK imports).\n *   - All other lines (describe/it/test calls, local declarations, etc.) are\n *     moved into the body of the exported async factory function.\n *\n * This preserves SDK import resolution (the sdk-redirect plugin processes\n * top-level imports normally) while deferring test registration to the factory.\n */\nfunction userFactoryPlugin(absPath: string): esbuild.Plugin {\n  const NAMESPACE = 'user-test-factory';\n  return {\n    name: 'user-test-factory',\n    setup(build) {\n      // Resolve the virtual \"user-test-factory\" specifier to our namespace.\n      build.onResolve({ filter: /^user-test-factory$/ }, () => ({\n        path: absPath,\n        namespace: NAMESPACE,\n      }));\n\n      // Load the user file, split imports from body, wrap body in the factory.\n      build.onLoad({ filter: /.*/, namespace: NAMESPACE }, async (args) => {\n        const source = await fs.readFile(args.path, 'utf8');\n        const lines = source.split('\\n');\n\n        const topLevelLines: string[] = [];\n        const bodyLines: string[] = [];\n\n        // Matches `export` value declarations that cannot appear inside a\n        // function body. We strip the `export` keyword so they become plain\n        // declarations inside the factory.\n        const EXPORT_DECLARATION_RE =\n          /^(export\\s+)(default\\s+|async\\s+function\\s+|function\\s+|class\\s+|const\\s+|let\\s+|var\\s+)/;\n\n        // True when `trimmed` begins a static `import` statement.\n        const isImportStart = (trimmed: string): boolean =>\n          trimmed.startsWith('import ') ||\n          trimmed.startsWith('import{') ||\n          trimmed.startsWith(\"import'\") ||\n          trimmed.startsWith('import\"');\n\n        // A module-scope `import`/`export … from` statement is \"complete\" on a\n        // single line when it ends with a quoted module specifier (optionally\n        // followed by `;`/whitespace), e.g. `… from '@x';` or side-effect\n        // `import './x';`. A line ending in `{` or `,` (the common multi-line\n        // named-import shape) is therefore NOT complete and must accumulate\n        // further lines until the closing `from '…'` line.\n        const endsStatement = (trimmed: string): boolean =>\n          /['\"]\\s*;?\\s*$/.test(trimmed.replace(/\\/\\/.*$/, '').trimEnd());\n\n        // When set, we are inside an unterminated multi-line import/re-export\n        // block: every subsequent line stays at top level until the block ends.\n        let inImportBlock = false;\n\n        for (const line of lines) {\n          const trimmed = line.trimStart();\n          const indent = line.slice(0, line.length - trimmed.length);\n\n          // Continuation of a multi-line import / re-export block — keep at\n          // top level. The block ends on the line that terminates the\n          // statement (closing `from '…'` / side-effect `'…'`).\n          if (inImportBlock) {\n            topLevelLines.push(line);\n            if (endsStatement(trimmed)) {\n              inImportBlock = false;\n            }\n            continue;\n          }\n\n          // Static import declarations must stay at module top level\n          // (the ESM spec forbids `import` inside a function body). If the\n          // statement does not terminate on this line, open an import block so\n          // the member lines and closing `} from '…'` line stay top-level too.\n          if (isImportStart(trimmed)) {\n            topLevelLines.push(line);\n            if (!endsStatement(trimmed)) {\n              inImportBlock = true;\n            }\n          } else if (trimmed.startsWith('export ')) {\n            // Determine whether this is a re-export (stays top-level) or a value\n            // declaration (goes into the factory, export keyword stripped).\n            const m = trimmed.match(EXPORT_DECLARATION_RE);\n            if (m) {\n              // Value declaration — strip `export ` and move into factory body.\n              // e.g. `export function hello()` → `function hello()`\n              //       `export const x = 1`     → `const x = 1`\n              bodyLines.push(indent + trimmed.slice('export '.length));\n            } else {\n              // Re-export or `export type { … }` — stays at top level. A\n              // multi-line `export { … } from '…'` opens an import block too.\n              topLevelLines.push(line);\n              if (/\\bfrom\\b/.test(trimmed) ? !endsStatement(trimmed) : trimmed.endsWith('{')) {\n                inImportBlock = true;\n              }\n            }\n          } else {\n            bodyLines.push(line);\n          }\n        }\n\n        const factoryContent = [\n          ...topLevelLines,\n          '',\n          '// biome-ignore lint: generated factory wrapper',\n          'export default async function __userFactory(): Promise<void> {',\n          ...bodyLines.map((l) => `  ${l}`),\n          '}',\n        ].join('\\n');\n\n        return {\n          contents: factoryContent,\n          loader: 'ts',\n          resolveDir: path.dirname(absPath),\n        };\n      });\n    },\n  };\n}\n\n/**\n * Returns the absolute filesystem path to a page-side leaf module shipped\n * alongside `bundle.ts` in dist (e.g. `runtime.js`, `bridge-stub.js`) — a\n * fully self-contained module with no further page-side deps of its own.\n *\n * Rolldown code-splitting duplicates this bundling logic into shared chunks\n * emitted at ARBITRARY dist depths: the `devtools-test` CLI pulls it from\n * dist/test-runner/bundle.js (dir = dist/test-runner/), while the `devtools-mcp`\n * daemon (dist/mcp/cli.js) pulls it through a ROOT chunk\n * (dist/debug-server-<hash>.js, dir = dist/). A fixed `..`-hop candidate list\n * is therefore wrong from at least one chunk — the live #697 regression.\n *\n * This resolves WITHOUT assuming chunk depth: from `import.meta.url`'s dir it\n * probes the co-located `<name>.js` and the nested `test-runner/<name>.js`,\n * then ascends one directory at a time (bounded) repeating both probes. The\n * nested probe catches dist/test-runner/<name>.js from the dist/ root level no\n * matter which depth the chunk was hoisted to (root, dist/mcp/, or a future\n * relocation). The build always emits dist/test-runner/<name>.js (tsdown entry\n * `'test-runner/<name>'`; guarded by scripts/check-test-runner-dist.sh for\n * `runtime`).\n *\n * An ABSOLUTE path is returned deliberately: esbuild loads it as a literal file\n * read, bypassing Node module resolution entirely, so this works identically in\n * the npx-daemon context (its own dist tree) and the consumer-CLI context\n * (the mini-app's installed @ait-co/devtools dist) — neither needs the package\n * to be node-resolvable from the caller.\n *\n * @param moduleName - The leaf module's basename without extension, e.g.\n *   `'runtime'` or `'bridge-stub'`.\n */\nfunction getPageSideModulePath(moduleName: string): string {\n  const startDir = path.dirname(fileURLToPath(import.meta.url));\n  // .js first so a SHIPPED chunk never feeds esbuild raw TypeScript; the .ts\n  // probe is last, for the source-tree (tsx) dev case where the module sits\n  // beside bundle.ts and no dist exists.\n  const RELATIVE_PROBES: string[][] = [\n    [`${moduleName}.js`],\n    ['test-runner', `${moduleName}.js`],\n    [`${moduleName}.ts`],\n    ['test-runner', `${moduleName}.ts`],\n  ];\n  // Bounded ascent: a package's dist is only a few levels deep. 12 is far more\n  // than any real layout (root chunk → dist is 0 hops; dist/mcp → dist is 1)\n  // and terminates well before the filesystem root in every case.\n  let dir = startDir;\n  for (let i = 0; i < 12; i++) {\n    for (const segs of RELATIVE_PROBES) {\n      const candidate = path.join(dir, ...segs);\n      try {\n        accessSync(candidate);\n        return candidate;\n      } catch {\n        // try next probe\n      }\n    }\n    const parent = path.dirname(dir);\n    if (parent === dir) break; // reached filesystem root\n    dir = parent;\n  }\n  // Nothing matched — return the co-located path so esbuild emits a clear\n  // \"Could not resolve\" against a concrete path rather than failing cryptically.\n  return path.join(startDir, `${moduleName}.js`);\n}\n\n/** Absolute path to the test-runner page-side runtime (describe/it/test/expect). */\nfunction getRuntimePath(): string {\n  return getPageSideModulePath('runtime');\n}\n\n/**\n * Absolute path to the bridge-stub interceptor (devtools#740, DT-2) —\n * `wrapSdkWithStub`/`isStubBlockingEnabled`, statically imported by the\n * `sdk-redirect` virtual module.\n */\nfunction getBridgeStubPath(): string {\n  return getPageSideModulePath('bridge-stub');\n}\n\n/**\n * Absolute path to the per-method pacing wrapper (devtools#769) —\n * `wrapWithMethodPacing`/`getPaceMethodMs`, statically imported by the\n * `sdk-redirect` virtual module.\n */\nfunction getMethodPacePath(): string {\n  return getPageSideModulePath('method-pace');\n}\n\n/**\n * Bundles `absPath` into a single IIFE string suitable for `Runtime.evaluate`.\n *\n * The IIFE installs `window.__testBundle` (or the custom `globalName`) with:\n *   - `runTestModule` — the runtime entry (from `runtime.ts`).\n *   - `__userFactory` — an async function wrapping the user's test registration\n *     code so it runs AFTER `runTestModule` installs the globals.\n *\n * Callers (rpc.ts) invoke:\n *   `globalThis.__testBundle.runTestModule(globalThis.__testBundle.__userFactory)`\n *\n * @param absPath - Absolute path to the user test file.\n * @param opts    - Optional bundling overrides.\n */\nexport async function bundleTestFile(absPath: string, opts?: BundleOptions): Promise<BundleResult> {\n  const globalName = opts?.globalName ?? '__testBundle';\n  const extraExternals = opts?.extraExternals ?? [];\n\n  // Lazy load esbuild at call time (see the module-scope import note).\n  const esbuild = await import('esbuild');\n  const runtimePath = getRuntimePath();\n\n  // Stdin wrapper: import the runtime and the user factory, re-export both.\n  // esbuild follows the static imports to include runtime.ts and the user file\n  // (via the userFactoryPlugin) in the single IIFE output.\n  const wrapperContent = [\n    `import { runTestModule } from ${JSON.stringify(runtimePath)};`,\n    `import __userFactory from \"user-test-factory\";`,\n    `export { runTestModule, __userFactory };`,\n  ].join('\\n');\n\n  const result = await esbuild.build({\n    stdin: {\n      contents: wrapperContent,\n      loader: 'ts',\n      // resolveDir is used for relative imports from the wrapper. Since the\n      // wrapper only imports absolute paths (runtimePath) and the virtual\n      // \"user-test-factory\" specifier (resolved by plugin), the directory\n      // doesn't matter — but we still provide a sensible default.\n      resolveDir: path.dirname(absPath),\n    },\n    bundle: true,\n    format: 'iife',\n    globalName,\n    platform: 'browser',\n    target: 'es2022',\n    write: false,\n    plugins: [userFactoryPlugin(absPath), vitestRedirectPlugin(), sdkRedirectPlugin()],\n    external: extraExternals,\n    treeShaking: true,\n    // Ensure the IIFE result is always reachable via globalThis regardless of\n    // the evaluation context.  esbuild's `globalName` emits:\n    //   var __testBundle = (() => { ... })();\n    // When `Runtime.evaluate` runs this bundle code inside an outer wrapper\n    // (rpc.ts's async IIFE), `var` creates a local variable — NOT a global\n    // property — so `globalThis.__testBundle` stays `undefined`.  The footer\n    // explicitly assigns the local variable to `globalThis` to close that gap.\n    footer: {\n      js: `globalThis[${JSON.stringify(globalName)}] = ${globalName};`,\n    },\n  });\n\n  const warnings = result.warnings.map(\n    (w) =>\n      `${path.relative(process.cwd(), w.location?.file ?? '')}:${w.location?.line ?? '?'}: ${w.text}`,\n  );\n\n  const outputFile = result.outputFiles?.[0];\n  if (!outputFile) {\n    throw new Error('bundleTestFile: esbuild produced no output — check entryPoints');\n  }\n\n  return { code: outputFile.text, warnings };\n}\n"],"mappings":"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"}

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

@@ -1,2 +0,0 @@
-import { n as parseCaptureLines, t as AitCaptureLine } from "../capture-DsP525OZ.js";
-export { AitCaptureLine, parseCaptureLines };

package/dist/test-runner/capture.js

@@ -1,44 +0,0 @@
-//#region src/test-runner/capture.ts
-/** The exact console-line prefix sdk-example's `flushCapture` emits. */
-const CAPTURE_PREFIX = "__AIT_CAPTURE__ ";
-/**
-* Parses raw console line texts into {@link AitCaptureLine}s.
-*
-* Filtering rules (each independently drops a line — never throws):
-*   - the line text must `startsWith(CAPTURE_PREFIX)` exactly (allowlist);
-*   - there must be a non-empty category token (up to the next space);
-*   - the remaining payload must be valid JSON (`JSON.parse` succeeds).
-*
-* Lines that fail any rule (wss/scheme noise, truncated, broken JSON) are
-* silently discarded — capture harvesting is best-effort and must never fail a
-* run or leak a malformed/secret-bearing line.
-*
-* @param raw - Console line objects (only `.text` is read).
-* @returns The captured lines, in input order.
-*/
-function parseCaptureLines(raw) {
-	const out = [];
-	for (const { text } of raw) {
-		if (!text.startsWith(CAPTURE_PREFIX)) continue;
-		const body = text.slice(16);
-		const spaceIdx = body.indexOf(" ");
-		if (spaceIdx === -1) continue;
-		const category = body.slice(0, spaceIdx);
-		const json = body.slice(spaceIdx + 1);
-		if (category === "" || json === "") continue;
-		try {
-			JSON.parse(json);
-		} catch {
-			continue;
-		}
-		out.push({
-			category,
-			json
-		});
-	}
-	return out;
-}
-//#endregion
-export { parseCaptureLines };
-
-//# sourceMappingURL=capture.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"capture.js","names":[],"sources":["../../src/test-runner/capture.ts"],"sourcesContent":["/**\n * `__AIT_CAPTURE__` console-line parser (devtools#696).\n *\n * env3 test runs inject sdk-example's `aitCapture.ts`, which — when running in a\n * WebView (no filesystem) — emits one `console.log` line per category in the\n * stable form:\n *\n *   __AIT_CAPTURE__ <category> <json>\n *\n * The relay-worker harvests `Runtime.consoleAPICalled` events as plain text\n * lines (see `relay-worker.ts`) and hands them here. This module's only job is\n * to recognise the allowlisted prefix, split off the category, and keep the\n * remaining JSON string OPAQUE — devtools does NOT own or interpret the\n * `__AIT_CAPTURE__` record shape (that lives in sdk-example). We carry\n * `{ category, json }` through untouched so the 2.x↔3.0 line comparison stays a\n * downstream concern.\n *\n * Why a strict allowlist prefix (SECRET-HANDLING): the raw console stream may\n * also contain wss/scheme/relay noise lines. Only lines that EXACTLY start with\n * `'__AIT_CAPTURE__ '` pass; everything else is discarded, so a stray relay URL\n * can never be serialised into a capture artifact.\n *\n * react-free, dependency-free — safe to import from any test-runner entry\n * without dragging in the chii/cloudflared Node graph.\n */\n\n/**\n * One parsed capture line. `json` is the raw JSON string exactly as the page\n * emitted it (an array of sdk-example capture records). devtools treats it as\n * opaque — it is validated as parseable JSON but never inspected.\n */\nexport interface AitCaptureLine {\n  /** The capture category (first whitespace-delimited token after the prefix). */\n  category: string;\n  /** The remaining JSON payload, verbatim. Opaque to devtools. */\n  json: string;\n}\n\n/** The exact console-line prefix sdk-example's `flushCapture` emits. */\nconst CAPTURE_PREFIX = '__AIT_CAPTURE__ ';\n\n/**\n * Parses raw console line texts into {@link AitCaptureLine}s.\n *\n * Filtering rules (each independently drops a line — never throws):\n *   - the line text must `startsWith(CAPTURE_PREFIX)` exactly (allowlist);\n *   - there must be a non-empty category token (up to the next space);\n *   - the remaining payload must be valid JSON (`JSON.parse` succeeds).\n *\n * Lines that fail any rule (wss/scheme noise, truncated, broken JSON) are\n * silently discarded — capture harvesting is best-effort and must never fail a\n * run or leak a malformed/secret-bearing line.\n *\n * @param raw - Console line objects (only `.text` is read).\n * @returns The captured lines, in input order.\n */\nexport function parseCaptureLines(raw: ReadonlyArray<{ text: string }>): AitCaptureLine[] {\n  const out: AitCaptureLine[] = [];\n  for (const { text } of raw) {\n    // Allowlist: only the exact `__AIT_CAPTURE__ ` prefix passes. wss/scheme\n    // noise lines are dropped here (SECRET-HANDLING).\n    if (!text.startsWith(CAPTURE_PREFIX)) continue;\n\n    const body = text.slice(CAPTURE_PREFIX.length);\n    const spaceIdx = body.indexOf(' ');\n    // No payload separator → malformed; drop.\n    if (spaceIdx === -1) continue;\n\n    const category = body.slice(0, spaceIdx);\n    const json = body.slice(spaceIdx + 1);\n    if (category === '' || json === '') continue;\n\n    // Validate the payload is parseable JSON, but keep it as an OPAQUE string —\n    // devtools does not own the record shape. Broken JSON is discarded (no throw).\n    try {\n      JSON.parse(json);\n    } catch {\n      continue;\n    }\n\n    out.push({ category, json });\n  }\n  return out;\n}\n"],"mappings":";;AAuCA,MAAM,iBAAiB;;;;;;;;;;;;;;;;AAiBvB,SAAgB,kBAAkB,KAAwD;CACxF,MAAM,MAAwB,EAAE;AAChC,MAAK,MAAM,EAAE,UAAU,KAAK;AAG1B,MAAI,CAAC,KAAK,WAAW,eAAe,CAAE;EAEtC,MAAM,OAAO,KAAK,MAAM,GAAsB;EAC9C,MAAM,WAAW,KAAK,QAAQ,IAAI;AAElC,MAAI,aAAa,GAAI;EAErB,MAAM,WAAW,KAAK,MAAM,GAAG,SAAS;EACxC,MAAM,OAAO,KAAK,MAAM,WAAW,EAAE;AACrC,MAAI,aAAa,MAAM,SAAS,GAAI;AAIpC,MAAI;AACF,QAAK,MAAM,KAAK;UACV;AACN;;AAGF,MAAI,KAAK;GAAE;GAAU;GAAM,CAAC;;AAE9B,QAAO"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/test-runner/relay-factory.ts","../../src/test-runner/config.ts"],"mappings":";;;;UAiDiB,6BAAA;ECrBe;;;;;;AAkBhC;;;EDaE,SAAA;ECZA;;;;;AAkBF;;;;;EDKE,cAAA;ECLuE;;;AAczE;;;;;;;;;EDIE,MAAA;ECEW;AAIb;;;EDDE,WAAA;ECC6C;;;;;;AAkC/C;;;EDzBE,SAAA;ECyBkD;EDvBlD,QAAA;ECuB0E;;;;;EDjB1E,IAAA;IAAS,OAAA;IAAiB,QAAA;EAAA;;;;;;;;;;EAU1B,YAAA;;;;;;;;;;;;EAYA,MAAA;;;;;;;;;;;;EAYA,YAAA;;;;;;;;EAQA,aAAA;;;;;;;;;;;;;;;;;EAiBA,WAAA,GAAc,UAAA;AAAA;;;;;;;;;;;;;;;;;;;iBAqBA,4BAAA,CACd,IAAA,EAAM,6BAAA,GACL,sBAAA;;;;;;UChKc,eAAA;ED8JD;;;;ECzJd,OAAA;ED0JA;;;ECtJA,SAAA;;;;AATF;EAcE,cAAA;AAAA;;UAIe,mBAAA;EACf,OAAA;EACA,SAAA;EACA,cAAA;AAAA;AAHF;;;;;;;AAAA,iBAmBgB,qBAAA,CAAsB,UAAA,GAAa,mBAAA,GAAsB,eAAA;;AAAzE;;;;;UAciB,qBAAA;EAdwD;EAgBvE,IAAA,EAAM,UAAA,QAAkB,eAAA;EAhB8D;EAkBtF,OAAA;EAJoC;EAMpC,WAAA;AAAA;;UAIe,qBAAA,SAA8B,mBAAA;EARrB;;;;;AAQ1B;;EAQE,UAAA,EAAY,sBAAA;EARoD;;;;;;;EAgBhE,eAAA;AAAA;;;;;;;;;;;;;;;;iBAkBc,uBAAA,CAAwB,UAAA,EAAY,qBAAA,GAAwB,qBAAA"}

package/dist/test-runner/method-pace.d.ts

@@ -1,82 +0,0 @@
-//#region src/test-runner/method-pace.d.ts
-/**
- * Per-method minimum-interval pacing for SDK calls (devtools#769).
- *
- * #767's `--pace` inserts delays BETWEEN test files / test-to-test — it has no
- * effect on a burst of same-method calls WITHIN a single test body (e.g. a
- * clipboard happy-path loop calling `setClipboardText`/`getClipboardText`
- * eight times back to back). Real-device observation (sdk-example#293,
- * 2.x×iOS) showed that burst alone is enough to saturate the native
- * per-method bridge rate limit (`APP_BRIDGE_THROTTLED`, devtools#767/throttle.ts)
- * even though `--pace`'s file/test spacing was already in effect — the
- * limiter reacts to burst cadence within a method name, not just across test
- * boundaries.
- *
- * This module wraps `window.__sdk` (the same bridge object `bundle.ts`'s
- * `sdkRedirectPlugin` redirects SDK imports to) so that every call to the
- * SAME named function waits out a minimum gap since that function's PREVIOUS
- * invocation before the real call proceeds. Preflight (`cell.ts`) proved the
- * inverse case empirically: a steady 250ms sequential cadence passes cleanly
- * where an unpaced burst does not — sequential-with-spacing is the fix this
- * module generalizes to every SDK call, not just the six permission probes.
- *
- * Runs entirely on the PAGE side (browser-compatible, no Node APIs) — bundled
- * into the injected IIFE by `bundle.ts`'s `sdkRedirectPlugin`, the same way
- * `bridge-stub.ts` and `runtime.ts` are. Imported ONLY from the test-runner
- * (never from `sdk-example/src` — boilerplate cleanliness, umbrella §1.4).
- *
- * SECRET-HANDLING: this module carries no secrets — only method names and
- * millisecond timestamps/durations.
- */
-/**
- * Reads the page-global `__AIT_PACE_METHOD_MS__` gap value (devtools#769),
- * injected by `relay-factory.ts` the same way `__AIT_PACE_MS__`/`__AIT_CELL__`
- * are (`cell.ts#injectGlobals`). Absent/non-positive resolves to `0` — the
- * same "treat absence as zero" contract `runtime.ts`'s `__AIT_PACE_MS__` read
- * uses.
- */
-declare function getPaceMethodMs(): number;
-/**
- * Wraps an SDK-shaped bridge object (`window.__sdk`, or the already
- * stub-wrapped result of `bridge-stub.ts#wrapSdkWithStub`) so that every
- * function-valued export is paced to a minimum `gapMs` interval between
- * calls to the SAME name (devtools#769). Non-function exports (constants,
- * etc.) and classes (`PermissionError`, etc. — wrapping a class would break
- * `new`, see `isClass`) pass through completely untouched.
- *
- * **Composition with bridge-stub (devtools#740)**: this wrapper is applied to
- * the RAW `window.__sdk` object, and `wrapSdkWithStub` is applied on TOP of
- * the paced result (`wrapSdkWithStub(wrapWithMethodPacing(rawSdk, gapMs),
- * stubEnabled)` — see `bundle.ts`'s sdk-redirect virtual module). This means
- * pacing sits BEHIND the stub interception: a stubbed name
- * (`STUB_REGISTRY` — `openPermissionDialog`, `requestPermission`,
- * `saveBase64Data`, `showFullScreenAd`) resolves instantly from the fixture
- * with no added delay, because `wrapSdkWithStub`'s Proxy intercepts the
- * property access before the paced function is ever reached. Only calls that
- * fall through to the REAL bridge — the ones that actually risk
- * `APP_BRIDGE_THROTTLED` — pay the pacing cost. Fixed by this ordering, not
- * incidental: swapping it (pacing outside the stub) would pace fixture
- * look-ups that can never hit the native rate limiter, for no benefit.
- *
- * `gapMs <= 0` (the default, no `--pace-method` / non-2.x cell) returns `sdk`
- * itself, untouched — the exact object identity is preserved so the
- * zero-diff-when-off contract holds under strict-equality checks, matching
- * `wrapSdkWithStub`'s own `enabled === false` fast path.
- *
- * **Memoization**: wrapper functions are cached per name in a `Map` local to
- * this call's `Proxy` (`wrapperCache` below), so repeated property access on
- * the SAME `sdk` object within a single `wrapWithMethodPacing` call returns
- * the SAME wrapper reference. This cache does NOT persist across separate
- * `wrapWithMethodPacing` calls — each call (e.g. the sdk-redirect virtual
- * module re-evaluated per test file bundle) gets its own fresh `Map` and
- * therefore its own wrapper function instances, even for the same method
- * name. That's fine for pacing correctness: the actual timing state lives in
- * the page-global `getRegistry()` map (keyed by method name, not by wrapper
- * identity), so cross-bundle pacing still works. But callers should NOT
- * assume cross-call function identity — only "same wrapper within one call"
- * is guaranteed.
- */
-declare function wrapWithMethodPacing(sdk: Record<string, unknown>, gapMs: number): Record<string, unknown>;
-//#endregion
-export { getPaceMethodMs, wrapWithMethodPacing };
-//# sourceMappingURL=method-pace.d.ts.map

package/dist/test-runner/method-pace.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"method-pace.d.ts","names":[],"sources":["../../src/test-runner/method-pace.ts"],"mappings":";;AAmFA;;;;;AA4EA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA5EgB,eAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4EA,oBAAA,CACd,GAAA,EAAK,MAAA,mBACL,KAAA,WACC,MAAA"}