@ait-co/devtools 0.1.144 → 0.2.1

package/dist/bundle-C796JIwG.d.ts

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

package/dist/bundle-C796JIwG.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle-C796JIwG.d.ts","names":[],"sources":["../src/test-runner/bundle.ts"],"mappings":";;AAqEA;;;;;AAmBA;;;;;AA+FA;;;;;AA4UA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA9biB,aAAA;;;;;;;EAOf,cAAA;;;;;EAKA,UAAA;AAAA;;;;;UAOe,YAAA;EACf,IAAA;EACA,QAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6Fc,8BAAA,CAAA;;;;;;;;;;;;;;;iBA4UM,cAAA,CAAe,OAAA,UAAiB,IAAA,GAAO,aAAA,GAAgB,OAAA,CAAQ,YAAA"}

package/dist/capture-DsP525OZ.d.ts

@@ -1,58 +0,0 @@
-//#region src/test-runner/capture.d.ts
-/**
- * `__AIT_CAPTURE__` console-line parser (devtools#696).
- *
- * env3 test runs inject sdk-example's `aitCapture.ts`, which — when running in a
- * WebView (no filesystem) — emits one `console.log` line per category in the
- * stable form:
- *
- *   __AIT_CAPTURE__ <category> <json>
- *
- * The relay-worker harvests `Runtime.consoleAPICalled` events as plain text
- * lines (see `relay-worker.ts`) and hands them here. This module's only job is
- * to recognise the allowlisted prefix, split off the category, and keep the
- * remaining JSON string OPAQUE — devtools does NOT own or interpret the
- * `__AIT_CAPTURE__` record shape (that lives in sdk-example). We carry
- * `{ category, json }` through untouched so the 2.x↔3.0 line comparison stays a
- * downstream concern.
- *
- * Why a strict allowlist prefix (SECRET-HANDLING): the raw console stream may
- * also contain wss/scheme/relay noise lines. Only lines that EXACTLY start with
- * `'__AIT_CAPTURE__ '` pass; everything else is discarded, so a stray relay URL
- * can never be serialised into a capture artifact.
- *
- * react-free, dependency-free — safe to import from any test-runner entry
- * without dragging in the chii/cloudflared Node graph.
- */
-/**
- * One parsed capture line. `json` is the raw JSON string exactly as the page
- * emitted it (an array of sdk-example capture records). devtools treats it as
- * opaque — it is validated as parseable JSON but never inspected.
- */
-interface AitCaptureLine {
-  /** The capture category (first whitespace-delimited token after the prefix). */
-  category: string;
-  /** The remaining JSON payload, verbatim. Opaque to devtools. */
-  json: string;
-}
-/**
- * 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.
- */
-declare function parseCaptureLines(raw: ReadonlyArray<{
-  text: string;
-}>): AitCaptureLine[];
-//#endregion
-export { parseCaptureLines as n, AitCaptureLine as t };
-//# sourceMappingURL=capture-DsP525OZ.d.ts.map

package/dist/capture-DsP525OZ.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"capture-DsP525OZ.d.ts","names":[],"sources":["../src/test-runner/capture.ts"],"mappings":";;AA+BA;;;;;AAyBA;;;;;;;;;;;;;;;;;;;;;;;;UAzBiB,cAAA;;EAEf,QAAA;;EAEA,IAAA;AAAA;;;;;;;;;;;;;;;;iBAqBc,iBAAA,CAAkB,GAAA,EAAK,aAAA;EAAgB,IAAA;AAAA,KAAkB,cAAA"}

package/dist/cdp-connection-rP1WdnH5.d.ts

