@specific.dev/spectest 0.90.0 → 0.90.1

package/dist/android-step.d.ts

@@ -0,0 +1,22 @@
+/** Recorded semantics, independent of Appium's wire selectors and display titles. */
+export interface AndroidTarget {
+    kind: "text" | "id" | "accessibility" | "class" | "xpath" | "custom";
+    value: string;
+    /** Original strategy for a custom locator; never interpreted as display text. */
+    strategy?: string;
+}
+export interface AndroidStepDetails {
+    device: string;
+    action: "tap" | "fill" | "text" | "visible" | "wait" | "swipe" | "back" | "source" | "screenshot" | "execute";
+    target?: AndroidTarget;
+    point?: {
+        x: number;
+        y: number;
+    };
+    direction?: "up" | "down" | "left" | "right";
+    state?: "visible" | "hidden";
+    command?: string;
+}
+export declare function androidTarget(using: string, value: string): AndroidTarget;
+export declare function androidTargetLabel(target: AndroidTarget): string;
+export declare function androidStepTitle(step: AndroidStepDetails): string;

package/dist/android-step.js

@@ -0,0 +1,78 @@
+export function androidTarget(using, value) {
+    const kind = new Map([
+        ["id", "id"],
+        ["accessibility id", "accessibility"],
+        ["class name", "class"],
+        ["xpath", "xpath"],
+    ]).get(using);
+    return kind ? { kind, value } : { kind: "custom", value, strategy: using };
+}
+export function androidTargetLabel(target) {
+    const quoted = JSON.stringify(target.value);
+    switch (target.kind) {
+        case "text":
+            return `text ${quoted}`;
+        case "id":
+            return `id ${quoted}`;
+        case "accessibility":
+            return `accessibility label ${quoted}`;
+        case "xpath":
+            return `XPath ${quoted}`;
+        case "custom":
+            return "custom selector";
+        case "class": {
+            const classes = {
+                "android.widget.EditText": "text field",
+                "android.widget.Button": "button",
+                "android.widget.TextView": "text view",
+                "android.widget.CheckBox": "checkbox",
+                "android.widget.Switch": "switch",
+                "android.widget.ImageView": "image",
+                "android.widget.ScrollView": "scroll view",
+                "androidx.recyclerview.widget.RecyclerView": "list",
+            };
+            return Object.hasOwn(classes, target.value)
+                ? classes[target.value]
+                : `class ${quoted}`;
+        }
+    }
+}
+export function androidStepTitle(step) {
+    const target = step.target ? androidTargetLabel(step.target) : "element";
+    let label;
+    switch (step.action) {
+        case "tap":
+            label = step.point
+                ? `tap (${step.point.x}, ${step.point.y})`
+                : `tap ${target}`;
+            break;
+        case "fill":
+            label = `fill ${target}`;
+            break;
+        case "text":
+            label = `read text from ${target}`;
+            break;
+        case "visible":
+            label = `check ${target} is visible`;
+            break;
+        case "wait":
+            label = `wait for ${target} to be ${step.state ?? "visible"}`;
+            break;
+        case "swipe":
+            label = `swipe ${step.direction}`;
+            break;
+        case "back":
+            label = "go back";
+            break;
+        case "source":
+            label = "read screen structure";
+            break;
+        case "screenshot":
+            label = "take screenshot";
+            break;
+        case "execute":
+            label = `run command ${JSON.stringify(step.command)}`;
+            break;
+    }
+    return `${step.device}: ${label}`;
+}

package/dist/android.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { rawFetch } from "./harness/raw-fetch.js";
 import { recordStep, reserveEvent } from "./recorder.js";
 import { wrap } from "./inspect.js";
