@specific.dev/spectest 0.90.0 → 0.90.2

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/coverage.d.ts

@@ -213,6 +213,8 @@ export declare const NODE_COVERAGE_DUMP_PREFIX = "node-";
  *   source map: the inline `data:` map in the text, the file the last
  *   `sourceMappingURL` comment names, or `<script>.map` next to the
  *   script; `sourcesContent` dropped (the sources are the repository).
+ *   Records are keyed by their descriptor and compiled-source hash, not
+ *   their URL: a recompilation can reuse a URL with different source.
  *   "Once per branch" is a marker file under `.spectest/scripts/`: the
  *   directory is shared by every process of the service and forks with
  *   the environment, so a record written at bring-up or by an ancestor

package/dist/coverage.js

@@ -196,6 +196,8 @@ export const NODE_COVERAGE_DUMP_PREFIX = "node-";
  *   source map: the inline `data:` map in the text, the file the last
  *   `sourceMappingURL` comment names, or `<script>.map` next to the
  *   script; `sourcesContent` dropped (the sources are the repository).
+ *   Records are keyed by their descriptor and compiled-source hash, not
+ *   their URL: a recompilation can reuse a URL with different source.
  *   "Once per branch" is a marker file under `.spectest/scripts/`: the
  *   directory is shared by every process of the service and forks with
  *   the environment, so a record written at bring-up or by an ancestor
