@ait-co/devtools 0.1.135 → 0.1.137

package/dist/test-runner/bridge-stub.d.ts

@@ -0,0 +1,125 @@
+//#region src/test-runner/bridge-stub.d.ts
+/**
+ * Bridge-stub interceptor for env3 blocking-UI SDK calls (devtools#740, DT-2).
+ *
+ * `--manual-blocking` (devtools#741) lets a human tap through native-UI SDK
+ * calls (fullscreen ads, permission dialogs, the save-file share sheet) so
+ * their real device behaviour can be captured. That capture (sdk-example
+ * run11, 2026-07-05, 2.x/iOS) is the ground truth this module replays: an
+ * opt-in interceptor that sits BETWEEN the test bundle and the real native
+ * bridge (`window.__sdk`, installed by `src/in-app/auto.ts`) and answers a
+ * fixed allowlist of blocking calls with fixture-shaped responses instead of
+ * forwarding them to native UI. This lets the SAME manual-tagged test files
+ * run unattended, so their assertions (denied-permission error shape,
+ * `NO_PERMISSION` envelope, etc.) become part of a CI-checkable contract
+ * instead of only ever running with a human present.
+ *
+ * HONESTY CONTRACT (devtools#740): a stubbed run is NOT env3 in the pure
+ * sense — it is a HYBRID cell (real device + real WebView + real bridge
+ * transport for every OTHER call, but a synthetic answer for the handful of
+ * calls in {@link STUB_REGISTRY}). Every artifact produced under this mode
+ * MUST be provenance-stamped (`cell.bridgeStub: true`, see `report.ts`) and
+ * MUST NOT be merged into the same file/mode as an unattended baseline run.
+ * A stubbed PASS proves "the SDK's rejection/resolution path behaves as
+ * fixture-shaped" — it does NOT prove the real native dialog/sheet still
+ * looks or behaves a given way on-device. Real behavior re-verification stays
+ * on `--manual-blocking` (DT-3) — this module never replaces it, only adds an
+ * unattended CHECK on top of what it captured.
+ *
+ * DRIFT AVOIDANCE: fixtures are frozen snapshots of a real capture. If the
+ * native SDK's error shape ever changes, only a fresh `--manual-blocking` run
+ * (DT-3) can tell you — this module has no way to detect drift on its own.
+ * Treat {@link STUB_REGISTRY} as "last known native truth", not as a
+ * specification devtools owns.
+ *
+ * Runs entirely on the PAGE side (browser-compatible, no Node APIs) — this
+ * file is bundled into the injected IIFE by `bundle.ts`'s `sdkRedirectPlugin`,
+ * mirroring how `runtime.ts` is bundled. It is imported ONLY from the
+ * test-runner (never from `sdk-example/src` — boilerplate cleanliness,
+ * umbrella §1.4: this is maintainer/runner infrastructure, not something a
+ * mini-app developer's shipped code should carry).
+ *
+ * SECRET-HANDLING: fixtures below are hand-derived summaries of the captured
+ * shapes (see per-entry doc comments citing the source scenario) — no device
+ * identifiers, tunnel hosts, relay URLs, or auth codes are embedded anywhere
+ * in this file.
+ */
+/**
+ * The exact shape a rejected native bridge call takes on iOS/2.x (and,
+ * empirically, unchanged across the manual captures this module replays).
+ * Mirrors the `errorKeys` observed in the ground-truth capture:
+ * `['name', 'code', 'userInfo', 'moduleName', '__isError']`.
+ */
+interface NativeBridgeErrorShape {
+  name: string;
+  code: string;
+  message: string;
+  userInfo: Record<string, unknown>;
+  moduleName: string;
+  __isError: true;
+}
+/**
+ * One blocking-call stub entry. `kind` distinguishes the two native calling
+ * conventions observed in the mock/real SDK:
+ *   - `'promise'` — the call returns a Promise the stub resolves/rejects
+ *     (`openPermissionDialog`, `requestPermission`, `saveBase64Data`).
+ *   - `'event'` — the call takes `{ onEvent, onError }` callbacks and returns
+ *     a cleanup function (`showFullScreenAd`) — the native fullscreen-ad flow
+ *     never resolves a Promise; it fires events instead.
+ */
+type StubEntry = {
+  kind: 'promise'; /** Pure factory so each call gets a fresh value/error (no shared mutable state). */
+  resolve: (args: unknown) => unknown;
+} | {
+  kind: 'event';
+  /**
+   * Invoked synchronously with the same `args` the real call would
+   * receive; calls `args.onEvent`/`args.onError` per the fixture and
+   * returns a no-op cleanup function.
+   */
+  run: (args: {
+    onEvent: (e: unknown) => void;
+    onError: (e: unknown) => void;
+  }) => () => void;
+};
+/**
+ * Fixture-shaped default responses for the blocking-UI APIs named in
+ * devtools#740 as the smallest viable surface: ads `show*`, permissions
+ * `openPermissionDialog`/`requestPermission`, storage `saveBase64Data`.
+ *
+ * Each entry cites the exact `.ait-capture` record (sdk-example run11,
+ * 2026-07-05, 2.x/iOS) it was derived from — see the PR body for the full
+ * source table. Only the REPRESENTATIVE shape is kept (one success + one
+ * native-error per API where the capture contains both); this is a fixed v1
+ * default set, not a scenario-selectable registry — see `resolveStubOutcome`
+ * for how a test can still opt into the error branch.
+ */
+declare const STUB_REGISTRY: Record<string, StubEntry>;
+/** The allowlisted API names {@link STUB_REGISTRY} can intercept. */
+type StubbableApiName = keyof typeof STUB_REGISTRY;
+/**
+ * Wraps a `window.__sdk`-shaped bridge object so that calls to any name in
+ * {@link STUB_REGISTRY} are answered from the fixture instead of forwarded to
+ * `sdk`. Every other property (including non-stubbed functions) passes
+ * through UNCHANGED — this is a targeted intercept, not a blanket mock.
+ *
+ * Returns `sdk` itself, untouched, when `enabled` is false — the exact
+ * object identity is preserved so the zero-diff-when-off contract holds even
+ * under strict-equality checks in a caller.
+ *
+ * @param sdk     - The real bridge namespace object (`window.__sdk`).
+ * @param enabled - Gate — mirrors the `--stub-blocking` CLI flag /
+ *                  `__AIT_STUB_BLOCKING__` page global. Defaults to `false`.
+ */
+declare function wrapSdkWithStub(sdk: Record<string, unknown>, enabled: boolean): Record<string, unknown>;
+/**
+ * Reads the page-global stub-blocking gate. Mirrors the pattern
+ * `runtime.ts`/`cell.ts` use for `__AIT_CELL__`/`__AIT_PERMS__` — a plain
+ * `globalThis` property injected via `injectGlobals` (Node side, `cell.ts`)
+ * BEFORE the first test bundle runs. Absent/false = disabled (default),
+ * matching every other opt-in flag in this runner.
+ */
+declare function isStubBlockingEnabled(): boolean;
+//#endregion
+export { NativeBridgeErrorShape, STUB_REGISTRY, StubEntry, StubbableApiName, isStubBlockingEnabled, wrapSdkWithStub };
+//# sourceMappingURL=bridge-stub.d.ts.map