+import { androidStepTitle, androidTarget, androidTargetLabel } from "./android-step.js";
 export const ANDROID_APP = Symbol.for("spectest.androidApp");
 export function androidApp(options) {
     return { ...options, [ANDROID_APP]: true };
@@ -154,14 +155,17 @@ export function androidScope(caseId, testStartedAt, options = {}) {
                     list.push(marker);
                 taps.set(app.name, list);
             }
-            async function op(title, fn) {
+            async function op(operation, fn) {
                 assertActive();
+                const android = { device: app.name, ...operation };
+                const title = androidStepTitle(android);
                 const reservation = reserveEvent(), started = Date.now();
                 try {
                     const result = await fn();
                     const seq = recordStep({
                         kind: "android",
-                        title: `${app.name}: ${title}`,
+                        title,
+                        android,
                         durationMs: Date.now() - started,
                         status: "passed",
                     }, reservation);
@@ -170,7 +174,8 @@ export function androidScope(caseId, testStartedAt, options = {}) {
                 catch (error) {
                     recordStep({
                         kind: "android",
-                        title: `${app.name}: ${title}`,
+                        title,
+                        android,
                         durationMs: Date.now() - started,
                         status: "failed",
                         error: String(error),
@@ -178,8 +183,8 @@ export function androidScope(caseId, testStartedAt, options = {}) {
                     throw error;
                 }
             }
-            const element = (using, value) => {
-                const label = `${using}=${value}`;
+            const element = (using, value, target = androidTarget(using, value)) => {
+                const label = androidTargetLabel(target);
                 const find = async () => {
                     const result = await command("POST", "/element", {
                         using,
@@ -203,7 +208,7 @@ export function androidScope(caseId, testStartedAt, options = {}) {
                 };
                 return {
                     async tap() {
-                        await op(`tap ${label}`, async () => {
+                        await op({ action: "tap", target }, async () => {
                             const path = await find();
                             const marker = await tapMarker(path);
                             await command("POST", `${path}/click`, {});
@@ -211,19 +216,19 @@ export function androidScope(caseId, testStartedAt, options = {}) {
                         });
                     },
                     async fill(text) {
-                        await op(`fill ${label}`, async () => {
+                        await op({ action: "fill", target }, async () => {
                             const path = await find();
                             await command("POST", `${path}/clear`, {});
                             await command("POST", `${path}/value`, { text });
                         });
                     },
-                    text: () => op(`text ${label}`, async () => command("GET", `${await find()}/text`)),
-                    isDisplayed: () => op(`visible ${label}`, displayed),
+                    text: () => op({ action: "text", target }, async () => command("GET", `${await find()}/text`)),
+                    isDisplayed: () => op({ action: "visible", target }, displayed),
                     async waitFor(options = {}) {
                         const timeout = options.timeoutMs ?? 10000;
                         if (!Number.isFinite(timeout) || timeout < 0)
                             throw new Error("Invalid wait timeout");
-                        await op(`wait for ${options.state ?? "visible"} ${label}`, async () => {
+                        await op({ action: "wait", target, state: options.state ?? "visible" }, async () => {
                             const end = Date.now() + timeout;
                             do {
                                 if ((await displayed()) === (options.state !== "hidden"))
@@ -239,16 +244,16 @@ export function androidScope(caseId, testStartedAt, options = {}) {
                 locator: element,
                 getByAccessibilityId: (id) => element("accessibility id", id),
                 getById: (id) => element("id", id),
-                getByText: (text) => element("-android uiautomator", `new UiSelector().text(${JSON.stringify(text)})`),
+                getByText: (text) => element("-android uiautomator", `new UiSelector().text(${JSON.stringify(text)})`, { kind: "text", value: text }),
                 async tap(x, y) {
-                    await op(`tap (${x}, ${y})`, async () => {
+                    await op({ action: "tap", point: { x, y } }, async () => {
                         const marker = await tapMarker({ x, y });
                         await command("POST", "/execute/sync", { script: "mobile: clickGesture", args: [{ x, y }] });
                         saveTap(marker);
                     });
                 },
                 async swipe(direction) {
-                    await op(`swipe ${direction}`, async () => {
+                    await op({ action: "swipe", direction }, async () => {
                         const rect = await command("GET", "/window/rect");
                         await command("POST", "/execute/sync", {
                             script: "mobile: swipeGesture",
@@ -266,14 +271,14 @@ export function androidScope(caseId, testStartedAt, options = {}) {
                     });
                 },
                 async back() {
-                    await op("back", () => command("POST", "/back", {}));
+                    await op({ action: "back" }, () => command("POST", "/back", {}));
                 },
-                pageSource: () => op("page source", () => command("GET", "/source")),
+                pageSource: () => op({ action: "source" }, () => command("GET", "/source")),
                 async screenshot() {
-                    const value = await op("screenshot", () => command("GET", "/screenshot"));
+                    const value = await op({ action: "screenshot" }, () => command("GET", "/screenshot"));
                     return Buffer.from(value.unwrap(), "base64");
                 },
-                execute: (script, args = {}) => op(script, () => command("POST", "/execute/sync", { script, args: [args] })),
+                execute: (script, args = {}) => op({ action: "execute", command: script }, () => command("POST", "/execute/sync", { script, args: [args] })),
             };
         })();
         handles.set(app.name, pending);

package/dist/daemon.js

@@ -5124,6 +5124,11 @@ async function evalCode(code) {
     const base = await spectestContext();
     const ctx = {
         ...base,
+        // Bun does not propagate the import() caller's AsyncLocalStorage into
+        // the snippet's module evaluation. Enter the eval scope at the ctx.fetch
+        // call itself so top-level awaits and imported helpers get wrapped values
+        // without enabling instrumentation for unrelated background/fake fetches.
+        fetch: (input, init) => runInstrumented(fetchScope, () => base.fetch(input, init)),
         // Wraps its result (no recorder under eval, so no provenance — but the
         // wrapped type is honest at runtime, so `.unwrap()` works).
         exec: execInServiceWrapped,

package/dist/recorder.d.ts

@@ -1,3 +1,4 @@
+import type { AndroidStepDetails } from "./android-step.js";
 export type TestEvent = ExecEvent | AssertionEvent | HttpEvent | KubeEvent | BrowserEvent | DbEvent | RedisEvent | S3Event | TerminalEvent | TerminalStepEvent | WaitEvent | FakeEvent | EnvEvent | EmailEvent | StepEvent;
 interface BaseEvent {
     /** Order of *start* within the test. Reserved when an op begins (see
@@ -659,6 +660,8 @@ export interface StepEvent extends BaseEvent {
     kind: string;
     /** The step's one-line summary in the timeline. */
     title: string;
+    /** Native action semantics; titles are presentation only. */
+    android?: AndroidStepDetails;
     blocks?: StepBlock[];
     status?: "passed" | "failed" | "error";
     durationMs?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.90.0",
+  "version": "0.90.1",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/android-step.test.ts

@@ -0,0 +1,115 @@
+import { expect, test } from "bun:test";
+import {
+  androidStepTitle,
+  androidTarget,
+  type AndroidStepDetails,
+} from "./android-step.js";
+
+const cases: [Omit<AndroidStepDetails, "device">, string][] = [
+  [
+    { action: "tap", target: { kind: "text", value: "SAVE LOCAL SQLITE" } },
+    'tap text "SAVE LOCAL SQLITE"',
+  ],
+  [
+    {
+      action: "tap",
+      target: { kind: "text", value: 'a "quoted" label\nnext' },
+    },
+    'tap text "a \\"quoted\\" label\\nnext"',
+  ],
+  [
+    {
+      action: "fill",
+      target: { kind: "class", value: "android.widget.EditText" },
+    },
+    "fill text field",
+  ],
+  [
+    {
+      action: "text",
+      target: { kind: "class", value: "android.widget.EditText" },
+    },
+    "read text from text field",
+  ],
+  [
+    { action: "visible", target: { kind: "id", value: "app:id/save" } },
+    'check id "app:id/save" is visible',
+  ],
+  [
+    {
+      action: "wait",
+      target: { kind: "accessibility", value: "Save" },
+      state: "hidden",
+    },
+    'wait for accessibility label "Save" to be hidden',
+  ],
+  [
+    {
+      action: "wait",
+      target: { kind: "text", value: "Ready" },
+      state: "visible",
+    },
+    'wait for text "Ready" to be visible',
+  ],
+  [
+    {
+      action: "tap",
+      target: { kind: "xpath", value: '//button[@text="Save"]' },
+    },
+    'tap XPath "//button[@text=\\"Save\\"]"',
+  ],
+  [
+    {
+      action: "tap",
+      target: {
+        kind: "custom",
+        strategy: "-android uiautomator",
+        value: 'new UiSelector().text("Save")',
+      },
+    },
+    "tap custom selector",
+  ],
+  [
+    { action: "tap", target: { kind: "class", value: "my.CustomWidget" } },
+    'tap class "my.CustomWidget"',
+  ],
+  [{ action: "tap", point: { x: 12, y: 34 } }, "tap (12, 34)"],
+  [{ action: "swipe", direction: "up" }, "swipe up"],
+  [{ action: "back" }, "go back"],
+  [{ action: "source" }, "read screen structure"],
+  [{ action: "screenshot" }, "take screenshot"],
+  [
+    { action: "execute", command: "mobile: getDeviceInfo" },
+    'run command "mobile: getDeviceInfo"',
+  ],
+];
+for (const [action, title] of cases) {
+  test(title, () =>
+    expect(androidStepTitle({ device: "phone", ...action })).toBe(
+      `phone: ${title}`,
+    ),
+  );
+}
+
+test("custom selector expressions remain opaque structured data", () => {
+  const expression = 'new UiSelector().text("Save").enabled(true)';
+  const target = androidTarget("-android uiautomator", expression);
+  expect(target).toEqual({
+    kind: "custom",
+    strategy: "-android uiautomator",
+    value: expression,
+  });
+  expect(androidStepTitle({ device: "phone", action: "tap", target })).toBe(
+    "phone: tap custom selector",
+  );
+  for (const [using, kind] of [
+    ["id", "id"],
+    ["accessibility id", "accessibility"],
+    ["class name", "class"],
+    ["xpath", "xpath"],
+  ] as const)
+    expect(androidTarget(using, expression)).toEqual({
+      kind,
+      value: expression,
+    });
+});

package/src/android-step.ts

@@ -0,0 +1,107 @@
+/** Recorded semantics, independent of Appium's wire selectors and display titles. */
+export interface AndroidTarget {
+  kind: "text" | "id" | "accessibility" | "class" | "xpath" | "custom";
+  value: string;
+  /** Original strategy for a custom locator; never interpreted as display text. */
+  strategy?: string;
+}
+export interface AndroidStepDetails {
+  device: string;
+  action:
+    | "tap"
+    | "fill"
+    | "text"
+    | "visible"
+    | "wait"
+    | "swipe"
+    | "back"
+    | "source"
+    | "screenshot"
+    | "execute";
+  target?: AndroidTarget;
+  point?: { x: number; y: number };
+  direction?: "up" | "down" | "left" | "right";
+  state?: "visible" | "hidden";
+  command?: string;
+}
+
+export function androidTarget(using: string, value: string): AndroidTarget {
+  const kind = new Map<string, AndroidTarget["kind"]>([
+    ["id", "id"],
+    ["accessibility id", "accessibility"],
+    ["class name", "class"],
+    ["xpath", "xpath"],
+  ]).get(using);
+  return kind ? { kind, value } : { kind: "custom", value, strategy: using };
+}
+
+export function androidTargetLabel(target: AndroidTarget): string {
+  const quoted = JSON.stringify(target.value);
+  switch (target.kind) {
+    case "text":
+      return `text ${quoted}`;
+    case "id":
+      return `id ${quoted}`;
+    case "accessibility":
+      return `accessibility label ${quoted}`;
+    case "xpath":
+      return `XPath ${quoted}`;
+    case "custom":
+      return "custom selector";
+    case "class": {
+      const classes = {
+        "android.widget.EditText": "text field",
+        "android.widget.Button": "button",
+        "android.widget.TextView": "text view",
+        "android.widget.CheckBox": "checkbox",
+        "android.widget.Switch": "switch",
+        "android.widget.ImageView": "image",
+        "android.widget.ScrollView": "scroll view",
+        "androidx.recyclerview.widget.RecyclerView": "list",
+      } as Record<string, string>;
+      return Object.hasOwn(classes, target.value)
+        ? classes[target.value]
+        : `class ${quoted}`;
+    }
+  }
+}
+
+export function androidStepTitle(step: AndroidStepDetails): string {
+  const target = step.target ? androidTargetLabel(step.target) : "element";
+  let label: string;
+  switch (step.action) {
+    case "tap":
+      label = step.point
+        ? `tap (${step.point.x}, ${step.point.y})`
+        : `tap ${target}`;
+      break;
+    case "fill":
+      label = `fill ${target}`;
+      break;
+    case "text":
+      label = `read text from ${target}`;
+      break;
+    case "visible":
+      label = `check ${target} is visible`;
+      break;
+    case "wait":
+      label = `wait for ${target} to be ${step.state ?? "visible"}`;
+      break;
+    case "swipe":
+      label = `swipe ${step.direction}`;
+      break;
+    case "back":
+      label = "go back";
+      break;
+    case "source":
+      label = "read screen structure";
+      break;
+    case "screenshot":
+      label = "take screenshot";
+      break;
+    case "execute":
+      label = `run command ${JSON.stringify(step.command)}`;
+      break;
+  }
+  return `${step.device}: ${label}`;
+}

package/src/android.test.ts

@@ -153,7 +153,18 @@ describe("Android case lifecycle", () => {
       expect(bad.error).toContain("encoder failed");
       expect(captures.size).toBe(0); // failed captures are released too
       const events = stopRecording();
-      expect(events.filter((e) => e.kind === "android").length).toBe(7);
+      const steps = events.filter((e) => e.kind === "android");
+      expect(steps.length).toBe(7);
+      expect(steps[0]).toMatchObject({
+        title: String.raw`phone: fill text "a \"quoted\" label"`,
+        android: { device: "phone", action: "fill", target: { kind: "text", value: 'a "quoted" label' } },
+      });
+      expect(steps[1]).toMatchObject({ android: { device: "phone", action: "text", target: { kind: "id", value: "com.example.app:id/draft" } } });
+      expect(steps[2]).toMatchObject({ title: "phone: take screenshot", android: { device: "phone", action: "screenshot" } });
+      expect(steps[3]).toMatchObject({ title: 'phone: tap text "Save"', android: { device: "phone", action: "tap", target: { kind: "text", value: "Save" } } });
+      expect(steps[4]).toMatchObject({ android: { device: "phone", action: "tap", point: { x: 270, y: 1800 } } });
+      expect(steps[5]).toMatchObject({ status: "failed", android: { device: "phone", action: "tap", target: { kind: "text", value: "Gone" } } });
+      expect(JSON.stringify(steps)).not.toContain("private draft");
     } finally {
       stopRecording();
       server.stop(true);

package/src/android.ts

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { rawFetch } from "./harness/raw-fetch.js";
 import { recordStep, reserveEvent } from "./recorder.js";
 import { wrap, type Wrapped } from "./inspect.js";
+import { androidStepTitle, androidTarget, androidTargetLabel, type AndroidStepDetails, type AndroidTarget } from "./android-step.js";
 
 export interface AndroidRecordingOptions {
   /** Maximum dimension of the video, default 1280. */
@@ -226,8 +227,10 @@ export function androidScope(
         if (list.length < 10000) list.push(marker);
         taps.set(app.name, list);
       }
-      async function op<T>(title: string, fn: () => Promise<T>): Promise<Wrapped<T>> {
+      async function op<T>(operation: Omit<AndroidStepDetails, "device">, fn: () => Promise<T>): Promise<Wrapped<T>> {
         assertActive();
+        const android = { device: app.name, ...operation };
+        const title = androidStepTitle(android);
         const reservation = reserveEvent(),
           started = Date.now();
         try {
@@ -235,7 +238,8 @@ export function androidScope(
           const seq = recordStep(
             {
               kind: "android",
-              title: `${app.name}: ${title}`,
+              title,
+              android,
               durationMs: Date.now() - started,
               status: "passed",
             },
@@ -246,7 +250,8 @@ export function androidScope(
           recordStep(
             {
               kind: "android",
-              title: `${app.name}: ${title}`,
+              title,
+              android,
               durationMs: Date.now() - started,
               status: "failed",
               error: String(error),
@@ -256,8 +261,8 @@ export function androidScope(
           throw error;
         }
       }
-      const element = (using: string, value: string): AndroidElement => {
-        const label = `${using}=${value}`;
+      const element = (using: string, value: string, target: AndroidTarget = androidTarget(using, value)): AndroidElement => {
+        const label = androidTargetLabel(target);
         const find = async () => {
           const result = await command<Record<string, string>>("POST", "/element", {
             using,
@@ -281,7 +286,7 @@ export function androidScope(
         };
         return {
           async tap() {
-            await op(`tap ${label}`, async () => {
+            await op({ action: "tap", target }, async () => {
               const path = await find();
               const marker = await tapMarker(path);
               await command("POST", `${path}/click`, {});
@@ -289,19 +294,19 @@ export function androidScope(
             });
           },
           async fill(text) {
-            await op(`fill ${label}`, async () => {
+            await op({ action: "fill", target }, async () => {
               const path = await find();
               await command("POST", `${path}/clear`, {});
               await command("POST", `${path}/value`, { text });
             });
           },
           text: () =>
-            op(`text ${label}`, async () => command<string>("GET", `${await find()}/text`)),
-          isDisplayed: () => op(`visible ${label}`, displayed),
+            op({ action: "text", target }, async () => command<string>("GET", `${await find()}/text`)),
+          isDisplayed: () => op({ action: "visible", target }, displayed),
           async waitFor(options = {}) {
             const timeout = options.timeoutMs ?? 10000;
             if (!Number.isFinite(timeout) || timeout < 0) throw new Error("Invalid wait timeout");
-            await op(`wait for ${options.state ?? "visible"} ${label}`, async () => {
+            await op({ action: "wait", target, state: options.state ?? "visible" }, async () => {
               const end = Date.now() + timeout;
               do {
                 if ((await displayed()) === (options.state !== "hidden")) return;
@@ -317,16 +322,16 @@ export function androidScope(
         getByAccessibilityId: (id) => element("accessibility id", id),
         getById: (id) => element("id", id),
         getByText: (text) =>
-          element("-android uiautomator", `new UiSelector().text(${JSON.stringify(text)})`),
+          element("-android uiautomator", `new UiSelector().text(${JSON.stringify(text)})`, { kind: "text", value: text }),
         async tap(x, y) {
-          await op(`tap (${x}, ${y})`, async () => {
+          await op({ action: "tap", point: { x, y } }, async () => {
             const marker = await tapMarker({ x, y });
             await command("POST", "/execute/sync", { script: "mobile: clickGesture", args: [{ x, y }] });
             saveTap(marker);
           });
         },
         async swipe(direction) {
-          await op(`swipe ${direction}`, async () => {
+          await op({ action: "swipe", direction }, async () => {
             const rect = await command<{ width: number; height: number }>("GET", "/window/rect");
             await command("POST", "/execute/sync", {
               script: "mobile: swipeGesture",
@@ -344,15 +349,15 @@ export function androidScope(
           });
         },
         async back() {
-          await op("back", () => command("POST", "/back", {}));
+          await op({ action: "back" }, () => command("POST", "/back", {}));
         },
-        pageSource: () => op("page source", () => command<string>("GET", "/source")),
+        pageSource: () => op({ action: "source" }, () => command<string>("GET", "/source")),
         async screenshot() {
-          const value = await op("screenshot", () => command<string>("GET", "/screenshot"));
+          const value = await op({ action: "screenshot" }, () => command<string>("GET", "/screenshot"));
           return Buffer.from(value.unwrap(), "base64");
         },
         execute: <T>(script: string, args: Record<string, unknown> = {}) =>
-          op(script, () => command<T>("POST", "/execute/sync", { script, args: [args] })),
+          op({ action: "execute", command: script }, () => command<T>("POST", "/execute/sync", { script, args: [args] })),
       } satisfies Android;
     })();
     handles.set(app.name, pending);

package/src/daemon.ts

@@ -6155,6 +6155,11 @@ async function evalCode(code: string): Promise<EvalResult> {
 
   const ctx: TestContext<undefined> = {
     ...base,
+    // Bun does not propagate the import() caller's AsyncLocalStorage into
+    // the snippet's module evaluation. Enter the eval scope at the ctx.fetch
+    // call itself so top-level awaits and imported helpers get wrapped values
+    // without enabling instrumentation for unrelated background/fake fetches.
+    fetch: (input, init) => runInstrumented(fetchScope, () => base.fetch(input, init)),
     // Wraps its result (no recorder under eval, so no provenance — but the
     // wrapped type is honest at runtime, so `.unwrap()` works).
     exec: execInServiceWrapped as unknown as TestContext<undefined>["exec"],

package/src/eval-fetch.test.ts

@@ -0,0 +1,111 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("interactive ctx.fetch keeps its wrapped contract across module evaluation", async () => {
+  // Exercise the real eval import boundary in a separate process: the daemon
+  // changes globals and captures stdout, and APP_DIR is fixed at import time.
+  const root = await mkdtemp(join(tmpdir(), "spectest-eval-fetch-"));
+  try {
+    const daemon = new URL("./daemon.ts", import.meta.url).href;
+    const scopes = new URL("./harness/instrumentation-scope.ts", import.meta.url).href;
+    const recorder = new URL("./recorder.ts", import.meta.url).href;
+    const url = "data:application/json,%7B%22id%22%3A%22example%22%7D";
+    await writeFile(join(root, "helper.ts"), `
+      export async function read(fetcher) {
+        await new Promise(resolve => setTimeout(resolve, 0));
+        const response = await fetcher(${JSON.stringify(url)});
+        return (await response.json()).id.unwrap();
+      }
+    `);
+    const reproducer = `
+      const r = await ctx.fetch(${JSON.stringify(url)});
+      const j = await r.json();
+      export default {
+        statusType: typeof r.status, statusUnwrap: typeof r.status.unwrap,
+        idType: typeof j.id, idUnwrap: typeof j.id.unwrap,
+      };
+    `;
+    const readers = `
+      import { read } from "../helper.ts";
+      const r = await ctx.fetch(${JSON.stringify(url)});
+      const clone = r.clone();
+      await Promise.resolve();
+      const body = await r.json();
+      const { fetch: fetcher } = ctx;
+      export default {
+        status: r.status.unwrap(), ok: r.ok.unwrap(),
+        contentType: r.headers.get("content-type").unwrap(),
+        id: body.id.unwrap(), text: (await clone.text()).unwrap(),
+        rawStatus: r.unwrap().status, helperId: await read(fetcher),
+      };
+    `;
+    const script = `
+      import { strict as assert } from "node:assert";
+      import { METHODS } from ${JSON.stringify(daemon)};
+      import { currentInstrumentationScope, runUninstrumented } from ${JSON.stringify(scopes)};
+      import { startRecording, stopRecording } from ${JSON.stringify(recorder)};
+      const originalFetch = globalThis.fetch;
+      const url = ${JSON.stringify(url)};
+      const contentType = (await originalFetch(url)).headers.get("content-type");
+      startRecording();
+      const result = await METHODS.eval({ code: ${JSON.stringify(reproducer)} });
+      assert.equal(result.ok, true, JSON.stringify(result));
+      assert.deepEqual(result.result, {
+        statusType: "object", statusUnwrap: "function",
+        idType: "object", idUnwrap: "function",
+      });
+      const values = await METHODS.eval({ code: ${JSON.stringify(readers)} });
+      assert.equal(values.ok, true, JSON.stringify(values));
+      assert.deepEqual(values.result, {
+        status: 200, ok: true, contentType,
+        id: "example", text: '{"id":"example"}', rawStatus: 200,
+        helperId: "example",
+      });
+      // Fake/background work outside the eval's call must still see native fetch.
+      let releaseBackground;
+      const released = new Promise(resolve => { releaseBackground = resolve; });
+      const background = released.then(async () => {
+        const r = await fetch(url);
+        assert.equal(r.status, 200);
+        assert.equal((await r.json()).id, "example");
+      });
+      globalThis.nativeProbe = async () => {
+        releaseBackground();
+        await background;
+        await runUninstrumented(async () => {
+          await Promise.resolve();
+          const fakeResponse = await fetch(url);
+          assert.equal(fakeResponse.status, 200);
+          assert.equal((await fakeResponse.json()).id, "example");
+        });
+      };
+      const isolated = await METHODS.eval({ code: "await nativeProbe();" });
+      assert.equal(isolated.ok, true, JSON.stringify(isolated));
+      const failed = await METHODS.eval({ code: 'await ctx.fetch(' + JSON.stringify(url) + '); throw new Error("expected");' });
+      assert.equal(failed.ok, false);
+      assert.equal(failed.error.message, "expected");
+      assert.equal(globalThis.fetch, originalFetch);
+      assert.equal(currentInstrumentationScope(), undefined);
+      assert.equal((await fetch(url)).status, 200);
+      const next = await METHODS.eval({ code: ${JSON.stringify(reproducer)} });
+      assert.equal(next.ok, true, JSON.stringify(next));
+      assert.deepEqual(next.result, result.result);
+      assert.deepEqual(stopRecording(), []);
+    `;
+    const child = Bun.spawn([process.execPath, "--eval", script], {
+      env: { ...process.env, SPECTEST_APP_DIR: root },
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [code, stdout, stderr] = await Promise.all([
+      child.exited,
+      new Response(child.stdout).text(),
+      new Response(child.stderr).text(),
+    ]);
+    expect(code, stdout + stderr).toBe(0);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}, 20_000);

package/src/recorder.ts

@@ -8,6 +8,7 @@
 // current recorder is `null` and the `record*` helpers are no-ops, so
 // callers can invoke them unconditionally.
 
+import type { AndroidStepDetails } from "./android-step.js";
 import { clearPendingNullish } from "./inspect.js";
 import { scopeAllowsRecording } from "./harness/instrumentation-scope.js";
 
@@ -911,6 +912,8 @@ export interface StepEvent extends BaseEvent {
   kind: string;
   /** The step's one-line summary in the timeline. */
   title: string;
+  /** Native action semantics; titles are presentation only. */
+  android?: AndroidStepDetails;
   blocks?: StepBlock[];
   status?: "passed" | "failed" | "error";
   durationMs?: number;