@@ -242,7 +244,9 @@ export const NODE_COVERAGE_HOOK = `"use strict";
   const SELF = url.pathToFileURL(__filename).href;
   const SCRIPTS = path.join(dir, ${JSON.stringify(NODE_COVERAGE_SCRIPTS_SUBDIR)});
   const MARKERS = path.join(dir, ${JSON.stringify(NODE_COVERAGE_MARKERS_SUBDIR)});
-  const known = new Set();
+  // V8 script ids identify a compiled script within this process. A URL
+  // can be reused by another process, vm context, or compilation.
+  const known = new Map();
   let seq = 0;
 
   function isApp(u) {
@@ -375,7 +379,6 @@ export const NODE_COVERAGE_HOOK = `"use strict";
     fs.renameSync(tmp, file);
   }
   function describe(s, source) {
-    const id = idOf(s.url);
     let scriptPath = null;
     try {
       scriptPath = url.fileURLToPath(s.url);
@@ -383,16 +386,20 @@ export const NODE_COVERAGE_HOOK = `"use strict";
     const text = typeof source === "string" ? source : null;
     const record = {
       url: s.url,
+      sourceHash: text !== null ? crypto.createHash("sha256").update(text).digest("hex") : null,
       lineLengths: text !== null ? lineLengths(text) : null,
       functions: s.functions.map(function (f) {
         return [f.functionName, f.ranges[0].startOffset, f.ranges[0].endOffset];
       }),
       sourceMap: text !== null && scriptPath !== null ? readMap(scriptPath, text) : null,
     };
-    writeAtomic(path.join(SCRIPTS, id + ".json"), JSON.stringify({ spectestScript: record }));
-    try {
+    const document = JSON.stringify({ spectestScript: record });
+    const id = idOf(document);
+    if (!fs.existsSync(path.join(MARKERS, id))) {
+      writeAtomic(path.join(SCRIPTS, id + ".json"), document);
       fs.writeFileSync(path.join(MARKERS, id), "");
-    } catch (e) {}
+    }
+    return id;
   }
   function take() {
     const res = post("Profiler.takePreciseCoverage");
@@ -413,9 +420,7 @@ export const NODE_COVERAGE_HOOK = `"use strict";
     if (kept.length === 0 && units.size === 0) return;
     const fresh = [];
     for (const s of kept) {
-      if (known.has(s.url)) continue;
-      known.add(s.url);
-      if (!fs.existsSync(path.join(MARKERS, idOf(s.url)))) fresh.push(s);
+      if (!known.has(s.scriptId)) fresh.push(s);
     }
     if (fresh.length > 0) {
       try {
@@ -426,7 +431,7 @@ export const NODE_COVERAGE_HOOK = `"use strict";
       for (const s of fresh) {
         const r = post("Debugger.getScriptSource", { scriptId: s.scriptId });
         try {
-          describe(s, r && r.scriptSource);
+          known.set(s.scriptId, describe(s, r && r.scriptSource));
         } catch (e) {}
       }
       post("Debugger.disable");
@@ -442,7 +447,7 @@ export const NODE_COVERAGE_HOOK = `"use strict";
       result: kept.map(function (s) {
         return {
           url: s.url,
-          spectestScript: idOf(s.url),
+          spectestScript: known.get(s.scriptId) || null,
           functions: s.functions.filter(ran).map(function (f) {
             const first = f.ranges[0];
             const out = [first.startOffset, first.endOffset - first.startOffset, first.count];

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/harness/browser-coverage.d.ts

@@ -41,11 +41,12 @@ export interface DecodedSourceMap {
 /** Decode one VLQ-encoded segment into its fields. */
 export declare function decodeVlq(segment: string): number[];
 /**
- * Normalise a source-map `sources` entry to a plain path. Bundlers prefix
+ * Normalise a source-map `sources` entry without discarding its identity. Bundlers prefix
  * their own scheme (`webpack:///./src/a.ts`), dev servers serve absolute
  * URLs paths (`/src/a.ts`), builds write relative ones (`../src/a.ts`).
- * The server maps these onto the repo by suffix, so all that matters here
- * is stripping what is not a path.
+ * The server validates file identity against the repository. Preserve
+ * virtual namespaces and external URLs; losing them makes foreign
+ * sources indistinguishable from project files.
  */
 export declare function normalizeSourcePath(src: string, sourceRoot?: string): string;
 /** Sources nobody's change can be attributed to: dependencies and bundler

package/dist/harness/browser-coverage.js

@@ -86,22 +86,28 @@ export function decodeVlq(segment) {
     return out;
 }
 /**
- * Normalise a source-map `sources` entry to a plain path. Bundlers prefix
+ * Normalise a source-map `sources` entry without discarding its identity. Bundlers prefix
  * their own scheme (`webpack:///./src/a.ts`), dev servers serve absolute
  * URLs paths (`/src/a.ts`), builds write relative ones (`../src/a.ts`).
- * The server maps these onto the repo by suffix, so all that matters here
- * is stripping what is not a path.
+ * The server validates file identity against the repository. Preserve
+ * virtual namespaces and external URLs; losing them makes foreign
+ * sources indistinguishable from project files.
  */
 export function normalizeSourcePath(src, sourceRoot) {
     let s = src;
     if (sourceRoot && !/^[a-z]+:/i.test(s)) {
         s = sourceRoot.replace(/\/?$/, "/") + s;
     }
-    s = s.replace(/^webpack:\/\/\/?/, "").replace(/^file:\/\//, "");
-    // A URL (`http://host/src/a.ts`, Vite's `/@fs/…`) keeps only its path.
-    const m = /^[a-z]+:\/\/[^/]*(\/.*)$/i.exec(s);
-    if (m)
-        s = m[1];
+    // Keep virtual source identity intact. Stripping the scheme turned
+    // webpack://_N_E/../src/utils.ts (a foreign source) into a plausible
+    // project path; a suffix match then attributed its lines to lib/utils.ts.
+    // Do not use URL here: it collapses the traversal we need to preserve.
+    if (/^(webpack|turbopack):\/\//.test(s))
+        return s;
+    s = s.replace(/^file:\/\//, "");
+    // External URLs keep their identity; Vite's /@fs is an explicit file path.
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(s))
+        return s;
     s = s.replace(/^\/@fs\//, "/");
     s = s.replace(/\?.*$/, "");
     // Turbopack (Next.js) roots every source at the `[project]` token —

package/dist/index.d.ts

@@ -829,8 +829,7 @@ export type ServiceImage = {
  * Runs in `defineEnvironment`, and in the daemon's runtime `startService`
  * twin, inside the VM, where the repo sits at the project root. Existence
  * checks go through the project-file resolver, so the same rules as
- * `ctx.readProjectFile` apply (a `spectest/.specignore`d path is refused
- * instead of read stale).
+ * `ctx.readProjectFile` apply.
  */
 export declare function validateServiceImage(serviceName: string, image: ServiceImage): ServiceImage;
 export interface VolumeMount {

package/dist/index.js

@@ -253,8 +253,7 @@ const BUILD_TARGET_RE = /^[^\s]+$/;
  * Runs in `defineEnvironment`, and in the daemon's runtime `startService`
  * twin, inside the VM, where the repo sits at the project root. Existence
  * checks go through the project-file resolver, so the same rules as
- * `ctx.readProjectFile` apply (a `spectest/.specignore`d path is refused
- * instead of read stale).
+ * `ctx.readProjectFile` apply.
  */
 export function validateServiceImage(serviceName, image) {
     if (image.type !== "dockerfile")

package/dist/project-files.js

@@ -9,46 +9,20 @@
 //                                 on EVERY start, warm ones included.
 //
 // A warm start happens only when the warm-template hash matches, so /workspace
-// is correct for every file that is IN that hash. It can be behind for the two
-// kinds of file the hash excludes: `spectest/tests/**` (excluded so a test-only
-// edit keeps the fast start) and anything a project lists in
-// `spectest/.specignore`.
+// is correct for every file that is IN that hash. It can be behind for the one
+// kind of file the hash excludes: `spectest/tests/**` (excluded so a test-only
+// edit keeps the fast start).
 //
 // Hence the rule below: a path under `spectest/` resolves against the app copy
 // first, because that copy is always current — this is what lets a fixture live
 // in `spectest/tests/fixtures/` and still be found after it was added. Any
 // other path resolves against /workspace, which the hash keeps current.
-//
-// The remaining hole is a file that `.specignore` excludes AND that sits outside
-// `spectest/`: /workspace holds whatever the cold start uploaded, so a later
-// edit is invisible. Nothing can repair those bytes at read time, so we refuse
-// to read them instead of returning stale content. The control plane writes the
-// exact path list it excluded (env.rs) into ENV_IGNORED_FILE.
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import path from "node:path";
 /** The extracted repo — `ctx.projectRoot`. */
 export const WORKSPACE = process.env.SPECTEST_WORKSPACE ?? "/workspace";
 /** The app dir; the user's `spectest/` sits directly under it. */
 export const APP_DIR = process.env.SPECTEST_APP_DIR ?? "/opt/spectest/app";
-/** Paths (repo-relative) the warm-template hash skipped because of
- *  `spectest/.specignore`. Written by the control plane at env start; absent
- *  when the project ships no `.specignore`. */
-const ENV_IGNORED_FILE = "/run/spectest-env-ignored.json";
-let _envIgnored;
-function envIgnored() {
-    if (_envIgnored)
-        return _envIgnored;
-    let paths = [];
-    try {
-        const raw = JSON.parse(readFileSync(ENV_IGNORED_FILE, "utf8"));
-        paths = raw.paths ?? [];
-    }
-    catch {
-        /* No file (no .specignore, or an older env) — nothing to refuse. */
-    }
-    _envIgnored = new Set(paths);
-    return _envIgnored;
-}
 /** Project files resolved since the last take — what a test read
  *  through the SDK. Module memory: forks with the environment; the
  *  coverage capture takes and clears it after every case, so a forked
@@ -89,11 +63,6 @@ export function resolveProjectPath(p, opts = {}) {
         if (existsSync(app))
             return app;
     }
-    if (envIgnored().has(rel)) {
-        throw new Error(`project file "${p}" is excluded by the environment cache ignore rules, so the copy in the VM ` +
-            `is whatever a cold start uploaded and can be out of date. Move it under ` +
-            `spectest/tests/ (still cache-free, and always re-uploaded), or drop the pattern.`);
-    }
     return path.join(WORKSPACE, rel);
 }
 /** {@link resolveProjectPath}, but a missing file is an error that names every

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.2",
   "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/coverage.test.ts

@@ -297,6 +297,34 @@ describe.if(hasNode)("nodeCoverage hook (real node)", () => {
     }
   });
 
+  test("recompiled scripts at the same URL get distinct records within and across processes", async () => {
+    const dir = await scratch();
+    const sharedUrl = `file://${path.join(dir, "shared.js")}`;
+    await fs.writeFile(path.join(dir, "main.js"), `
+      const vm = require("node:vm");
+      vm.runInThisContext("globalThis.value = 1;", { filename: ${JSON.stringify(sharedUrl)} });
+      vm.runInThisContext("globalThis.value = 2;", { filename: ${JSON.stringify(sharedUrl)} });
+    `);
+    expect(await runOnce(dir, "main.js")).toBe(0);
+    const first = (await Promise.all((await dumpsIn(dir)).map((n) => readDump(dir, n))))
+      .flatMap((d) => d.result).filter((s) => s.url === sharedUrl);
+    expect(first).toHaveLength(2);
+    const ids = new Set(first.map((s) => s.spectestScript));
+    expect(ids.size).toBe(2); // same URL, line lengths and extents, different source
+    for (const id of ids) {
+      const record = JSON.parse(await fs.readFile(path.join(dir, NODE_COVERAGE_SCRIPTS_SUBDIR, `${id}.json`), "utf8"));
+      expect(record.spectestScript.url).toBe(sharedUrl);
+      expect(record.spectestScript.sourceHash).toMatch(/^[a-f0-9]{64}$/);
+    }
+    // A second process shares the marker directory. Identical descriptors
+    // deduplicate, but must never borrow the other compilation's identity.
+    expect(await runOnce(dir, "main.js")).toBe(0);
+    const all = (await Promise.all((await dumpsIn(dir)).map((n) => readDump(dir, n))))
+      .flatMap((d) => d.result).filter((s) => s.url === sharedUrl);
+    expect(all).toHaveLength(4);
+    expect(new Set(all.map((s) => s.spectestScript))).toEqual(ids);
+  });
+
   test("short-lived CLI processes write at exit; the map next to the script is recorded once, no NODE_V8_COVERAGE", async () => {
     const dir = await scratch();
     await fs.writeFile(path.join(dir, "cli.js"), "function used() { return 1 }\nfunction unused() { return 2 }\nused();\n");

package/src/coverage.ts

@@ -342,6 +342,8 @@ export const NODE_COVERAGE_DUMP_PREFIX = "node-";
  *   source map: the inline `data:` map in the text, the file the last
  *   `sourceMappingURL` comment names, or `<script>.map` next to the
  *   script; `sourcesContent` dropped (the sources are the repository).
+ *   Records are keyed by their descriptor and compiled-source hash, not
+ *   their URL: a recompilation can reuse a URL with different source.
  *   "Once per branch" is a marker file under `.spectest/scripts/`: the
  *   directory is shared by every process of the service and forks with
  *   the environment, so a record written at bring-up or by an ancestor
@@ -388,7 +390,9 @@ export const NODE_COVERAGE_HOOK = `"use strict";
   const SELF = url.pathToFileURL(__filename).href;
   const SCRIPTS = path.join(dir, ${JSON.stringify(NODE_COVERAGE_SCRIPTS_SUBDIR)});
   const MARKERS = path.join(dir, ${JSON.stringify(NODE_COVERAGE_MARKERS_SUBDIR)});
-  const known = new Set();
+  // V8 script ids identify a compiled script within this process. A URL
+  // can be reused by another process, vm context, or compilation.
+  const known = new Map();
   let seq = 0;
 
   function isApp(u) {
@@ -521,7 +525,6 @@ export const NODE_COVERAGE_HOOK = `"use strict";
     fs.renameSync(tmp, file);
   }
   function describe(s, source) {
-    const id = idOf(s.url);
     let scriptPath = null;
     try {
       scriptPath = url.fileURLToPath(s.url);
@@ -529,16 +532,20 @@ export const NODE_COVERAGE_HOOK = `"use strict";
     const text = typeof source === "string" ? source : null;
     const record = {
       url: s.url,
+      sourceHash: text !== null ? crypto.createHash("sha256").update(text).digest("hex") : null,
       lineLengths: text !== null ? lineLengths(text) : null,
       functions: s.functions.map(function (f) {
         return [f.functionName, f.ranges[0].startOffset, f.ranges[0].endOffset];
       }),
       sourceMap: text !== null && scriptPath !== null ? readMap(scriptPath, text) : null,
     };
-    writeAtomic(path.join(SCRIPTS, id + ".json"), JSON.stringify({ spectestScript: record }));
-    try {
+    const document = JSON.stringify({ spectestScript: record });
+    const id = idOf(document);
+    if (!fs.existsSync(path.join(MARKERS, id))) {
+      writeAtomic(path.join(SCRIPTS, id + ".json"), document);
       fs.writeFileSync(path.join(MARKERS, id), "");
-    } catch (e) {}
+    }
+    return id;
   }
   function take() {
     const res = post("Profiler.takePreciseCoverage");
@@ -559,9 +566,7 @@ export const NODE_COVERAGE_HOOK = `"use strict";
     if (kept.length === 0 && units.size === 0) return;
     const fresh = [];
     for (const s of kept) {
-      if (known.has(s.url)) continue;
-      known.add(s.url);
-      if (!fs.existsSync(path.join(MARKERS, idOf(s.url)))) fresh.push(s);
+      if (!known.has(s.scriptId)) fresh.push(s);
     }
     if (fresh.length > 0) {
       try {
@@ -572,7 +577,7 @@ export const NODE_COVERAGE_HOOK = `"use strict";
       for (const s of fresh) {
         const r = post("Debugger.getScriptSource", { scriptId: s.scriptId });
         try {
-          describe(s, r && r.scriptSource);
+          known.set(s.scriptId, describe(s, r && r.scriptSource));
         } catch (e) {}
       }
       post("Debugger.disable");
@@ -588,7 +593,7 @@ export const NODE_COVERAGE_HOOK = `"use strict";
       result: kept.map(function (s) {
         return {
           url: s.url,
-          spectestScript: idOf(s.url),
+          spectestScript: known.get(s.scriptId) || null,
           functions: s.functions.filter(ran).map(function (f) {
             const first = f.ranges[0];
             const out = [first.startOffset, first.endOffset - first.startOffset, first.count];

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/harness/browser-coverage.test.ts

@@ -41,10 +41,10 @@ describe("source maps", () => {
       mappings: "AAAA,ICAA;ACIA",
     });
     expect(map).not.toBeNull();
-    expect(map!.sources).toEqual(["src/a.ts", "node_modules/x.js", "src/b.ts"]);
+    expect(map!.sources).toEqual(["webpack:///./src/a.ts", "webpack:///./node_modules/x.js", "src/b.ts"]);
     const files = mapToOriginal(map!, new Map([[1, 2], [2, 0]]));
-    expect([...files.keys()]).toEqual(["src/a.ts", "src/b.ts"]);
-    expect(files.get("src/a.ts")!.get(1)).toBe(2);
+    expect([...files.keys()]).toEqual(["webpack:///./src/a.ts", "src/b.ts"]);
+    expect(files.get("webpack:///./src/a.ts")!.get(1)).toBe(2);
     expect(files.get("src/b.ts")!.get(5)).toBe(0);
   });
 
@@ -54,9 +54,12 @@ describe("source maps", () => {
     expect(decodeSourceMap("nope")).toBeNull();
   });
 
-  test("normalizeSourcePath strips schemes, roots and queries", () => {
-    expect(normalizeSourcePath("webpack:///./src/a.ts")).toBe("src/a.ts");
-    expect(normalizeSourcePath("http://app.test/src/a.ts?t=1")).toBe("/src/a.ts");
+  test("normalizeSourcePath preserves namespaces and external origins", () => {
+    expect(normalizeSourcePath("webpack:///./src/a.ts")).toBe("webpack:///./src/a.ts");
+    expect(normalizeSourcePath("webpack://_N_E/../src/utils.ts")).toBe("webpack://_N_E/../src/utils.ts");
+    expect(normalizeSourcePath("webpack://_N_E/./lib/utils.ts")).toBe("webpack://_N_E/./lib/utils.ts");
+    expect(normalizeSourcePath("turbopack:///[project]/src/a.ts")).toBe("turbopack:///[project]/src/a.ts");
+    expect(normalizeSourcePath("http://app.test/src/a.ts?t=1")).toBe("http://app.test/src/a.ts?t=1");
     expect(normalizeSourcePath("/@fs/repo/src/a.ts")).toBe("/repo/src/a.ts");
     expect(normalizeSourcePath("a.ts", "/app/src")).toBe("/app/src/a.ts");
     expect(normalizeSourcePath("file:///app/src/a.ts")).toBe("/app/src/a.ts");

package/src/harness/browser-coverage.ts

@@ -119,21 +119,26 @@ export function decodeVlq(segment: string): number[] {
 }
 
 /**
- * Normalise a source-map `sources` entry to a plain path. Bundlers prefix
+ * Normalise a source-map `sources` entry without discarding its identity. Bundlers prefix
  * their own scheme (`webpack:///./src/a.ts`), dev servers serve absolute
  * URLs paths (`/src/a.ts`), builds write relative ones (`../src/a.ts`).
- * The server maps these onto the repo by suffix, so all that matters here
- * is stripping what is not a path.
+ * The server validates file identity against the repository. Preserve
+ * virtual namespaces and external URLs; losing them makes foreign
+ * sources indistinguishable from project files.
  */
 export function normalizeSourcePath(src: string, sourceRoot?: string): string {
   let s = src;
   if (sourceRoot && !/^[a-z]+:/i.test(s)) {
     s = sourceRoot.replace(/\/?$/, "/") + s;
   }
-  s = s.replace(/^webpack:\/\/\/?/, "").replace(/^file:\/\//, "");
-  // A URL (`http://host/src/a.ts`, Vite's `/@fs/…`) keeps only its path.
-  const m = /^[a-z]+:\/\/[^/]*(\/.*)$/i.exec(s);
-  if (m) s = m[1];
+  // Keep virtual source identity intact. Stripping the scheme turned
+  // webpack://_N_E/../src/utils.ts (a foreign source) into a plausible
+  // project path; a suffix match then attributed its lines to lib/utils.ts.
+  // Do not use URL here: it collapses the traversal we need to preserve.
+  if (/^(webpack|turbopack):\/\//.test(s)) return s;
+  s = s.replace(/^file:\/\//, "");
+  // External URLs keep their identity; Vite's /@fs is an explicit file path.
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(s)) return s;
   s = s.replace(/^\/@fs\//, "/");
   s = s.replace(/\?.*$/, "");
   // Turbopack (Next.js) roots every source at the `[project]` token —

package/src/index.ts

@@ -1272,8 +1272,7 @@ const BUILD_TARGET_RE = /^[^\s]+$/;
  * Runs in `defineEnvironment`, and in the daemon's runtime `startService`
  * twin, inside the VM, where the repo sits at the project root. Existence
  * checks go through the project-file resolver, so the same rules as
- * `ctx.readProjectFile` apply (a `spectest/.specignore`d path is refused
- * instead of read stale).
+ * `ctx.readProjectFile` apply.
  */
 export function validateServiceImage(serviceName: string, image: ServiceImage): ServiceImage {
   if (image.type !== "dockerfile") return image;

package/src/project-files.ts

@@ -9,23 +9,16 @@
 //                                 on EVERY start, warm ones included.
 //
 // A warm start happens only when the warm-template hash matches, so /workspace
-// is correct for every file that is IN that hash. It can be behind for the two
-// kinds of file the hash excludes: `spectest/tests/**` (excluded so a test-only
-// edit keeps the fast start) and anything a project lists in
-// `spectest/.specignore`.
+// is correct for every file that is IN that hash. It can be behind for the one
+// kind of file the hash excludes: `spectest/tests/**` (excluded so a test-only
+// edit keeps the fast start).
 //
 // Hence the rule below: a path under `spectest/` resolves against the app copy
 // first, because that copy is always current — this is what lets a fixture live
 // in `spectest/tests/fixtures/` and still be found after it was added. Any
 // other path resolves against /workspace, which the hash keeps current.
-//
-// The remaining hole is a file that `.specignore` excludes AND that sits outside
-// `spectest/`: /workspace holds whatever the cold start uploaded, so a later
-// edit is invisible. Nothing can repair those bytes at read time, so we refuse
-// to read them instead of returning stale content. The control plane writes the
-// exact path list it excluded (env.rs) into ENV_IGNORED_FILE.
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import path from "node:path";
 
 /** The extracted repo — `ctx.projectRoot`. */
@@ -33,25 +26,6 @@ export const WORKSPACE = process.env.SPECTEST_WORKSPACE ?? "/workspace";
 /** The app dir; the user's `spectest/` sits directly under it. */
 export const APP_DIR = process.env.SPECTEST_APP_DIR ?? "/opt/spectest/app";
 
-/** Paths (repo-relative) the warm-template hash skipped because of
- *  `spectest/.specignore`. Written by the control plane at env start; absent
- *  when the project ships no `.specignore`. */
-const ENV_IGNORED_FILE = "/run/spectest-env-ignored.json";
-
-let _envIgnored: Set<string> | undefined;
-function envIgnored(): Set<string> {
-  if (_envIgnored) return _envIgnored;
-  let paths: string[] = [];
-  try {
-    const raw = JSON.parse(readFileSync(ENV_IGNORED_FILE, "utf8")) as { paths?: string[] };
-    paths = raw.paths ?? [];
-  } catch {
-    /* No file (no .specignore, or an older env) — nothing to refuse. */
-  }
-  _envIgnored = new Set(paths);
-  return _envIgnored;
-}
-
 /** Project files resolved since the last take — what a test read
  *  through the SDK. Module memory: forks with the environment; the
  *  coverage capture takes and clears it after every case, so a forked
@@ -92,13 +66,6 @@ export function resolveProjectPath(p: string, opts: { record?: boolean } = {}):
     const app = path.join(APP_DIR, rel);
     if (existsSync(app)) return app;
   }
-  if (envIgnored().has(rel)) {
-    throw new Error(
-      `project file "${p}" is excluded by the environment cache ignore rules, so the copy in the VM ` +
-        `is whatever a cold start uploaded and can be out of date. Move it under ` +
-        `spectest/tests/ (still cache-free, and always re-uploaded), or drop the pattern.`,
-    );
-  }
   return path.join(WORKSPACE, rel);
 }
 

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;