package/dist/test-runner/bridge-stub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-stub.d.ts","names":[],"sources":["../../src/test-runner/bridge-stub.ts"],"mappings":";;AAoDA;;;;;;;;;;;;;AAkCA;;;;;;;;;;;;;;;;AA4BA;;;;;AAgDA;;;;;AAgBA;;;;;;;;;;AAoCA;UAlKiB,sBAAA;EACf,IAAA;EACA,IAAA;EACA,OAAA;EACA,QAAA,EAAU,MAAA;EACV,UAAA;EACA,SAAA;AAAA;;;;;;;;;;KA4BU,SAAA;EAEN,IAAA;EAEA,OAAA,GAAU,IAAA;AAAA;EAGV,IAAA;;;;;;EAMA,GAAA,GAAM,IAAA;IAAQ,OAAA,GAAU,CAAA;IAAqB,OAAA,GAAU,CAAA;EAAA;AAAA;;;;;;;;;;;;;cAehD,aAAA,EAAe,MAAA,SAAe,SAAA;;KAgD/B,gBAAA,gBAAgC,aAAA;;;;;;;;;;;;;;;iBAgB5B,eAAA,CACd,GAAA,EAAK,MAAA,mBACL,OAAA,YACC,MAAA;;;;;;;;iBAiCa,qBAAA,CAAA"}

package/dist/test-runner/bridge-stub.js

@@ -0,0 +1,92 @@
+//#region src/test-runner/bridge-stub.ts
+/** Builds a {@link NativeBridgeErrorShape}-compatible `Error` instance. */
+function makeNativeError(code, message, moduleName, userInfo = {}) {
+	const err = new Error(message);
+	err.name = "Error";
+	err.code = code;
+	err.userInfo = userInfo;
+	err.moduleName = moduleName;
+	err.__isError = true;
+	return err;
+}
+/**
+* Fixture-shaped default responses for the blocking-UI APIs named in
+* devtools#740 as the smallest viable surface: ads `show*`, permissions
+* `openPermissionDialog`/`requestPermission`, storage `saveBase64Data`.
+*
+* Each entry cites the exact `.ait-capture` record (sdk-example run11,
+* 2026-07-05, 2.x/iOS) it was derived from — see the PR body for the full
+* source table. Only the REPRESENTATIVE shape is kept (one success + one
+* native-error per API where the capture contains both); this is a fixed v1
+* default set, not a scenario-selectable registry — see `resolveStubOutcome`
+* for how a test can still opt into the error branch.
+*/
+const STUB_REGISTRY = {
+	openPermissionDialog: {
+		kind: "promise",
+		resolve: () => "allowed"
+	},
+	requestPermission: {
+		kind: "promise",
+		resolve: () => {
+			throw makeNativeError("NO_PERMISSION", "No permission", "RNPermissions");
+		}
+	},
+	saveBase64Data: {
+		kind: "promise",
+		resolve: () => void 0
+	},
+	showFullScreenAd: {
+		kind: "event",
+		run: (args) => {
+			const err = /* @__PURE__ */ new Error("광고가 로드 중이거나 준비되지 않았습니다");
+			err.code = "1006";
+			args.onError(err);
+			return () => {};
+		}
+	}
+};
+/**
+* Wraps a `window.__sdk`-shaped bridge object so that calls to any name in
+* {@link STUB_REGISTRY} are answered from the fixture instead of forwarded to
+* `sdk`. Every other property (including non-stubbed functions) passes
+* through UNCHANGED — this is a targeted intercept, not a blanket mock.
+*
+* Returns `sdk` itself, untouched, when `enabled` is false — the exact
+* object identity is preserved so the zero-diff-when-off contract holds even
+* under strict-equality checks in a caller.
+*
+* @param sdk     - The real bridge namespace object (`window.__sdk`).
+* @param enabled - Gate — mirrors the `--stub-blocking` CLI flag /
+*                  `__AIT_STUB_BLOCKING__` page global. Defaults to `false`.
+*/
+function wrapSdkWithStub(sdk, enabled) {
+	if (!enabled) return sdk;
+	return new Proxy(sdk, { get(target, prop, receiver) {
+		if (typeof prop === "string" && Object.hasOwn(STUB_REGISTRY, prop)) return buildStubFunction(prop);
+		return Reflect.get(target, prop, receiver);
+	} });
+}
+/** Builds the callable replacement for a single stubbed API name. */
+function buildStubFunction(name) {
+	const entry = STUB_REGISTRY[name];
+	if (entry.kind === "promise") return async (...args) => entry.resolve(args[0]);
+	return (...args) => {
+		const callArgs = args[0];
+		return entry.run(callArgs);
+	};
+}
+/**
+* Reads the page-global stub-blocking gate. Mirrors the pattern
+* `runtime.ts`/`cell.ts` use for `__AIT_CELL__`/`__AIT_PERMS__` — a plain
+* `globalThis` property injected via `injectGlobals` (Node side, `cell.ts`)
+* BEFORE the first test bundle runs. Absent/false = disabled (default),
+* matching every other opt-in flag in this runner.
+*/
+function isStubBlockingEnabled() {
+	return globalThis.__AIT_STUB_BLOCKING__ === true;
+}
+//#endregion
+export { STUB_REGISTRY, isStubBlockingEnabled, wrapSdkWithStub };
+
+//# sourceMappingURL=bridge-stub.js.map