@@ -1,287 +0,0 @@
-//#region src/mcp/cdp-connection.d.ts
-/**
- * Injectable CDP connection abstraction for the debug-mode MCP server.
- *
- * The Phase 1 tool layer (`list_console_messages`, `list_network_requests`,
- * `list_pages`) reads from CDP events captured off a Chii relay connection.
- * To keep that tool layer CI-verifiable without a phone roundtrip, the actual
- * relay websocket sits behind this interface. Production wires
- * `ChiiCdpConnection` (see `chii-connection.ts`); tests inject a fake that
- * emits canned `Runtime.consoleAPICalled` / `Network.*` events.
- *
- * Phase 2 adds CDP *commands* (request→response): `DOM.getDocument`,
- * `DOMSnapshot.captureSnapshot`, `Page.captureScreenshot`. Unlike Phase 1's
- * event streams these need a `send(method, params)` round-trip, so the
- * connection grows a typed `send`. The fake returns canned command results.
- *
- * Phase 2 extension: `Runtime.evaluate` (read-only probe) added for the
- * `measure_safe_area` tool — executes a JS snippet on the attached page and
- * returns the result as a `RemoteObject`. The fake returns canned results for
- * unit tests without a phone roundtrip.
- *
- * Only the slice of the Chrome DevTools Protocol the tools need is typed here.
- */
-/** A target (page) the Chii relay currently sees attached. */
-interface CdpTarget {
-  /** Chii's internal target id (session UUID). */
-  id: string;
-  /** Page title reported by the in-app target. */
-  title: string;
-  /** Page URL reported by the in-app target. */
-  url: string;
-}
-/** `Runtime.RemoteObject` subset we surface for console args. */
-interface CdpRemoteObject {
-  type: string;
-  subtype?: string;
-  value?: unknown;
-  description?: string;
-  className?: string;
-}
-/** Payload of a `Runtime.consoleAPICalled` event. */
-interface ConsoleApiCalledEvent {
-  /** log | warning | error | info | debug | … */
-  type: string;
-  args: CdpRemoteObject[];
-  /** Milliseconds since epoch (CDP `Runtime.Timestamp`). */
-  timestamp: number;
-  executionContextId?: number;
-  stackTrace?: {
-    callFrames: Array<{
-      functionName: string;
-      url: string;
-      lineNumber: number;
-      columnNumber: number;
-    }>;
-  };
-}
-/** Payload of a `Network.requestWillBeSent` event (subset). */
-interface NetworkRequestWillBeSentEvent {
-  requestId: string;
-  request: {
-    url: string;
-    method: string;
-    headers?: Record<string, string>;
-  };
-  /** CDP `Network.MonotonicTime` (seconds). */
-  timestamp: number;
-  /** Wall-clock seconds since epoch, when available. */
-  wallTime?: number;
-  type?: string;
-}
-/** Payload of a `Network.responseReceived` event (subset). */
-interface NetworkResponseReceivedEvent {
-  requestId: string;
-  response: {
-    url: string;
-    status: number;
-    statusText: string;
-    mimeType?: string;
-  };
-  timestamp: number;
-  type?: string;
-}
-/**
- * A single call frame in a `Runtime.exceptionThrown` stack trace.
- * Subset of the CDP `Runtime.CallFrame` shape.
- */
-interface CdpCallFrame {
-  functionName: string;
-  scriptId?: string;
-  url: string;
-  lineNumber: number;
-  columnNumber: number;
-}
-/** Payload of a `Runtime.exceptionThrown` event. */
-interface RuntimeExceptionThrownEvent {
-  /** Milliseconds since epoch (CDP `Runtime.Timestamp`). */
-  timestamp: number;
-  exceptionDetails: {
-    exceptionId: number;
-    text: string;
-    lineNumber: number;
-    columnNumber: number;
-    scriptId?: string;
-    url?: string;
-    stackTrace?: {
-      callFrames: CdpCallFrame[];
-    }; /** The thrown value as a CDP `RemoteObject`. */
-    exception?: CdpRemoteObject;
-  };
-}
-/** Map of the CDP event names Phase 1 consumes to their payload shapes. */
-interface CdpEventMap {
-  'Runtime.consoleAPICalled': ConsoleApiCalledEvent;
-  'Network.requestWillBeSent': NetworkRequestWillBeSentEvent;
-  'Network.responseReceived': NetworkResponseReceivedEvent;
-  'Runtime.exceptionThrown': RuntimeExceptionThrownEvent;
-}
-type CdpEventName = keyof CdpEventMap;
-/** A `DOM.Node` subset (recursive) returned by `DOM.getDocument`. */
-interface CdpDomNode {
-  nodeId: number;
-  /** CDP node type (1 = element, 3 = text, 9 = document, …). */
-  nodeType: number;
-  nodeName: string;
-  /** Tag/local name for elements. */
-  localName?: string;
-  nodeValue?: string;
-  /** Flattened attribute list: `[name, value, name, value, …]`. */
-  attributes?: string[];
-  childNodeCount?: number;
-  children?: CdpDomNode[];
-  documentURL?: string;
-  baseURL?: string;
-}
-/** Result of `DOM.getDocument`. */
-interface DomGetDocumentResult {
-  root: CdpDomNode;
-}
-/** Result of `DOMSnapshot.captureSnapshot` (subset we surface). */
-interface DomSnapshotResult {
-  documents: unknown[];
-  strings: string[];
-}
-/** Result of `Page.captureScreenshot`. */
-interface PageCaptureScreenshotResult {
-  /** Base64-encoded image bytes (PNG by default). */
-  data: string;
-}
-/**
- * Params for `Runtime.evaluate`.
- * Covers the subset used by the `measure_safe_area` read-only probe.
- */
-interface RuntimeEvaluateParams {
-  /** JavaScript expression to evaluate in the page context. */
-  expression: string;
-  /** Return the result as a plain JSON value (vs. a handle). Default false. */
-  returnByValue?: boolean;
-  /** Await a returned Promise before resolving. Default false. */
-  awaitPromise?: boolean;
-}
-/** Result of `Runtime.evaluate`. */
-interface RuntimeEvaluateResult {
-  /** The evaluation result. */
-  result: CdpRemoteObject;
-  /** Present when evaluation threw an uncaught exception. */
-  exceptionDetails?: {
-    text: string;
-    exception?: CdpRemoteObject;
-  };
-}
-/**
- * Map of CDP command method → params/result shape. Keeps `send` typed so a
- * `DOM.getDocument` call resolves to a `DomGetDocumentResult`, etc.
- */
-interface CdpCommandMap {
-  'DOM.getDocument': {
-    params: {
-      depth?: number;
-      pierce?: boolean;
-    };
-    result: DomGetDocumentResult;
-  };
-  'DOMSnapshot.captureSnapshot': {
-    params: {
-      computedStyles?: string[];
-    };
-    result: DomSnapshotResult;
-  };
-  'Page.captureScreenshot': {
-    params: {
-      format?: 'png' | 'jpeg' | 'webp';
-      quality?: number;
-    };
-    result: PageCaptureScreenshotResult;
-  };
-  'Runtime.evaluate': {
-    params: RuntimeEvaluateParams;
-    result: RuntimeEvaluateResult;
-  };
-}
-type CdpCommandName = keyof CdpCommandMap;
-/**
- * The connection the tool layer reads from. The production implementation
- * wraps the Chii relay's CDP websocket; tests inject a fake.
- *
- * Implementations are expected to maintain an internal ring buffer of recent
- * events (so a tool call returns recent history rather than only live events).
- */
-interface CdpConnection {
-  /**
-   * Authoritative kind of this connection's transport (issue #348).
-   *
-   * - `'relay'` — backed by the Chii relay + cloudflared tunnel (a real-device
-   *   WebView, env 3/4). `ChiiCdpConnection`.
-   * - `'local'` — backed by a direct CDP websocket to a local Chromium (env 1).
-   *   `LocalCdpConnection`.
-   *
-   * This replaces the old `getEnvironment()` URL-pattern sniffing: the
-   * `mock` vs `relay` split is now a free, authoritative property of the
-   * connection itself, known before any target attaches. The `relay-dev` vs
-   * `relay-live` distinction is orthogonal (operator-supplied `liveIntent`,
-   * see `environment.ts`) because dog-food and production relays are
-   * byte-identical on the wire.
-   */
-  readonly kind: 'relay' | 'local';
-  /**
-   * Enable the CDP domains Phase 1 needs (`Runtime.enable`, `Network.enable`).
-   * Idempotent. Resolves once the relay has acknowledged (or immediately for a
-   * fake connection).
-   */
-  enableDomains(): Promise<void>;
-  /** Targets (pages) the relay currently sees attached. */
-  listTargets(): CdpTarget[];
-  /** Recent buffered events for a domain, oldest-first. */
-  getBufferedEvents<E extends CdpEventName>(event: E): ReadonlyArray<CdpEventMap[E]>;
-  /** Subscribe to live events. Returns an unsubscribe function. */
-  on<E extends CdpEventName>(event: E, listener: (payload: CdpEventMap[E]) => void): () => void;
-  /**
-   * Issue a CDP command (request → response). Phase 2's DOM/snapshot/screenshot
-   * tools use this; resolves with the typed result or rejects on a CDP error.
-   * Implementations must have called {@link enableDomains} first.
-   *
-   * @param opts.timeoutMs - Per-call override for the connection's own command
-   *   watchdog (devtools#747). Optional — implementations without a per-command
-   *   watchdog (e.g. `LocalCdpConnection`) may ignore it. Callers that already
-   *   race `send` against their own longer timeout (e.g. the test-runner's
-   *   file-evaluate budget) MUST pass a `timeoutMs` at least as large as that
-   *   caller-side timeout, or the connection's shorter default watchdog fires
-   *   first and undercuts the caller's race.
-   */
-  send<M extends CdpCommandName>(method: M, params?: CdpCommandMap[M]['params'], opts?: {
-    timeoutMs?: number;
-  }): Promise<CdpCommandMap[M]['result']>;
-  /**
-   * Close the underlying transport and reject any in-flight commands.
-   * Optional so that minimal test fakes that don't need teardown remain
-   * compatible without change. Both `ChiiCdpConnection` and
-   * `LocalCdpConnection` already implement this.
-   */
-  close?(): void;
-  /**
-   * Refresh the attached-target list from the relay and return the result.
-   * Emits an internal `'target:attached'` event when a new target appears so
-   * that {@link waitForFirstTarget} can race against the polling round.
-   *
-   * Optional — only `ChiiCdpConnection` (relay mode) supports this; local
-   * connections and test fakes may omit it. Callers should guard with
-   * `connection.refreshTargets?.()`.
-   */
-  refreshTargets?(): Promise<CdpTarget[]>;
-  /**
-   * Waits until at least one target satisfying `filterFn` is attached, then
-   * resolves with the full target list at that moment.
-   *
-   * Optional — only `ChiiCdpConnection` provides the event-driven
-   * implementation. When absent, callers fall back to a generic polling loop.
-   *
-   * @param filterFn      - Predicate the resolved targets must satisfy.
-   * @param timeoutMs     - Reject after this many ms (default 90 000).
-   * @param pollIntervalMs - Fallback poll interval (default 500 ms).
-   */
-  waitForFirstTarget?(filterFn: (targets: CdpTarget[]) => boolean, timeoutMs?: number, pollIntervalMs?: number): Promise<CdpTarget[]>;
-}
-//#endregion
-export { CdpConnection as t };
-//# sourceMappingURL=cdp-connection-rP1WdnH5.d.ts.map

