@specific.dev/spectest 0.121.0 → 0.123.0

package/dist/text-match.js

@@ -1,25 +1,4 @@
-// Text comparison for the web-first matchers, and readable notes for the
-// failures that invisible characters cause.
-//
-// Two rules, and they are deliberately different:
-//
-//   * **Matching is Playwright's.** `expect(locator).toHaveText(...)` and
-//     `toContainText(...)` normalize whitespace on BOTH sides exactly as
-//     playwright's own text engine does (`normalizeWhiteSpace` in
-//     playwright-core). Without this the SDK disagreed with itself: the same
-//     string matched through `getByText("15 000 kr")` (playwright's engine,
-//     which normalizes) and failed through `toContainText("15 000 kr")`
-//     (ours, which did a raw `includes`). The case that reported it is
-//     Swedish number formatting — `Intl.NumberFormat("sv-SE")` groups
-//     thousands with U+00A0 NO-BREAK SPACE, and JavaScript's `\s` covers
-//     U+00A0, so normalization makes a typed space match it.
-//
-//   * **Diagnostics are wider.** A value the author compares themselves
-//     (`expect(body).toContain(...)`, `toHaveValue`) is still exact, as it
-//     must be — so when such a comparison fails on characters that print the
-//     same, the message has to say so. `textDifferenceNote` reports the
-//     invisible or look-alike characters that are the whole difference, and
-//     `escapeInvisible` makes the two printed strings differ on screen.
+// Text diagnostics only. Browser comparisons are delegated to Playwright.
 /** Characters that are invisible on screen (or print as an ordinary space)
  *  and their Unicode names, for a message a reader can act on. */
 const INVISIBLE_NAMES = {
@@ -82,30 +61,6 @@ const LOOKALIKES = {
 export function normalizeWhiteSpace(text) {
     return text.replace(/[\u200b\u00ad]/g, "").trim().replace(/\s+/g, " ");
 }
-function caseFold(s, opts) {
-    return opts?.ignoreCase ? s.toLowerCase() : s;
-}
-function withIgnoreCase(re, opts) {
-    if (!opts?.ignoreCase || re.flags.includes("i"))
-        return re;
-    return new RegExp(re.source, `${re.flags}i`);
-}
-/** The element's text equals `expected`, with whitespace normalized on both
- *  sides. A RegExp is tested against the normalized text. */
-export function matchesText(actual, expected, opts) {
-    const a = normalizeWhiteSpace(actual);
-    if (expected instanceof RegExp)
-        return withIgnoreCase(expected, opts).test(a);
-    return caseFold(a, opts) === caseFold(normalizeWhiteSpace(expected), opts);
-}
-/** The element's text contains `expected`, with whitespace normalized on both
- *  sides. A RegExp is tested against the normalized text. */
-export function containsText(actual, expected, opts) {
-    const a = normalizeWhiteSpace(actual);
-    if (expected instanceof RegExp)
-        return withIgnoreCase(expected, opts).test(a);
-    return caseFold(a, opts).includes(caseFold(normalizeWhiteSpace(expected), opts));
-}
 // ── Diagnostics ───────────────────────────────────────────────────────────
 /** `" "` for an invisible character, the character itself otherwise.
  *  Applied to an ALREADY `JSON.stringify`-ed string, so the result stays a
@@ -210,30 +165,3 @@ export function textDifferenceNote(actual, expected, mode) {
     }
     return "";
 }
-// ── Array forms (`toHaveText([...])` / `toContainText([...])`) ────────────
-//
-// Playwright's own rule, from its injected script: the expected items are
-// matched against the received texts **greedily, in order**, and the lengths
-// must agree for `toHaveText` but not for `toContainText`. So
-// `toContainText(["Two", "Four"])` passes against a four-row list, while
-// `toHaveText(["Two", "Four"])` does not.
-function matchesInOrder(actual, expected, item) {
-    let want = 0;
-    for (let i = 0; i < actual.length && want < expected.length; i++) {
-        if (item(actual[i], expected[want]))
-            want++;
-    }
-    return want === expected.length;
-}
-/** Every element's text equals the item at its position, and there are
- *  exactly as many elements as items. */
-export function matchesTextArray(actual, expected, opts) {
-    if (actual.length !== expected.length)
-        return false;
-    return matchesInOrder(actual, expected, (a, e) => matchesText(a, e, opts));
-}
-/** The elements' texts contain every item, in order. Extra elements between
- *  the matches are allowed. */
-export function containsTextArray(actual, expected, opts) {
-    return matchesInOrder(actual, expected, (a, e) => containsText(a, e, opts));
-}

package/dist/url-match.d.ts

@@ -9,3 +9,4 @@ export type UrlPattern = string | RegExp | ((url: URL) => boolean);
 export declare function matchesUrl(current: string, pattern: UrlPattern): boolean;
 /** Human display of a pattern, for timeline labels and failure messages. */
 export declare function describeUrlPattern(pattern: UrlPattern): string;
+export declare function globToRegExp(glob: string): RegExp;

package/dist/url-match.js

@@ -1,13 +1,9 @@
 // URL pattern matching — shared by `browser.waitForURL(...)` and
 // `expect(browser).toHaveURL(...)`.
 //
-// Both take the same pattern forms as Playwright (glob string | RegExp |
-// predicate over a `URL`), and both lower to `matchesUrl` here so the two
-// can never disagree: `waitForURL` hands playwright a predicate that calls
-// this rather than letting playwright apply its own glob dialect, and the
-// matcher polls it directly. Deliberately dependency-free so `index.ts` (the
-// module a project imports on the host, where playwright isn't installed) can
-// use it without pulling in `browser.ts`.
+// Both accept glob strings, RegExp, or predicates over a URL. waitForURL
+// uses matchesUrl; the assertion adapter passes regexes/predicates directly
+// to Playwright and compiles string globs with the same globToRegExp helper.
 /** Whether `current` (a full URL string) matches `pattern`. */
 export function matchesUrl(current, pattern) {
     if (typeof pattern === "function") {
@@ -34,9 +30,9 @@ export function describeUrlPattern(pattern) {
         return String(pattern);
     return JSON.stringify(pattern);
 }
-// Compiled globs are cached: a matcher polls the same pattern every 50ms.
+// Reuse compiled globs across waits and assertions.
 const GLOB_CACHE = new Map();
-function globToRegExp(glob) {
+export function globToRegExp(glob) {
     const hit = GLOB_CACHE.get(glob);
     if (hit)
         return hit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.121.0",
+  "version": "0.123.0",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,10 +54,11 @@
   },
   "dependencies": {
     "@kubernetes/client-node": "^1.0.0",
+    "@playwright/test": "1.61.1",
     "@xterm/headless": "^5.5.0",
     "acorn": "8.18.0",
     "dns-packet": "^5.6.1",
-    "playwright-core": "^1.61.1",
+    "playwright-core": "1.61.1",
     "ws": "^8.20.1"
   },
   "devDependencies": {

package/src/browser.ts

@@ -2082,9 +2082,8 @@ function buildBackend(
         fields,
         async () => {
           try {
-            // Always a predicate, never playwright's own glob: `matchesUrl`
-            // is then the single matching implementation shared with
-            // `expect(browser).toHaveURL`.
+            // Preserve Spectest's glob dialect. URL assertions use the same
+            // glob compiler through their native matcher adapter.
             await holder.page.waitForURL((u: URL) => matchesUrl(u.href, pattern), {
               timeout: timeoutMs,
               waitUntil: options.waitUntil ?? "commit",
@@ -2310,12 +2309,15 @@ function buildBackend(
       return instrumented(action, fields, () => fn(holder.page), opts);
     },
   };
-  // The seam `expect(browser).toHaveURL(...)` polls: a silent URL read plus
+  // The seam `expect(browser).toHaveURL(...)` uses: a native assertion plus
   // the single settled step its assertion nests under — the session twin of
   // the locator probe, and what brands this object as a browser session for
   // `expect`'s overload dispatch.
   attachBrowserProbe(backend, {
-    url: () => holder.page.url(),
+    assertURL: async (negated, expected, opts) => {
+      const { assertURL } = await import("./playwright-assertions.js");
+      await assertURL(holder.page, negated, expected, opts);
+    },
     settle: (action, waitedMs, error) =>
       backend.recordSettled(action, { url: holder.page.url() }, waitedMs, error),
   });

package/src/components/internal-fetch.test.ts

@@ -11,6 +11,7 @@ async function check(code: string, workspace?: string): Promise<void> {
     import { strict as assert } from "node:assert";
     import { s3 } from ${moduleUrl("./s3.ts")};
     import { supabase } from ${moduleUrl("./supabase.ts")};
+    import { supabaseFunctionsCoverage } from ${moduleUrl("./supabase-coverage.ts")};
     import { emailHelpers } from ${moduleUrl("./email.ts")};
     import { installFetchWrapper } from ${moduleUrl("../harness/fetch.ts")};
     import { createInstrumentationScope, runInstrumented } from ${moduleUrl("../harness/instrumentation-scope.ts")};
@@ -56,6 +57,42 @@ test.each([200, 201, 409, 403, 500])("S3 setup handles HTTP %i inside a wrapped
   `);
 });
 
+test("Supabase report writes overlap and drain before a failed capture returns", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spectest-edge-parallel-"));
+  try {
+    await check(`
+      const fs = await import("node:fs/promises");
+      const root = ${JSON.stringify(root)};
+      const adapter = supabaseFunctionsCoverage("custom/functions");
+      const slow = Promise.withResolvers();
+      const bothStarted = Promise.withResolvers();
+      let started = 0, settled = false;
+      respond = () => Response.json({ reports: [
+        { name: "edge-1.json", content: "one" },
+        { name: "edge-2.json", content: "two" },
+      ] });
+      const ctx = { service: "functions", reportDir: root, signal: AbortSignal.timeout(5000),
+        async writeReport(name, content) {
+          if (++started === 2) bothStarted.resolve();
+          if (name === "edge-1.json") throw new Error("write failed");
+          await slow.promise;
+          await fs.writeFile(root + "/" + name, content);
+        },
+      };
+      const pending = adapter.capture(ctx).then(() => null, error => { settled = true; return error; });
+      await bothStarted.promise;
+      await Bun.sleep(0);
+      assert.equal(settled, false);
+      slow.resolve();
+      assert.match((await pending).message, /write failed/);
+      respond = () => Response.json({ reports: [{ name: "edge-3.json", content: "three" }] });
+      ctx.writeReport = (name, content) => fs.writeFile(root + "/" + name, content);
+      await adapter.capture(ctx);
+      assert.deepEqual(await fs.readdir(root), ["edge-3.json"]);
+    `);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});
+
 test("S3 setup propagates transport failures", async () => {
   await check(`
     respond = () => { throw new Error("connection refused"); };
@@ -107,3 +144,34 @@ test("email helpers reject HTTP errors and retain their public event without int
     assert.equal(events.some(e => e.error), false);
   `);
 });
+
+test("automatic edge coverage uses raw fetch and replaces only its previously shipped reports", async () => {
+  const root = await mkdtemp(join(tmpdir(), "spectest-edge-capture-"));
+  try {
+    await check(`
+      const fs = await import("node:fs/promises");
+      const root = ${JSON.stringify(root)};
+      const adapter = supabaseFunctionsCoverage("custom/functions");
+      const ctx = {
+        service: "custom-functions", reportDir: root, signal: AbortSignal.timeout(5000),
+        writeReport: (name, content) => fs.writeFile(root + "/" + name, content),
+      };
+      await fs.writeFile(root + "/other.lcov", "TN:");
+      const content = JSON.stringify({ spectestVersion: 2, result: [] });
+      respond = () => Response.json({ reports: [{ name: "edge-1.json", content }] });
+      await adapter.capture(ctx);
+      respond = () => Response.json({ reports: [{ name: "edge-2.json", content }] });
+      await adapter.capture(ctx);
+      assert.deepEqual((await fs.readdir(root)).sort(), ["edge-2.json", "other.lcov"]);
+      assert.deepEqual(requests, [
+        { url: "http://custom-functions:9000/_spectest/coverage", method: "POST" },
+        { url: "http://custom-functions:9000/_spectest/coverage", method: "POST" },
+      ]);
+      respond = () => Response.json({ reports: [{ name: "../escape.json", content }] });
+      await assert.rejects(() => adapter.capture(ctx), /invalid edge coverage report/);
+      respond = () => new Response("lost worker", { status: 500 });
+      await assert.rejects(() => adapter.capture(ctx), /lost worker/);
+      assert.equal(await fs.readFile(root + "/edge-2.json", "utf8"), content);
+    `);
+  } finally { await rm(root, { recursive: true, force: true }); }
+});

package/src/components/supabase-coverage.test.ts

@@ -0,0 +1,261 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, mkdir, writeFile, readdir, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { supabase } from "./supabase.js";
+import { SUPABASE_COVERAGE_COLLECTOR, supabaseFunctionsCoverage } from "./supabase-coverage.js";
+import { isWellFormedReport } from "../harness/coverage.js";
+import type { ServiceDefinition } from "../index.js";
+
+type Report = { name: string; content: string };
+const runtime = process.env.SPECTEST_TEST_EDGE_RUNTIME;
+
+// Use Supabase's pinned v1.74.0 release executable (and its bundled libraries),
+// not stock Deno. No database, Docker daemon, or production endpoint is needed.
+// SPECTEST_TEST_EDGE_RUNTIME=/path/bin/edge-runtime bun test src/components/supabase-coverage.test.ts
+for (const layout of ["shared", "per-function", "workspace"] as const) {
+  const mode = layout === "shared" ? "shared" : "per-function";
+  test.skipIf(!runtime)(`real edge runtime: ${layout} source identity, setup and capture deltas`, async () => {
+    // /tmp is a private in-memory filesystem inside Edge Runtime. Keep sources
+    // on disk and generated helpers on a different root to exercise relocation
+    // exactly as production's /repo and /home/deno do.
+    const root = await mkdtemp(path.join(homedir(), ".spectest-edge-test-"));
+    const generated = await mkdtemp("/dev/shm/spectest-edge-test-");
+    const repository = path.join(root, "repo");
+    const functions = path.join(repository, "custom/backend/functions");
+    const oldWorkspace = process.env.SPECTEST_WORKSPACE;
+    let child: ReturnType<typeof Bun.spawn> | undefined;
+    let logs: Promise<string> | undefined;
+    // Reserve random ports; the executable starts immediately after release.
+    const reserve = () => Bun.serve({ port: 0, fetch: () => new Response() });
+    const http = reserve(), inspector = reserve();
+    const httpPort = http.port!, inspectorPort = inspector.port!;
+    http.stop(true); inspector.stop(true);
+    const base = `http://127.0.0.1:${httpPort}`;
+    try {
+      await mkdir(path.join(functions, "alpha"), { recursive: true });
+      await mkdir(path.join(functions, "beta"), { recursive: true });
+      await mkdir(path.join(repository, "packages/shared"), { recursive: true });
+      await writeFile(path.join(repository, "packages/shared/logic.ts"), [
+        'export function first(): string {', '  return "first ✓🙂";', '}',
+        'export function second(): string {', '  return "second";', '}',
+        'export function initialize(): string { return "initialized"; }',
+      ].join("\n"));
+      await writeFile(path.join(functions, "alpha/index.ts"), [
+        `import { first, second, initialize } from "${mode === "per-function" ? "shared-logic" : "../../../../packages/shared/logic.ts"}";`,
+        'initialize();',
+        'Deno.serve(req => new Response(new URL(req.url).pathname.endsWith("/first") ? first() : second()));',
+      ].join("\n"));
+      await writeFile(path.join(functions, "beta/index.ts"), 'export default { fetch() { return new Response("beta"); } };\n');
+      if (mode === "per-function") {
+        const imports = { "shared-logic": "../../../../packages/shared/logic.ts" };
+        if (layout === "workspace") {
+          await writeFile(path.join(repository, "deno.json"), JSON.stringify({
+            workspace: ["./custom/backend/functions/alpha", "./packages/shared"],
+          }));
+          await writeFile(path.join(repository, "packages/shared/deno.json"), JSON.stringify({
+            name: "@fixture/shared", version: "1.0.0", exports: "./logic.ts",
+          }));
+          await writeFile(path.join(functions, "alpha/deno.json"), JSON.stringify({ imports }));
+        } else {
+          await writeFile(path.join(functions, "alpha/deno.json"), '{"importMap":"./import_map.json"}');
+          await writeFile(path.join(functions, "alpha/import_map.json"), JSON.stringify({ imports }));
+        }
+        // More workers than runtime threads: coverage gates must keep the
+        // event loop live while all inspectors attach concurrently.
+        for (let i = 0; i < 18; i++) {
+          const dir = path.join(functions, `extra${i}`);
+          await mkdir(dir);
+          await writeFile(path.join(dir, "index.ts"), 'Deno.serve(() => new Response("extra"));\n');
+        }
+      }
+      process.env.SPECTEST_WORKSPACE = repository;
+      const parts = supabase({ name: "custom-stack", dir: "custom/backend" }).group.services({
+        name: "custom-stack", key: part => `custom-stack-${part}`,
+      });
+      const service = parts.functions as ServiceDefinition;
+      expect(service.coverage).toBeDefined();
+      const replace = (text: string) => text.replaceAll("/home/deno", generated)
+        .replaceAll("/repo", repository).replaceAll("127.0.0.1:9229", `127.0.0.1:${inspectorPort}`);
+      for (const file of service.files!) {
+        const target = replace(file.path);
+        await mkdir(path.dirname(target), { recursive: true });
+        await writeFile(target, replace(file.content));
+      }
+      child = Bun.spawn([runtime!, "start", "--main-service", path.join(generated, "main"),
+        "--port", String(httpPort), `--inspect=127.0.0.1:${inspectorPort}`], {
+        env: { ...process.env, FUNCTIONS_DIR: functions, VERIFY_JWT: "false", EDGE_RUNTIME_WORKER_POOL_SIZE: "1" }, stdout: "ignore", stderr: "pipe",
+      });
+      logs = new Response(child.stderr).text();
+      const request = async (route: string, method = "GET") => {
+        const response = await fetch(base + route, { method, signal: AbortSignal.timeout(60_000) });
+        const text = await response.text();
+        if (!response.ok) throw new Error(`${route}: ${response.status}: ${text}`);
+        return text;
+      };
+      const deadline = Date.now() + 20_000;
+      while (true) {
+        try { await request("/_spectest/health"); break; } catch (error) {
+          if (Date.now() > deadline || child.exitCode !== null) throw error;
+          await Bun.sleep(30);
+        }
+      }
+      const warmed = JSON.parse(await request("/_spectest/warm"));
+      expect(warmed.mode).toBe(mode);
+      expect(warmed.failed).toEqual({});
+      const records = new Map<string, any>();
+      const captures: Report[][] = [];
+      async function capture() {
+        const { reports } = JSON.parse(await request("/_spectest/coverage", "POST")) as { reports: Report[] };
+        captures.push(reports);
+        for (const report of reports) {
+          expect(isWellFormedReport(report.content, report.name)).toBe(true);
+          const doc = JSON.parse(report.content);
+          if (doc.spectestScript) {
+            records.set(path.basename(report.name, ".json"), doc.spectestScript);
+            expect(report.content).not.toContain("sourcesContent");
+            expect(doc.spectestScript.url.startsWith(`file://${repository}/`)).toBe(true);
+          }
+        }
+        const dump = JSON.parse(reports.find(r => /^edge-\d+\.json$/.test(r.name))!.content);
+        const names = new Set<string>();
+        for (const script of dump.result) {
+          const record = records.get(script.spectestScript);
+          expect(record).toBeDefined();
+          for (const f of script.functions) {
+            const definition = record.functions.find((d: any) => d[1] === f[0] && d[2] === f[0] + f[1]);
+            expect(definition).toBeDefined();
+            if (f[2] > 0) names.add(definition[0]);
+          }
+        }
+        return { names, dump, reports };
+      }
+      const setup = await capture();
+      expect(setup.dump.result.length).toBeGreaterThan(0);
+      expect(setup.names.has("initialize")).toBe(true);
+      expect(setup.names.has("first")).toBe(false);
+      expect(setup.names.has("second")).toBe(false);
+      expect((await capture()).dump.result).toEqual([]);
+      expect(await request("/alpha/first")).toBe("first ✓🙂");
+      const first = await capture();
+      expect(first.names.has("first")).toBe(true);
+      expect(first.names.has("second")).toBe(false);
+      expect(first.reports.every(r => !r.name.startsWith("edge-scripts/"))).toBe(true);
+      expect(await request("/alpha/second")).toBe("second");
+      const second = await capture();
+      expect(second.names.has("first")).toBe(false);
+      expect(second.names.has("second")).toBe(true);
+      expect(await request("/beta")).toBe("beta");
+      expect((await capture()).dump.result.some((s: any) => s.url.endsWith("/beta/index.ts"))).toBe(true);
+      expect((await capture()).dump.result).toEqual([]);
+      // Optional handoff to the control-plane decoder regression below.
+      if (process.env.SPECTEST_EDGE_COVERAGE_FIXTURE) {
+        const serialized = JSON.stringify(captures).replaceAll(repository, "/repo");
+        await writeFile(process.env.SPECTEST_EDGE_COVERAGE_FIXTURE + "." + layout + ".json", serialized);
+      }
+      // Ensure the fallback actually created independent workers.
+      const targets = await fetch(`http://127.0.0.1:${inspectorPort}/json/list`).then(r => r.json()) as any[];
+      expect(targets.length).toBe(mode === "shared" ? 1 : 20);
+      expect((await readdir(path.join(functions, "alpha"))).some(name => name.startsWith(".spectest"))).toBe(false);
+    } finally {
+      if (oldWorkspace === undefined) delete process.env.SPECTEST_WORKSPACE;
+      else process.env.SPECTEST_WORKSPACE = oldWorkspace;
+      if (child) { child.kill("SIGKILL"); await child.exited; }
+      const output = await logs;
+      if (output?.includes("coverage") || output?.includes("error")) console.error(output);
+      await rm(root, { recursive: true, force: true });
+      await rm(generated, { recursive: true, force: true });
+    }
+  }, 150_000);
+}
+
+test("collector rejects missing workers and latches capture gaps", async () => {
+  // Exercise failure behavior without requiring an executable. Stop its timer;
+  // the protocol itself is exercised by the real-runtime tests above.
+  const { EdgeCoverage } = await import(`data:text/javascript;base64,${Buffer.from(SUPABASE_COVERAGE_COLLECTOR).toString("base64")}`);
+  const collector = new EdgeCoverage();
+  clearInterval(collector.timer);
+  collector.ready = async () => {};
+  collector.sessions.set("lost", { ready: Promise.resolve(), post: async () => { throw new Error("lost isolate"); } });
+  await expect(collector.capture()).rejects.toThrow("lost isolate");
+  collector.sessions.clear();
+  await expect(collector.capture()).rejects.toThrow("lost isolate");
+});
+
+test("collector overlaps isolate takes and descriptors, then merges deterministically", async () => {
+  const { EdgeCoverage } = await import(`data:text/javascript;base64,${Buffer.from(SUPABASE_COVERAGE_COLLECTOR).toString("base64")}`);
+  const collector = new EdgeCoverage();
+  clearInterval(collector.timer);
+  collector.ready = async () => {};
+  const takes = [Promise.withResolvers<any>(), Promise.withResolvers<any>()];
+  const descriptions = Array.from({ length: 4 }, () => Promise.withResolvers<any>());
+  const allTaking = Promise.withResolvers<void>();
+  const allDescribing = Promise.withResolvers<void>();
+  let taking = 0, describing = 0;
+  for (let i = 0; i < 2; i++) collector.sessions.set(String(i), {
+    base: "/", prefix: "/", entry: "/generated/entry.mjs",
+    post: async (method: string) => {
+      expect(method).toBe("Profiler.takePreciseCoverage");
+      if (++taking === 2) allTaking.resolve();
+      return takes[i]!.promise;
+    },
+  });
+  collector.describe = async (_session: unknown, script: any) => {
+    if (++describing === 4) allDescribing.resolve();
+    return descriptions[Number(script.scriptId)]!.promise;
+  };
+  const script = (i: number) => ({ scriptId: String(i), url: `file:///repo/${i % 2}.ts`,
+    functions: [{ functionName: "handler", ranges: [{ startOffset: 0, endOffset: 20, count: 1 }] }] });
+  const pending = collector.capture();
+  await allTaking.promise; // neither isolate needs the other's response to start
+  takes[1]!.resolve({ result: [script(2), script(3)] });
+  takes[0]!.resolve({ result: [script(0), script(1)] });
+  await allDescribing.promise; // all scripts overlap, including within one isolate
+  for (const i of [3, 2, 1, 0]) descriptions[i]!.resolve({ id: `record-${i % 2}`, content: `descriptor-${i % 2}` });
+  const { reports } = await pending;
+  expect(reports.map((r: Report) => r.name)).toEqual(["edge-scripts/record-0.json", "edge-scripts/record-1.json", "edge-1.json"]);
+  const dump = JSON.parse(reports[2].content);
+  expect(dump.result.map((r: any) => r.url)).toEqual(["file:///repo/0.ts", "file:///repo/1.ts", "file:///repo/0.ts", "file:///repo/1.ts"]);
+});
+
+test("failed parallel captures drain pending takes and permanently reject later captures", async () => {
+  const { EdgeCoverage } = await import(`data:text/javascript;base64,${Buffer.from(SUPABASE_COVERAGE_COLLECTOR).toString("base64")}`);
+  const collector = new EdgeCoverage();
+  clearInterval(collector.timer);
+  collector.ready = async () => {};
+  const slow = Promise.withResolvers<any>();
+  const started = Promise.withResolvers<void>();
+  let takes = 0;
+  collector.sessions.set("failed", { post: async () => { takes++; throw new Error("lost isolate"); } });
+  collector.sessions.set("slow", { post: async () => { takes++; started.resolve(); return slow.promise; } });
+  let settled = false;
+  const pending = collector.capture().then(() => null, (error: Error) => { settled = true; return error; });
+  await started.promise;
+  await Bun.sleep(0);
+  expect(settled).toBe(false);
+  await expect(collector.capture()).rejects.toThrow("already in progress");
+  expect(takes).toBe(2);
+  slow.resolve({ result: [] });
+  expect((await pending)?.message).toBe("lost isolate");
+  expect(collector.records.size).toBe(0);
+  await expect(collector.capture()).rejects.toThrow("lost isolate");
+  expect(takes).toBe(2);
+});
+
+test("function discovery changes invalidate the inventory for any component directory", async () => {
+  const adapter = supabaseFunctionsCoverage("nested/backend/functions");
+  const files = ["nested/backend/functions/one/index.ts", "nested/backend/functions/_shared/helpers.ts"];
+  let config = '{"imports":{}}';
+  const ctx = { projectFiles: async () => files, readProjectFile: async () => config } as any;
+  const before = await adapter.inventory!(ctx);
+  files.push("nested/backend/functions/_private/index.ts", "unrelated/functions/two/index.ts");
+  expect(await adapter.inventory!(ctx)).toEqual(before);
+  files.push("nested/backend/functions/two/index.ts");
+  expect(await adapter.inventory!(ctx)).not.toEqual(before);
+  const added = await adapter.inventory!(ctx);
+  files.push("nested/backend/functions/two/deno.json");
+  expect(await adapter.inventory!(ctx)).not.toEqual(added);
+  const configured = await adapter.inventory!(ctx);
+  config = '{"imports":{"shared":"./other.ts"}}';
+  expect(await adapter.inventory!(ctx)).not.toEqual(configured);
+});