package/dist/test-runner/bridge-stub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-stub.js","names":[],"sources":["../../src/test-runner/bridge-stub.ts"],"sourcesContent":["/**\n * Bridge-stub interceptor for env3 blocking-UI SDK calls (devtools#740, DT-2).\n *\n * `--manual-blocking` (devtools#741) lets a human tap through native-UI SDK\n * calls (fullscreen ads, permission dialogs, the save-file share sheet) so\n * their real device behaviour can be captured. That capture (sdk-example\n * run11, 2026-07-05, 2.x/iOS) is the ground truth this module replays: an\n * opt-in interceptor that sits BETWEEN the test bundle and the real native\n * bridge (`window.__sdk`, installed by `src/in-app/auto.ts`) and answers a\n * fixed allowlist of blocking calls with fixture-shaped responses instead of\n * forwarding them to native UI. This lets the SAME manual-tagged test files\n * run unattended, so their assertions (denied-permission error shape,\n * `NO_PERMISSION` envelope, etc.) become part of a CI-checkable contract\n * instead of only ever running with a human present.\n *\n * HONESTY CONTRACT (devtools#740): a stubbed run is NOT env3 in the pure\n * sense — it is a HYBRID cell (real device + real WebView + real bridge\n * transport for every OTHER call, but a synthetic answer for the handful of\n * calls in {@link STUB_REGISTRY}). Every artifact produced under this mode\n * MUST be provenance-stamped (`cell.bridgeStub: true`, see `report.ts`) and\n * MUST NOT be merged into the same file/mode as an unattended baseline run.\n * A stubbed PASS proves \"the SDK's rejection/resolution path behaves as\n * fixture-shaped\" — it does NOT prove the real native dialog/sheet still\n * looks or behaves a given way on-device. Real behavior re-verification stays\n * on `--manual-blocking` (DT-3) — this module never replaces it, only adds an\n * unattended CHECK on top of what it captured.\n *\n * DRIFT AVOIDANCE: fixtures are frozen snapshots of a real capture. If the\n * native SDK's error shape ever changes, only a fresh `--manual-blocking` run\n * (DT-3) can tell you — this module has no way to detect drift on its own.\n * Treat {@link STUB_REGISTRY} as \"last known native truth\", not as a\n * specification devtools owns.\n *\n * Runs entirely on the PAGE side (browser-compatible, no Node APIs) — this\n * file is bundled into the injected IIFE by `bundle.ts`'s `sdkRedirectPlugin`,\n * mirroring how `runtime.ts` is bundled. It is imported ONLY from the\n * test-runner (never from `sdk-example/src` — boilerplate cleanliness,\n * umbrella §1.4: this is maintainer/runner infrastructure, not something a\n * mini-app developer's shipped code should carry).\n *\n * SECRET-HANDLING: fixtures below are hand-derived summaries of the captured\n * shapes (see per-entry doc comments citing the source scenario) — no device\n * identifiers, tunnel hosts, relay URLs, or auth codes are embedded anywhere\n * in this file.\n */\n\n/**\n * The exact shape a rejected native bridge call takes on iOS/2.x (and,\n * empirically, unchanged across the manual captures this module replays).\n * Mirrors the `errorKeys` observed in the ground-truth capture:\n * `['name', 'code', 'userInfo', 'moduleName', '__isError']`.\n */\nexport interface NativeBridgeErrorShape {\n  name: string;\n  code: string;\n  message: string;\n  userInfo: Record<string, unknown>;\n  moduleName: string;\n  __isError: true;\n}\n\n/** Builds a {@link NativeBridgeErrorShape}-compatible `Error` instance. */\nfunction makeNativeError(\n  code: string,\n  message: string,\n  moduleName: string,\n  userInfo: Record<string, unknown> = {},\n): Error & NativeBridgeErrorShape {\n  const err = new Error(message) as Error & NativeBridgeErrorShape;\n  err.name = 'Error';\n  err.code = code;\n  err.userInfo = userInfo;\n  err.moduleName = moduleName;\n  err.__isError = true;\n  return err;\n}\n\n/**\n * One blocking-call stub entry. `kind` distinguishes the two native calling\n * conventions observed in the mock/real SDK:\n *   - `'promise'` — the call returns a Promise the stub resolves/rejects\n *     (`openPermissionDialog`, `requestPermission`, `saveBase64Data`).\n *   - `'event'` — the call takes `{ onEvent, onError }` callbacks and returns\n *     a cleanup function (`showFullScreenAd`) — the native fullscreen-ad flow\n *     never resolves a Promise; it fires events instead.\n */\nexport type StubEntry =\n  | {\n      kind: 'promise';\n      /** Pure factory so each call gets a fresh value/error (no shared mutable state). */\n      resolve: (args: unknown) => unknown;\n    }\n  | {\n      kind: 'event';\n      /**\n       * Invoked synchronously with the same `args` the real call would\n       * receive; calls `args.onEvent`/`args.onError` per the fixture and\n       * returns a no-op cleanup function.\n       */\n      run: (args: { onEvent: (e: unknown) => void; onError: (e: unknown) => void }) => () => void;\n    };\n\n/**\n * Fixture-shaped default responses for the blocking-UI APIs named in\n * devtools#740 as the smallest viable surface: ads `show*`, permissions\n * `openPermissionDialog`/`requestPermission`, storage `saveBase64Data`.\n *\n * Each entry cites the exact `.ait-capture` record (sdk-example run11,\n * 2026-07-05, 2.x/iOS) it was derived from — see the PR body for the full\n * source table. Only the REPRESENTATIVE shape is kept (one success + one\n * native-error per API where the capture contains both); this is a fixed v1\n * default set, not a scenario-selectable registry — see `resolveStubOutcome`\n * for how a test can still opt into the error branch.\n */\nexport const STUB_REGISTRY: Record<string, StubEntry> = {\n  // Source: permissions.2.x.ios.json — scenario \"manual-native-dialog-camera\"\n  // (outcome: resolved, value: 'allowed'). The capture's own resolved value\n  // was a bare string, not an object — mirrored verbatim.\n  openPermissionDialog: {\n    kind: 'promise',\n    resolve: () => 'allowed',\n  },\n\n  // Source: permissions.2.x.ios.json — scenario\n  // \"manual-native-request-geolocation\" (outcome: rejected, isNativeShape:\n  // true, errorCode: 'NO_PERMISSION', errorMessage: 'No permission'). This is\n  // the exact envelope DT-2's issue body calls out (\"requestPermission→\n  // 'denied' 스텁\") — the native denial path, not a synthetic message.\n  requestPermission: {\n    kind: 'promise',\n    resolve: () => {\n      throw makeNativeError('NO_PERMISSION', 'No permission', 'RNPermissions');\n    },\n  },\n\n  // Source: storage.2.x.ios.json — scenario \"manual-happy-varied-mime-png\"\n  // (outcome: resolved, returnType: 'undefined') — the real share-sheet call\n  // resolves with no value on success.\n  saveBase64Data: {\n    kind: 'promise',\n    resolve: () => undefined,\n  },\n\n  // Source: ads.2.x.ios.json — scenario \"manual-show\" (outcome: rejected,\n  // errorCode: '1006', errorMessage: '광고가 로드 중이거나 준비되지 않았습니다').\n  // showFullScreenAd never resolves/rejects a Promise on the real bridge — it\n  // reports outcomes via onEvent/onError, so the representative capture\n  // outcome is replayed as an onError call using the SAME error shape family\n  // (isNativeShape: false in the capture — a plain Error, not the\n  // name/code/userInfo/moduleName envelope).\n  showFullScreenAd: {\n    kind: 'event',\n    run: (args) => {\n      const err = new Error('광고가 로드 중이거나 준비되지 않았습니다') as Error & { code: string };\n      err.code = '1006';\n      args.onError(err);\n      return () => {};\n    },\n  },\n};\n\n/** The allowlisted API names {@link STUB_REGISTRY} can intercept. */\nexport type StubbableApiName = keyof typeof STUB_REGISTRY;\n\n/**\n * Wraps a `window.__sdk`-shaped bridge object so that calls to any name in\n * {@link STUB_REGISTRY} are answered from the fixture instead of forwarded to\n * `sdk`. Every other property (including non-stubbed functions) passes\n * through UNCHANGED — this is a targeted intercept, not a blanket mock.\n *\n * Returns `sdk` itself, untouched, when `enabled` is false — the exact\n * object identity is preserved so the zero-diff-when-off contract holds even\n * under strict-equality checks in a caller.\n *\n * @param sdk     - The real bridge namespace object (`window.__sdk`).\n * @param enabled - Gate — mirrors the `--stub-blocking` CLI flag /\n *                  `__AIT_STUB_BLOCKING__` page global. Defaults to `false`.\n */\nexport function wrapSdkWithStub(\n  sdk: Record<string, unknown>,\n  enabled: boolean,\n): Record<string, unknown> {\n  if (!enabled) return sdk;\n\n  return new Proxy(sdk, {\n    get(target, prop, receiver) {\n      if (typeof prop === 'string' && Object.hasOwn(STUB_REGISTRY, prop)) {\n        return buildStubFunction(prop);\n      }\n      return Reflect.get(target, prop, receiver);\n    },\n  });\n}\n\n/** Builds the callable replacement for a single stubbed API name. */\nfunction buildStubFunction(name: string): (...args: unknown[]) => unknown {\n  const entry = STUB_REGISTRY[name];\n  if (entry.kind === 'promise') {\n    return async (...args: unknown[]) => entry.resolve(args[0]);\n  }\n  // 'event' kind: (args: { onEvent, onError, ... }) => cleanup\n  return (...args: unknown[]) => {\n    const callArgs = args[0] as { onEvent: (e: unknown) => void; onError: (e: unknown) => void };\n    return entry.run(callArgs);\n  };\n}\n\n/**\n * Reads the page-global stub-blocking gate. Mirrors the pattern\n * `runtime.ts`/`cell.ts` use for `__AIT_CELL__`/`__AIT_PERMS__` — a plain\n * `globalThis` property injected via `injectGlobals` (Node side, `cell.ts`)\n * BEFORE the first test bundle runs. Absent/false = disabled (default),\n * matching every other opt-in flag in this runner.\n */\nexport function isStubBlockingEnabled(): boolean {\n  return (globalThis as { __AIT_STUB_BLOCKING__?: boolean }).__AIT_STUB_BLOCKING__ === true;\n}\n"],"mappings":";;AA8DA,SAAS,gBACP,MACA,SACA,YACA,WAAoC,EAAE,EACN;CAChC,MAAM,MAAM,IAAI,MAAM,QAAQ;AAC9B,KAAI,OAAO;AACX,KAAI,OAAO;AACX,KAAI,WAAW;AACf,KAAI,aAAa;AACjB,KAAI,YAAY;AAChB,QAAO;;;;;;;;;;;;;;AAwCT,MAAa,gBAA2C;CAItD,sBAAsB;EACpB,MAAM;EACN,eAAe;EAChB;CAOD,mBAAmB;EACjB,MAAM;EACN,eAAe;AACb,SAAM,gBAAgB,iBAAiB,iBAAiB,gBAAgB;;EAE3E;CAKD,gBAAgB;EACd,MAAM;EACN,eAAe,KAAA;EAChB;CASD,kBAAkB;EAChB,MAAM;EACN,MAAM,SAAS;GACb,MAAM,sBAAM,IAAI,MAAM,yBAAyB;AAC/C,OAAI,OAAO;AACX,QAAK,QAAQ,IAAI;AACjB,gBAAa;;EAEhB;CACF;;;;;;;;;;;;;;;AAmBD,SAAgB,gBACd,KACA,SACyB;AACzB,KAAI,CAAC,QAAS,QAAO;AAErB,QAAO,IAAI,MAAM,KAAK,EACpB,IAAI,QAAQ,MAAM,UAAU;AAC1B,MAAI,OAAO,SAAS,YAAY,OAAO,OAAO,eAAe,KAAK,CAChE,QAAO,kBAAkB,KAAK;AAEhC,SAAO,QAAQ,IAAI,QAAQ,MAAM,SAAS;IAE7C,CAAC;;;AAIJ,SAAS,kBAAkB,MAA+C;CACxE,MAAM,QAAQ,cAAc;AAC5B,KAAI,MAAM,SAAS,UACjB,QAAO,OAAO,GAAG,SAAoB,MAAM,QAAQ,KAAK,GAAG;AAG7D,SAAQ,GAAG,SAAoB;EAC7B,MAAM,WAAW,KAAK;AACtB,SAAO,MAAM,IAAI,SAAS;;;;;;;;;;AAW9B,SAAgB,wBAAiC;AAC/C,QAAQ,WAAmD,0BAA0B"}

package/dist/test-runner/bundle.js

@@ -93,6 +93,16 @@ const SDK_IMPORT_FILTER = new RegExp(`^${SDK_PACKAGE.replace(/[.*+?^${}()|[\]\\]
 *
 * 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.
 */
 function sdkRedirectPlugin() {
 	return {
@@ -107,16 +117,19 @@ function sdkRedirectPlugin() {
 				namespace: "sdk-redirect"
 			}, () => ({
 				contents: `
-var __proxy = (typeof window !== 'undefined' && window.__sdk)
+import { wrapSdkWithStub, isStubBlockingEnabled } from ${JSON.stringify(getBridgeStubPath())};
+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 __proxy = wrapSdkWithStub(__rawSdk, isStubBlockingEnabled());
 module.exports = __proxy;
 `,
-				loader: "js"
+				loader: "js",
+				resolveDir: process.cwd()
 			}));
 		}
 	};
@@ -250,8 +263,9 @@ function userFactoryPlugin(absPath) {
 	};
 }
 /**
-* Returns the absolute filesystem path to the test-runner runtime module
-* (dist/test-runner/runtime.js — a fully self-contained page-side bundle).
+* 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
@@ -261,26 +275,30 @@ function userFactoryPlugin(absPath) {
 * 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 `runtime.js` and the nested `test-runner/runtime.js`,
+* 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/runtime.js from the dist/ root level no
+* 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/runtime.js (tsdown entry
-* `'test-runner/runtime'`; guarded by scripts/check-test-runner-dist.sh).
+* 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 getRuntimePath() {
+function getPageSideModulePath(moduleName) {
 	const startDir = path$1.dirname(fileURLToPath(import.meta.url));
 	const RELATIVE_PROBES = [
-		["runtime.js"],
-		["test-runner", "runtime.js"],
-		["runtime.ts"],
-		["test-runner", "runtime.ts"]
+		[`${moduleName}.js`],
+		["test-runner", `${moduleName}.js`],
+		[`${moduleName}.ts`],
+		["test-runner", `${moduleName}.ts`]
 	];
 	let dir = startDir;
 	for (let i = 0; i < 12; i++) {
@@ -295,7 +313,19 @@ function getRuntimePath() {
 		if (parent === dir) break;
 		dir = parent;
 	}
-	return path$1.join(startDir, "runtime.js");
+	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");
 }
 /**
 * Bundles `absPath` into a single IIFE string suitable for `Runtime.evaluate`.

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

@@ -1 +1 @@
-{"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 */\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        // Generate a virtual CommonJS-style module so that esbuild does NOT perform\n        // strict named-export matching. When `format:'iife'` bundles a CJS module,\n        // it wraps it with its own __toCommonJS helper and satisfies named imports\n        // via property access on the module.exports object — which is our Proxy.\n        // This means `import { getPlatformOS } from '...'` becomes\n        // `__proxy.getPlatformOS` at runtime, which correctly reads from window.__sdk.\n        contents: `\nvar __proxy = (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    });\nmodule.exports = __proxy;\n`,\n        loader: 'js',\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 the test-runner runtime module\n * (dist/test-runner/runtime.js — a fully self-contained page-side bundle).\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 `runtime.js` and the nested `test-runner/runtime.js`,\n * then ascends one directory at a time (bounded) repeating both probes. The\n * nested probe catches dist/test-runner/runtime.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/runtime.js (tsdown entry\n * `'test-runner/runtime'`; guarded by scripts/check-test-runner-dist.sh).\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 */\nfunction getRuntimePath(): 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 runtime.ts sits\n  // beside bundle.ts and no dist exists.\n  const RELATIVE_PROBES: string[][] = [\n    ['runtime.js'],\n    ['test-runner', 'runtime.js'],\n    ['runtime.ts'],\n    ['test-runner', 'runtime.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, 'runtime.js');\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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"}
+{"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 */\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        // Generate a virtual CommonJS-style module so that esbuild does NOT perform\n        // strict named-export matching. When `format:'iife'` bundles a CJS module,\n        // it wraps it with its own __toCommonJS helper and satisfies named imports\n        // via property access on the module.exports object — which is our Proxy.\n        // This means `import { getPlatformOS } from '...'` becomes\n        // `__proxy.getPlatformOS` at runtime, which correctly reads from window.__sdk.\n        //\n        // The bridge-stub import is a STATIC import of the real `bridge-stub.ts`\n        // module (not inlined JS) so esbuild bundles it once and the fixture\n        // registry has a single source of truth shared with its own unit tests.\n        contents: `\nimport { wrapSdkWithStub, isStubBlockingEnabled } from ${JSON.stringify(getBridgeStubPath())};\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 __proxy = wrapSdkWithStub(__rawSdk, isStubBlockingEnabled());\nmodule.exports = __proxy;\n`,\n        loader: 'js',\n        // resolveDir is required so esbuild can resolve the absolute\n        // getBridgeStubPath() import above from a filesystem base — a virtual\n        // module has no implicit directory of its own. process.cwd() is a\n        // safe base for an ABSOLUTE import specifier (it is never used to\n        // 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 * 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8FA,MAAM,cAAc;;;;;;;AAQpB,MAAM,sBAAsB;CAC1B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;;;;;;AAOD,MAAM,oBAAoB,IAAI,OAAO,IAAI,YAAY,QAAQ,uBAAuB,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;AAwB9F,SAAS,oBAAoC;AAC3C,QAAO;EACL,MAAM;EACN,MAAM,OAAO;AAEX,SAAM,UAAU,EAAE,QAAQ,mBAAmB,GAAG,UAAU;IACxD,MAAM,KAAK;IACX,WAAW;IACZ,EAAE;AAEH,SAAM,OAAO;IAAE,QAAQ;IAAM,WAAW;IAAgB,SAAS;IAW/D,UAAU;yDACuC,KAAK,UAAU,mBAAmB,CAAC,CAAC;;;;;;;;;;;IAWrF,QAAQ;IAMR,YAAY,QAAQ,KAAK;IAC1B,EAAE;;EAEN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BH,SAAS,uBAAuC;AAC9C,QAAO;EACL,MAAM;EACN,MAAM,OAAO;AACX,SAAM,UAAU,EAAE,QAAQ,YAAY,SAAS;IAC7C,MAAM;IACN,WAAW;IACZ,EAAE;AAEH,SAAM,OAAO;IAAE,QAAQ;IAAY,WAAW;IAAmB,QAAQ;AAQvE,WAAO;KACL,UAAU,mEARI,oBAAoB,KACjC,SACC,kCAAkC,KAAK,UAAU,KAAK,CAAC,4DAA4D,KAAK,UAAU,KAAK,CAAC,UAC3I,CAAC,KAAK,KAAK,CAK2E;KACrF,QAAQ;KACT;KACD;;EAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BH,SAAS,kBAAkB,SAAiC;CAC1D,MAAM,YAAY;AAClB,QAAO;EACL,MAAM;EACN,MAAM,OAAO;AAEX,SAAM,UAAU,EAAE,QAAQ,uBAAuB,SAAS;IACxD,MAAM;IACN,WAAW;IACZ,EAAE;AAGH,SAAM,OAAO;IAAE,QAAQ;IAAM,WAAW;IAAW,EAAE,OAAO,SAAS;IAEnE,MAAM,SADS,MAAM,GAAG,SAAS,KAAK,MAAM,OAAO,EAC9B,MAAM,KAAK;IAEhC,MAAM,gBAA0B,EAAE;IAClC,MAAM,YAAsB,EAAE;IAK9B,MAAM,wBACJ;IAGF,MAAM,iBAAiB,YACrB,QAAQ,WAAW,UAAU,IAC7B,QAAQ,WAAW,UAAU,IAC7B,QAAQ,WAAW,UAAU,IAC7B,QAAQ,WAAW,WAAU;IAQ/B,MAAM,iBAAiB,YACrB,gBAAgB,KAAK,QAAQ,QAAQ,WAAW,GAAG,CAAC,SAAS,CAAC;IAIhE,IAAI,gBAAgB;AAEpB,SAAK,MAAM,QAAQ,OAAO;KACxB,MAAM,UAAU,KAAK,WAAW;KAChC,MAAM,SAAS,KAAK,MAAM,GAAG,KAAK,SAAS,QAAQ,OAAO;AAK1D,SAAI,eAAe;AACjB,oBAAc,KAAK,KAAK;AACxB,UAAI,cAAc,QAAQ,CACxB,iBAAgB;AAElB;;AAOF,SAAI,cAAc,QAAQ,EAAE;AAC1B,oBAAc,KAAK,KAAK;AACxB,UAAI,CAAC,cAAc,QAAQ,CACzB,iBAAgB;gBAET,QAAQ,WAAW,UAAU,CAItC,KADU,QAAQ,MAAM,sBAAsB,CAK5C,WAAU,KAAK,SAAS,QAAQ,MAAM,EAAiB,CAAC;UACnD;AAGL,oBAAc,KAAK,KAAK;AACxB,UAAI,WAAW,KAAK,QAAQ,GAAG,CAAC,cAAc,QAAQ,GAAG,QAAQ,SAAS,IAAI,CAC5E,iBAAgB;;SAIpB,WAAU,KAAK,KAAK;;AAaxB,WAAO;KACL,UAVqB;MACrB,GAAG;MACH;MACA;MACA;MACA,GAAG,UAAU,KAAK,MAAM,KAAK,IAAI;MACjC;MACD,CAAC,KAAK,KAAK;KAIV,QAAQ;KACR,YAAYA,OAAK,QAAQ,QAAQ;KAClC;KACD;;EAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCH,SAAS,sBAAsB,YAA4B;CACzD,MAAM,WAAWA,OAAK,QAAQ,cAAc,OAAO,KAAK,IAAI,CAAC;CAI7D,MAAM,kBAA8B;EAClC,CAAC,GAAG,WAAW,KAAK;EACpB,CAAC,eAAe,GAAG,WAAW,KAAK;EACnC,CAAC,GAAG,WAAW,KAAK;EACpB,CAAC,eAAe,GAAG,WAAW,KAAK;EACpC;CAID,IAAI,MAAM;AACV,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,OAAK,MAAM,QAAQ,iBAAiB;GAClC,MAAM,YAAYA,OAAK,KAAK,KAAK,GAAG,KAAK;AACzC,OAAI;AACF,eAAW,UAAU;AACrB,WAAO;WACD;;EAIV,MAAM,SAASA,OAAK,QAAQ,IAAI;AAChC,MAAI,WAAW,IAAK;AACpB,QAAM;;AAIR,QAAOA,OAAK,KAAK,UAAU,GAAG,WAAW,KAAK;;;AAIhD,SAAS,iBAAyB;AAChC,QAAO,sBAAsB,UAAU;;;;;;;AAQzC,SAAS,oBAA4B;AACnC,QAAO,sBAAsB,cAAc;;;;;;;;;;;;;;;;AAiB7C,eAAsB,eAAe,SAAiB,MAA6C;CACjG,MAAM,aAAa,MAAM,cAAc;CACvC,MAAM,iBAAiB,MAAM,kBAAkB,EAAE;CAGjD,MAAM,UAAU,MAAM,OAAO;CAC7B,MAAM,cAAc,gBAAgB;CAKpC,MAAM,iBAAiB;EACrB,iCAAiC,KAAK,UAAU,YAAY,CAAC;EAC7D;EACA;EACD,CAAC,KAAK,KAAK;CAEZ,MAAM,SAAS,MAAM,QAAQ,MAAM;EACjC,OAAO;GACL,UAAU;GACV,QAAQ;GAKR,YAAYA,OAAK,QAAQ,QAAQ;GAClC;EACD,QAAQ;EACR,QAAQ;EACR;EACA,UAAU;EACV,QAAQ;EACR,OAAO;EACP,SAAS;GAAC,kBAAkB,QAAQ;GAAE,sBAAsB;GAAE,mBAAmB;GAAC;EAClF,UAAU;EACV,aAAa;EAQb,QAAQ,EACN,IAAI,cAAc,KAAK,UAAU,WAAW,CAAC,MAAM,WAAW,IAC/D;EACF,CAAC;CAEF,MAAM,WAAW,OAAO,SAAS,KAC9B,MACC,GAAGA,OAAK,SAAS,QAAQ,KAAK,EAAE,EAAE,UAAU,QAAQ,GAAG,CAAC,GAAG,EAAE,UAAU,QAAQ,IAAI,IAAI,EAAE,OAC5F;CAED,MAAM,aAAa,OAAO,cAAc;AACxC,KAAI,CAAC,WACH,OAAM,IAAI,MAAM,iEAAiE;AAGnF,QAAO;EAAE,MAAM,WAAW;EAAM;EAAU"}

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

@@ -1,4 +1,4 @@
-import { i as createRelayPool, n as RelayConnectionFactory, t as RELAY_POOL_NAME } from "../pool-C6TgrcyW.js";
+import { i as createRelayPool, n as RelayConnectionFactory, t as RELAY_POOL_NAME } from "../pool-CmfvXnwh.js";
 
 //#region src/test-runner/relay-factory.d.ts
 /** Options for {@link createRelayConnectionFactory}. */
@@ -35,6 +35,16 @@ interface RelayConnectionFactoryOptions {
     sdkLine: string;
     platform: string;
   };
+  /**
+   * When `true`, injects `__AIT_STUB_BLOCKING__ = true` before the first test
+   * bundle runs (devtools#740, DT-2) — `bundle.ts`'s sdk-redirect module reads
+   * this flag via `isStubBlockingEnabled()` and answers the blocking-UI APIs
+   * in `bridge-stub.ts`'s `STUB_REGISTRY` from fixtures instead of forwarding
+   * them to native. Optional — omitted/false means no flag is injected, which
+   * is byte-for-byte the pre-#740 behavior (the sdk-redirect module treats
+   * absence the same as `false`). Not a secret.
+   */
+  stubBlocking?: boolean;
   /**
    * Overrides the dashboard HTTP server's bind base port (devtools#752).
    * Threaded straight through to `startQrHttpServer`'s `dashboardPort`

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/test-runner/relay-factory.ts","../../src/test-runner/config.ts"],"mappings":";;;;UAiDiB,6BAAA;ECPD;AAIhB;;;;EDSE,SAAA;ECPA;;;;EDYA,WAAA;ECKmC;;;;;;;;AAcrC;EDTE,SAAA;;EAEA,QAAA;ECSA;;;;;EDHA,IAAA;IAAS,OAAA;IAAiB,QAAA;EAAA;;;;;;;;EAQ1B,aAAA;ECqCc;;;;;;;;;;;;;;;;EDpBd,WAAA,GAAc,UAAA;AAAA;;;;;;;;;;;;;;;;;;iBAoBA,4BAAA,CACd,IAAA,EAAM,6BAAA,GACL,sBAAA;;;;;;UCjGc,eAAA;EDgGf;;;;EC3FA,OAAA;;;AALF;EASE,SAAA;;;;;EAKA,cAAA;AAAA;;UAIe,mBAAA;EACf,OAAA;EACA,SAAA;EACA,cAAA;AAAA;;;;;AAgBF;;;iBAAgB,qBAAA,CAAsB,UAAA,GAAa,mBAAA,GAAsB,eAAA;;;;;;AAczE;UAAiB,qBAAA;;EAEf,IAAA,EAAM,UAAA,QAAkB,eAAA;EAAxB;EAEA,OAAA;EAFwB;EAIxB,WAAA;AAAA;;UAIe,qBAAA,SAA8B,mBAAA;EAA9B;;;;;;;EAQf,UAAA,EAAY,sBAAA;EAQG;;AAkBjB;;;;;EAlBE,eAAA;AAAA;;;;;;;;;;;;;;;;iBAkBc,uBAAA,CAAwB,UAAA,EAAY,qBAAA,GAAwB,qBAAA"}
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/test-runner/relay-factory.ts","../../src/test-runner/config.ts"],"mappings":";;;;UAiDiB,6BAAA;ECPD;;AAIhB;;;EDSE,SAAA;ECRA;;;;EDaA,WAAA;ECKc;;;;;;;;;EDKd,SAAA;ECSoC;EDPpC,QAAA;ECSgB;;;;;EDHhB,IAAA;IAAS,OAAA;IAAiB,QAAA;EAAA;ECWW;;;;;;;;;EDDrC,YAAA;ECmCqC;;;;;;;ED3BrC,aAAA;;;;;;;;;;;;;;;;;EAiBA,WAAA,GAAc,UAAA;AAAA;;;;;;;;;;;;;;;;;;iBAoBA,4BAAA,CACd,IAAA,EAAM,6BAAA,GACL,sBAAA;;;AAFH;;;AAAA,UCzGiB,eAAA;ED0GT;;;;ECrGN,OAAA;;;;EAIA,SAAA;EAT8B;;;;EAc9B,cAAA;AAAA;;UAIe,mBAAA;EACf,OAAA;EACA,SAAA;EACA,cAAA;AAAA;;;;;;AAgBF;;iBAAgB,qBAAA,CAAsB,UAAA,GAAa,mBAAA,GAAsB,eAAA;;;;;;;UAcxD,qBAAA;EAAqB;EAEpC,IAAA,EAAM,UAAA,QAAkB,eAAA;EAAR;EAEhB,OAAA;EAFM;EAIN,WAAA;AAAA;;UAIe,qBAAA,SAA8B,mBAAA;EAJlC;AAIb;;;;;;EAQE,UAAA,EAAY,sBAAA;EAQZ;;;AAkBF;;;;EAlBE,eAAA;AAAA;;;;;;;;;;;;;;;;iBAkBc,uBAAA,CAAwB,UAAA,EAAY,qBAAA,GAAwB,qBAAA"}

package/dist/test-runner/config.js

@@ -1,5 +1,5 @@
 import { RELAY_POOL_NAME, createRelayPool } from "./pool.js";
-import { t as createRelayConnectionFactory } from "../relay-factory-CjqAJ3Y8.js";
+import { t as createRelayConnectionFactory } from "../relay-factory-DVzpBRxz.js";
 //#region src/test-runner/config.ts
 const DEFAULT_CONFIG = {
 	include: ["**/*.ait.test.ts"],

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

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

package/dist/test-runner/pool.js

@@ -1,4 +1,4 @@
-import { i as runTestFilesOverRelay } from "../relay-worker-UK0nBfDX.js";
+import { i as runTestFilesOverRelay } from "../relay-worker-6fy1eaIo.js";
 import { synthesizeFileTask, toTaskEventPacks, toTaskResultPacks } from "./task-graph.js";
 //#region src/test-runner/pool.ts
 /** The pool name Vitest matches against `getFilePoolName(project)`. */

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

@@ -11133,6 +11133,16 @@ interface RelayConnectionFactoryOptions {
     sdkLine: string;
     platform: string;
   };
+  /**
+   * When `true`, injects `__AIT_STUB_BLOCKING__ = true` before the first test
+   * bundle runs (devtools#740, DT-2) — `bundle.ts`'s sdk-redirect module reads
+   * this flag via `isStubBlockingEnabled()` and answers the blocking-UI APIs
+   * in `bridge-stub.ts`'s `STUB_REGISTRY` from fixtures instead of forwarding
+   * them to native. Optional — omitted/false means no flag is injected, which
+   * is byte-for-byte the pre-#740 behavior (the sdk-redirect module treats
+   * absence the same as `false`). Not a secret.
+   */
+  stubBlocking?: boolean;
   /**
    * Overrides the dashboard HTTP server's bind base port (devtools#752).
    * Threaded straight through to `startQrHttpServer`'s `dashboardPort`