package/dist/cdp-connection-rP1WdnH5.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cdp-connection-rP1WdnH5.d.ts","names":[],"sources":["../src/mcp/cdp-connection.ts"],"mappings":"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"}

package/dist/cell-BaLvusOl.js

@@ -1,68 +0,0 @@
-import { buildIndicatorExpression } from "./attach-orchestrator-D65KxFy_.js";
-//#region src/test-runner/cell.ts
-/**
-* Injects each key of `globals` into `globalThis` in the page via a single
-* `Runtime.evaluate` call. Must be called BEFORE the first `bundleTestFile`
-* inject — the cell is session-global and applies to all subsequent files.
-*
-* Throws if the CDP evaluate returns an exception.
-*
-* @param conn    - The live CDP connection (relay-attached page).
-* @param globals - Plain-JSON-serialisable key→value map to assign onto `globalThis`.
-*/
-async function injectGlobals(conn, globals) {
-	const expr = `(() => { Object.assign(globalThis, ${JSON.stringify(globals)}); return true; })()`;
-	const result = await conn.send("Runtime.evaluate", {
-		expression: expr,
-		returnByValue: true
-	});
-	if (result.exceptionDetails) {
-		const msg = result.exceptionDetails.exception?.description ?? result.exceptionDetails.text ?? "unknown error";
-		throw new Error(`injectGlobals: Runtime.evaluate threw: ${msg}`);
-	}
-}
-/**
-* Injects (or updates) the "Debugger Connected"/"Debugger Disconnected"
-* on-phone indicator via `Runtime.evaluate` (#730).
-*
-* Uses the same CDP mechanism as {@link injectGlobals} — a single
-* `Runtime.evaluate` round-trip with the expression built by
-* {@link buildIndicatorExpression}. The indicator is a LIVE badge rendered at
-* the bottom-left of the page (position:fixed, safe-area-aware): the badge's
-* controller is idempotent, so calling this again (e.g. right before
-* `close()` with `{ state: 'disconnected' }`) UPDATES the existing badge in
-* place instead of injecting a duplicate.
-*
-* **Isolation**: unlike {@link injectGlobals}, this function NEVER throws to
-* its caller. Injection failure (e.g. page detached during inject, CSS not
-* supported) is swallowed and logged as `console.debug` — the badge is
-* informational UI and must never block attach success or test execution.
-* This is the same fire-and-forget spirit as the in-page console mount in
-* `src/in-app/attach.ts`.
-*
-* Call this ONLY on the manual debug paths (start_attach MCP, devtools-test
-* CLI). Do NOT call on the `run_tests` auto-attach path — the badge
-* would contaminate screenshots, measure_safe_area probes, and DOM snapshots
-* taken during automated measurement runs.
-*
-* SECRET-HANDLING: the injected expression contains no secrets, relay URLs,
-* wss addresses, or TOTP codes — it is pure DOM UI text + enum state built by
-* {@link buildIndicatorExpression}.
-*
-* @param conn - The live CDP connection (relay-attached page).
-* @param opts - Optional overrides forwarded to {@link buildIndicatorExpression}.
-*/
-async function injectDebugIndicator(conn, opts) {
-	try {
-		await conn.send("Runtime.evaluate", {
-			expression: buildIndicatorExpression(opts),
-			returnByValue: true
-		});
-	} catch (err) {
-		console.debug("[@ait-co/devtools] debug indicator inject skipped:", err);
-	}
-}
-//#endregion
-export { injectDebugIndicator, injectGlobals };
-
-//# sourceMappingURL=cell-BaLvusOl.js.map

package/dist/cell-BaLvusOl.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cell-BaLvusOl.js","names":[],"sources":["../src/test-runner/cell.ts"],"sourcesContent":["/**\n * Cell injection utility for the `devtools-test` CLI (issue #684 §4.1).\n *\n * Injects arbitrary globals into the page via `Runtime.evaluate` BEFORE the\n * first test bundle is injected. The injected values are session-global — one\n * call covers all files in the run.\n *\n * The primary use-case is injecting `__AIT_CELL__` (sdkLine/platform) so\n * sdk-example's `aitCapture.ts` picks up the correct test-axis values instead\n * of falling back to `'2.x'`/`'mock'`.\n *\n * devtools does NOT know the shape of `__AIT_CELL__` — it only provides the\n * general injection mechanism. The caller (CLI or MCP auto-attach path) is\n * responsible for constructing the cell object.\n *\n * SECRET-HANDLING: cell values (sdkLine/platform) are not secrets and may be\n * logged at the caller's discretion. This module does NOT log them itself.\n *\n * Node-only. react-free. CdpConnection only.\n */\n\nimport { THROTTLED_ERROR_CODE, THROTTLED_MESSAGE_SUBSTRING } from './throttle.js';\n\n/**\n * `__AIT_PERMS__` key → SDK function name whose `.getPermission()` is probed\n * (devtools#739). This is the exact contract sdk-example#265 consumes — do\n * not rename keys without a coordinated sdk-example update.\n *\n * Each SDK function is reached via `window.__sdk` — the SAME page-global\n * bridge `src/in-app/auto.ts` installs for `call_sdk`/`__sdkCall` (see\n * `src/test-runner/bundle.ts`'s `sdkRedirectPlugin`, which redirects bundled\n * `@apps-in-toss/web-framework` imports to this same object at runtime). The\n * test-runner bundle owns no independent SDK import — `window.__sdk` is a\n * page global regardless of whether a bundle has been injected yet, so this\n * preflight runs standalone via `injectGlobals`'s `Runtime.evaluate`\n * mechanism BEFORE the first bundle, rather than being prepended into\n * `rpc.ts#buildRunTestsExpression`. (Design choice documented in PR #739 —\n * bundle-prepend was the fallback plan if the SDK were only reachable from\n * inside bundle scope, which reality ruled out.)\n */\nconst PERMISSION_PROBE_MAP: Record<string, string> = {\n  clipboardRead: 'getClipboardText',\n  clipboardWrite: 'setClipboardText',\n  album: 'fetchAlbumPhotos',\n  camera: 'openCamera',\n  contacts: 'fetchContacts',\n  location: 'getCurrentLocation',\n};\n\n/**\n * Inter-probe spacing (ms) applied BEFORE every probe after the first\n * (devtools#767). The native per-method bridge rate limit observed\n * 2026-07-10 rejects a SECOND call to the same method within a short window\n * with `APP_BRIDGE_THROTTLED` — the permission preflight's un-paced burst\n * (6 probes fired back-to-back) was the FIRST trigger of that limiter in the\n * wild (only the first probe passed; the remaining 5 came back throttled →\n * `unavailable`, cascading into skipped `__AIT_PERMS__`-branching tests).\n * Sequential-with-spacing is cheap insurance even though each probe targets a\n * DIFFERENT method — the limiter's exact scope (per-method vs. a shared\n * bridge-wide window) was not reverse-engineered (explicitly out of scope,\n * devtools#767) so spacing every probe is the conservative choice.\n */\nconst PROBE_INTER_CALL_DELAY_MS = 250;\n\n/**\n * Backoff delays (ms) between retry attempts when a probe is throttled. Its\n * `.length` IS the max retry count (devtools#767: \"최대 2회 재시도\") — the\n * generated page-side expression below derives `attempt < backoff.length`\n * from this same array (via `backoffArray`), so there is a single source for\n * both the delay ladder and the retry count; no separate max-retries\n * constant is kept in this module (unlike `runtime.ts`'s `TEST_MAX_RETRIES`,\n * which IS consumed directly by a Node-side loop condition).\n */\nconst PROBE_RETRY_BACKOFF_MS = [500, 1000] as const;\n\n/**\n * Non-fatal bound for the permission preflight `Runtime.evaluate` round-trip\n * (devtools#767: raised from the pre-pacing 10s to cover the new sequential +\n * backoff time budget).\n *\n * Worst-case budget with 6 probes, each requiring the full retry ladder:\n *   - inter-probe spacing: only BEFORE probes 2‑6 (none before the first) =\n *     5 × {@link PROBE_INTER_CALL_DELAY_MS} = 1 250ms\n *   - per-probe backoff (both retries taken): 6 × (500 + 1000) = 9 000ms\n *   - probe round-trips themselves (headroom, not just the sleeps): ~4 500ms\n *   total ≈ 14 750ms, rounded up to a clean 20 000ms for headroom.\n */\nexport const PERMISSION_PREFLIGHT_TIMEOUT_MS = 20_000;\n\n/**\n * Builds the `Runtime.evaluate` expression for the permission-state preflight\n * (devtools#739). Evaluated ONCE per relay session, before the first test\n * bundle is injected (see `relay-worker.ts#runTestFilesOverRelay`).\n *\n * For each entry in {@link PERMISSION_PROBE_MAP}, probes\n * `window.__sdk.<fn>.getPermission()` — a NON-blocking query (never\n * `openPermissionDialog`/`requestPermission`, which open native UI) — and\n * assigns the resolved `'allowed'|'denied'|'notDetermined'` status to\n * `globalThis.__AIT_PERMS__[<key>]`. A probe that is absent, throws, or\n * rejects resolves to `'unavailable'` — this expression never throws to its\n * caller, and a single slow/broken permission must not fail the others (each\n * probe is awaited independently, not short-circuited).\n *\n * devtools#767: probes run SEQUENTIALLY (not a parallel burst) with a\n * {@link PROBE_INTER_CALL_DELAY_MS} gap before each probe after the first, and\n * a probe that comes back `APP_BRIDGE_THROTTLED` (native per-method bridge\n * rate limit) is retried up to {@link PROBE_RETRY_BACKOFF_MS}`.length` times\n * with the same {@link PROBE_RETRY_BACKOFF_MS} ladder before falling back to\n * `'unavailable'`.\n * The THROTTLED detection mirrors `throttle.ts#isThrottledError` inline (this\n * expression is raw JS text evaluated via CDP, not an esbuild-bundled module,\n * so it cannot statically `import` that helper) — kept in sync by checking\n * BOTH `e.code === 'APP_BRIDGE_THROTTLED'` and a message substring match, the\n * same two signals `isThrottledError` checks.\n *\n * devtools#767 acceptance criteria 2 (\"3.x run duration은 유의미하게 늘지 않음,\n * pacing은 opt-in 또는 throttle-adaptive\") requires this NOT be an unconditional\n * cost — `pace` (default `true`, matching the pre-existing sequential+spacing\n * behavior for 2.x/unknown cells) lets a 3.x caller skip BOTH the inter-probe\n * `sleep(250)` AND the retry backoff ladder, since `APP_BRIDGE_THROTTLED` is a\n * 2.x-bridge-only limiter (see `--pace`'s own doc in `cli.ts`: \"3.x cells are\n * unaffected by that limiter\"). When `pace` is `false`, probes still run\n * sequentially (never a parallel burst) but back-to-back with no added delay,\n * and a THROTTLED result resolves to `'unavailable'` immediately (no retry) —\n * this matches the 3.x runtime, which never emits `APP_BRIDGE_THROTTLED`.\n *\n * Tests (sdk-example#265) read `globalThis.__AIT_PERMS__` to branch\n * deterministically per permission state instead of blanket outcome-branching.\n *\n * Returns a JSON-serialised string (the same double-serialisation pattern\n * `rpc.ts#buildRunTestsExpression` uses) rather than relying on CDP\n * `returnByValue` structural fidelity for a plain object across the Chii\n * relay — the Node side re-parses via `JSON.parse`.\n *\n * Pure function — no I/O, no CDP call. Callers pass the returned string to\n * `Runtime.evaluate`.\n *\n * @param pace - Defaults to `true` (today's sequential+spacing+backoff\n *   behavior). Pass `false` for a 3.x cell to skip the inter-probe delay and\n *   the THROTTLED retry ladder entirely.\n */\nexport function buildPermissionPreflightExpression(pace = true): string {\n  const probeKeys = Object.keys(PERMISSION_PROBE_MAP);\n  const probeCalls = probeKeys\n    .map((key, i) => {\n      const fnName = PERMISSION_PROBE_MAP[key];\n      // Every probe after the first waits PROBE_INTER_CALL_DELAY_MS first —\n      // sequential execution with spacing, never a parallel burst. Skipped\n      // entirely when `pace` is false (3.x cell — no native limiter to dodge).\n      const spacing = i === 0 || !pace ? '' : `    await sleep(${PROBE_INTER_CALL_DELAY_MS});\\n`;\n      return (\n        `${spacing}` +\n        `    result[${JSON.stringify(key)}] = await probeWithRetry(${JSON.stringify(fnName)});`\n      );\n    })\n    .join('\\n');\n\n  // 3.x cells never emit APP_BRIDGE_THROTTLED (it's a 2.x-bridge-only native\n  // limiter) — an empty backoff ladder makes `probeWithRetry` resolve any\n  // throw (throttled or not) to 'unavailable' on the FIRST attempt, with zero\n  // retry sleeps, satisfying devtools#767 acceptance criteria 2.\n  const backoffArray = pace ? `[${PROBE_RETRY_BACKOFF_MS.join(',')}]` : '[]';\n\n  return (\n    `(async () => {` +\n    `  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));` +\n    `  const isThrottled = (e) => {` +\n    `    if (!e) return false;` +\n    `    if (e.code === ${JSON.stringify(THROTTLED_ERROR_CODE)}) return true;` +\n    `    const msg = typeof e.message === 'string' ? e.message : '';` +\n    `    return msg.indexOf(${JSON.stringify(THROTTLED_MESSAGE_SUBSTRING)}) !== -1;` +\n    `  };` +\n    `  const probe = async (fnName) => {` +\n    `    const fn = globalThis.__sdk && globalThis.__sdk[fnName];` +\n    `    if (!fn || typeof fn.getPermission !== 'function') return { ok: true, value: 'unavailable' };` +\n    `    const status = await fn.getPermission();` +\n    `    if (status === 'allowed' || status === 'denied' || status === 'notDetermined') return { ok: true, value: status };` +\n    `    return { ok: true, value: 'unavailable' };` +\n    `  };` +\n    // probeWithRetry: up to PROBE_RETRY_BACKOFF_MS.length retries on THROTTLED,\n    // backing off per PROBE_RETRY_BACKOFF_MS. Any OTHER throw (or a\n    // non-throttled outcome) resolves to 'unavailable' immediately — only\n    // THROTTLED gets a retry.\n    `  const backoff = ${backoffArray};` +\n    `  const probeWithRetry = async (fnName) => {` +\n    `    for (let attempt = 0; attempt <= backoff.length; attempt++) {` +\n    `      try {` +\n    `        const r = await probe(fnName);` +\n    `        return r.value;` +\n    `      } catch (e) {` +\n    `        if (isThrottled(e) && attempt < backoff.length) {` +\n    `          await sleep(backoff[attempt]);` +\n    `          continue;` +\n    `        }` +\n    `        return 'unavailable';` +\n    `      }` +\n    `    }` +\n    `    return 'unavailable';` +\n    `  };` +\n    `  const result = {};` +\n    `${probeCalls}\\n` +\n    `  globalThis.__AIT_PERMS__ = result;` +\n    `  return JSON.stringify(result);` +\n    `})()`\n  );\n}\n\n/**\n * Runs the permission-state preflight (devtools#739) via `Runtime.evaluate`\n * and returns the collected `__AIT_PERMS__` map, or `undefined` when the\n * preflight itself failed or timed out.\n *\n * NON-FATAL by design: any failure (CDP exception, timeout, page-side throw)\n * is caught here, logged as ONE stderr line, and swallowed — the whole test\n * run must proceed even when the preflight cannot complete (e.g. `window.__sdk`\n * not yet installed, or a page navigation mid-attach). Callers that want the\n * result for report provenance (`RelayRunReport.preflight`) get `undefined`\n * in that case, which downstream code treats the same as \"not run\".\n *\n * SECRET-HANDLING: no relay/wss/secret values are read or logged; only\n * permission-state strings cross this boundary.\n *\n * @param conn      - The live CDP connection (relay-attached page).\n * @param timeoutMs - Round-trip bound. Defaults to {@link PERMISSION_PREFLIGHT_TIMEOUT_MS}.\n * @param pace      - Forwarded to {@link buildPermissionPreflightExpression}.\n *   Defaults to `true` (today's sequential+spacing+backoff behavior, correct\n *   for 2.x/unknown cells). Callers that know the cell is 3.x should pass\n *   `false` — devtools#767 acceptance criteria 2 requires 3.x run duration not\n *   grow from this preflight, and 3.x never hits the 2.x-only\n *   `APP_BRIDGE_THROTTLED` limiter this pacing exists to dodge.\n */\nexport async function runPermissionPreflight(\n  conn: CdpConnection,\n  timeoutMs = PERMISSION_PREFLIGHT_TIMEOUT_MS,\n  pace = true,\n): Promise<Record<string, string> | undefined> {\n  const TIMEOUT_SENTINEL = Symbol('permission-preflight-timeout');\n  const timeoutPromise = new Promise<typeof TIMEOUT_SENTINEL>((resolve) =>\n    setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs),\n  );\n\n  try {\n    const evalPromise = conn.send('Runtime.evaluate', {\n      expression: buildPermissionPreflightExpression(pace),\n      returnByValue: true,\n      awaitPromise: true,\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      process.stderr.write(\n        `test-runner: permission preflight timed out after ${timeoutMs}ms — proceeding with __AIT_PERMS__ unset\\n`,\n      );\n      return undefined;\n    }\n\n    if (raceResult.v.exceptionDetails) {\n      process.stderr.write(\n        'test-runner: permission preflight threw — proceeding with __AIT_PERMS__ unset\\n',\n      );\n      return undefined;\n    }\n\n    const rawValue = raceResult.v.result.value;\n    if (typeof rawValue !== 'string') return undefined;\n    const parsed: unknown = JSON.parse(rawValue);\n    if (typeof parsed !== 'object' || parsed === null) return undefined;\n    return parsed as Record<string, string>;\n  } catch (e) {\n    process.stderr.write(\n      `test-runner: permission preflight failed (${\n        e instanceof Error ? e.message : String(e)\n      }) — proceeding with __AIT_PERMS__ unset\\n`,\n    );\n    return undefined;\n  }\n}\n\nimport { buildIndicatorExpression } from '../mcp/attach-orchestrator.js';\nimport type { CdpConnection } from '../mcp/cdp-connection.js';\n\n/**\n * Injects each key of `globals` into `globalThis` in the page via a single\n * `Runtime.evaluate` call. Must be called BEFORE the first `bundleTestFile`\n * inject — the cell is session-global and applies to all subsequent files.\n *\n * Throws if the CDP evaluate returns an exception.\n *\n * @param conn    - The live CDP connection (relay-attached page).\n * @param globals - Plain-JSON-serialisable key→value map to assign onto `globalThis`.\n */\nexport async function injectGlobals(\n  conn: CdpConnection,\n  globals: Record<string, unknown>,\n): Promise<void> {\n  // JSON.stringify is safe here: globals values are plain data (sdkLine/platform\n  // strings or simple objects). If a value is not JSON-serialisable this throws\n  // at call time, which surfaces the error early and clearly.\n  const expr = `(() => { Object.assign(globalThis, ${JSON.stringify(globals)}); return true; })()`;\n  const result = await conn.send('Runtime.evaluate', { expression: expr, returnByValue: true });\n  if (result.exceptionDetails) {\n    const msg =\n      result.exceptionDetails.exception?.description ??\n      result.exceptionDetails.text ??\n      'unknown error';\n    throw new Error(`injectGlobals: Runtime.evaluate threw: ${msg}`);\n  }\n}\n\n/**\n * Injects (or updates) the \"Debugger Connected\"/\"Debugger Disconnected\"\n * on-phone indicator via `Runtime.evaluate` (#730).\n *\n * Uses the same CDP mechanism as {@link injectGlobals} — a single\n * `Runtime.evaluate` round-trip with the expression built by\n * {@link buildIndicatorExpression}. The indicator is a LIVE badge rendered at\n * the bottom-left of the page (position:fixed, safe-area-aware): the badge's\n * controller is idempotent, so calling this again (e.g. right before\n * `close()` with `{ state: 'disconnected' }`) UPDATES the existing badge in\n * place instead of injecting a duplicate.\n *\n * **Isolation**: unlike {@link injectGlobals}, this function NEVER throws to\n * its caller. Injection failure (e.g. page detached during inject, CSS not\n * supported) is swallowed and logged as `console.debug` — the badge is\n * informational UI and must never block attach success or test execution.\n * This is the same fire-and-forget spirit as the in-page console mount in\n * `src/in-app/attach.ts`.\n *\n * Call this ONLY on the manual debug paths (start_attach MCP, devtools-test\n * CLI). Do NOT call on the `run_tests` auto-attach path — the badge\n * would contaminate screenshots, measure_safe_area probes, and DOM snapshots\n * taken during automated measurement runs.\n *\n * SECRET-HANDLING: the injected expression contains no secrets, relay URLs,\n * wss addresses, or TOTP codes — it is pure DOM UI text + enum state built by\n * {@link buildIndicatorExpression}.\n *\n * @param conn - The live CDP connection (relay-attached page).\n * @param opts - Optional overrides forwarded to {@link buildIndicatorExpression}.\n */\nexport async function injectDebugIndicator(\n  conn: CdpConnection,\n  opts?: { label?: string; disconnectedLabel?: string; state?: 'attached' | 'disconnected' },\n): Promise<void> {\n  try {\n    await conn.send('Runtime.evaluate', {\n      expression: buildIndicatorExpression(opts),\n      returnByValue: true,\n    });\n  } catch (err) {\n    // Badge injection is informational UI — swallow and log; never propagate.\n    console.debug('[@ait-co/devtools] debug indicator inject skipped:', err);\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAuSA,eAAsB,cACpB,MACA,SACe;CAIf,MAAM,OAAO,sCAAsC,KAAK,UAAU,QAAQ,CAAC;CAC3E,MAAM,SAAS,MAAM,KAAK,KAAK,oBAAoB;EAAE,YAAY;EAAM,eAAe;EAAM,CAAC;AAC7F,KAAI,OAAO,kBAAkB;EAC3B,MAAM,MACJ,OAAO,iBAAiB,WAAW,eACnC,OAAO,iBAAiB,QACxB;AACF,QAAM,IAAI,MAAM,0CAA0C,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCpE,eAAsB,qBACpB,MACA,MACe;AACf,KAAI;AACF,QAAM,KAAK,KAAK,oBAAoB;GAClC,YAAY,yBAAyB,KAAK;GAC1C,eAAe;GAChB,CAAC;UACK,KAAK;AAEZ,UAAQ,MAAM,sDAAsD,IAAI"}