rea-agents 6.1.0 → 6.3.0

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -2,9 +2,168 @@ import { chmod, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { chromium, } from "playwright-core";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 const OPERATION = "capture_browser_scenario";
+const throwIfScenarioCancelled = (signal) => {
+    if (signal?.aborted === true)
+        throw new BrowserObservationError(OPERATION, "cancelled");
+};
+/** Owns one browser connection and optional private profile through cleanup retries. */
+export class PlaywrightScenarioBrowserCleanupOwner {
+    resources;
+    #browserClosed = false;
+    #profileRemoved;
+    #closePromise;
+    #eventFinalizationPromise;
+    /** Keep the narrow provider actions needed to release one opened browser. */
+    constructor(resources) {
+        this.resources = resources;
+        this.#profileRemoved = resources.removeProfile === undefined;
+    }
+    close(finishEvents, signal) {
+        const cleanup = this.#closePromise ?? this.#closeResources(finishEvents);
+        if (this.#closePromise === undefined) {
+            this.#closePromise = cleanup;
+            void cleanup.then(() => this.resources.onSettled?.(this.#browserClosed), () => {
+                if (this.#closePromise === cleanup)
+                    this.#closePromise = undefined;
+                this.resources.onSettled?.(this.#browserClosed);
+            });
+        }
+        return this.#awaitCleanup(cleanup, signal);
+    }
+    async #awaitCleanup(cleanup, signal) {
+        try {
+            await withPlaywrightExecutionBoundary(() => cleanup, 1_000, signal);
+        }
+        catch (cause) {
+            throw new BrowserObservationError(OPERATION, "cleanup_failed", {
+                cause,
+                cleanup: {
+                    reason: cause instanceof Error ? cause.message : String(cause),
+                    resources: [
+                        "browser_transport",
+                        ...(this.resources.removeProfile === undefined
+                            ? []
+                            : ["browser_profile"]),
+                    ],
+                },
+            });
+        }
+    }
+    async #closeResources(finishEvents) {
+        const failures = [];
+        const eventFinalization = (this.#eventFinalizationPromise ??=
+            Promise.resolve().then(async () => {
+                await finishEvents?.();
+            }));
+        try {
+            await eventFinalization;
+        }
+        catch (cause) {
+            failures.push(cause);
+        }
+        if (!this.#browserClosed) {
+            try {
+                await this.resources.closeBrowser();
+                this.#browserClosed = true;
+            }
+            catch (cause) {
+                failures.push(cause);
+            }
+        }
+        if (this.#browserClosed &&
+            !this.#profileRemoved &&
+            this.resources.removeProfile !== undefined) {
+            try {
+                await this.resources.removeProfile();
+                this.#profileRemoved = true;
+            }
+            catch (cause) {
+                failures.push(cause);
+            }
+        }
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1)
+            throw new AggregateError(failures, "Browser session cleanup failed");
+    }
+}
+const attachedScenarioAdmissions = new Map();
+const releaseAttachedScenario = (key, admission) => {
+    const waiter = admission.waiters.shift();
+    if (waiter === undefined) {
+        admission.active = false;
+        if (admission.cleanupOwner === undefined &&
+            attachedScenarioAdmissions.get(key) === admission)
+            attachedScenarioAdmissions.delete(key);
+        return;
+    }
+    if (waiter.onAbort !== undefined)
+        waiter.signal?.removeEventListener("abort", waiter.onAbort);
+    if (waiter.signal?.aborted === true) {
+        waiter.reject(new BrowserObservationError(OPERATION, "cancelled"));
+        releaseAttachedScenario(key, admission);
+        return;
+    }
+    waiter.resolve(createAttachedScenarioRelease(key, admission));
+};
+const createAttachedScenarioRelease = (key, admission) => {
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        releaseAttachedScenario(key, admission);
+    };
+};
+const acquireAttachedScenario = (scenario, signal) => {
+    if (signal?.aborted === true)
+        return Promise.reject(new BrowserObservationError(OPERATION, "cancelled"));
+    const key = JSON.stringify([scenario.cdp_endpoint, scenario.target_id]);
+    const admission = attachedScenarioAdmissions.get(key) ??
+        {
+            active: false,
+            waiters: [],
+            cleanupOwner: undefined,
+        };
+    attachedScenarioAdmissions.set(key, admission);
+    return new Promise((resolve, reject) => {
+        const grant = (release) => resolve({ admission, release });
+        if (!admission.active) {
+            admission.active = true;
+            grant(createAttachedScenarioRelease(key, admission));
+            return;
+        }
+        const waiter = {
+            signal,
+            resolve: (release) => grant(release),
+            reject,
+            onAbort: undefined,
+        };
+        admission.waiters.push(waiter);
+        if (signal !== undefined) {
+            const onAbort = () => {
+                const index = admission.waiters.indexOf(waiter);
+                if (index < 0)
+                    return;
+                admission.waiters.splice(index, 1);
+                signal.removeEventListener("abort", onAbort);
+                reject(new BrowserObservationError(OPERATION, "cancelled"));
+                if (!admission.active && admission.waiters.length === 0)
+                    releaseAttachedScenario(key, admission);
+            };
+            waiter.onAbort = onAbort;
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+        }
+    });
+};
 const allowedBrowserEnvironment = (environment) => {
     const allowed = [
         "DBUS_SESSION_BUS_ADDRESS",
@@ -25,12 +184,14 @@ const allowedBrowserEnvironment = (environment) => {
         .map((name) => [name, environment[name]])
         .filter((entry) => entry[1] !== undefined));
 };
-const findConnectedPage = async (browser, targetId) => {
+const findConnectedPage = async (browser, targetId, signal) => {
     for (const context of browser.contexts())
         for (const page of context.pages()) {
             const session = await context.newCDPSession(page);
             try {
+                throwIfScenarioCancelled(signal);
                 const { targetInfo } = await session.send("Target.getTargetInfo");
+                throwIfScenarioCancelled(signal);
                 if (targetInfo.targetId !== targetId)
                     continue;
                 return { context, page };
@@ -41,51 +202,108 @@ const findConnectedPage = async (browser, targetId) => {
         }
     throw new BrowserObservationError(OPERATION, "target_not_found");
 };
-const configureAttachedEnvironment = async (context, page, scenario) => {
-    await page.setViewportSize({
-        width: scenario.environment.viewport.width,
-        height: scenario.environment.viewport.height,
-    });
+const configureAttachedEnvironment = async (context, page, environment, signal) => {
+    // setViewportSize also resizes the external browser window. The scenario's
+    // CDP metrics override below supplies the viewport and expires on disconnect.
     await page.emulateMedia({
-        colorScheme: scenario.environment.color_scheme,
-        reducedMotion: scenario.environment.reduced_motion,
+        colorScheme: environment.color_scheme,
+        reducedMotion: environment.reduced_motion,
     });
+    throwIfScenarioCancelled(signal);
     const session = await context.newCDPSession(page);
+    throwIfScenarioCancelled(signal);
+    // Chromium resets these overrides when the CDP session detaches. Keep it on
+    // the scenario transport until cleanup disconnects the attached browser.
+    await session.send("Emulation.setDeviceMetricsOverride", {
+        width: environment.viewport.width,
+        height: environment.viewport.height,
+        deviceScaleFactor: environment.viewport.device_scale_factor,
+        mobile: false,
+        dontSetVisibleSize: true,
+    });
+    throwIfScenarioCancelled(signal);
+    await session.send("Emulation.setLocaleOverride", {
+        locale: environment.locale,
+    });
+    throwIfScenarioCancelled(signal);
+    await session.send("Emulation.setTimezoneOverride", {
+        timezoneId: environment.timezone,
+    });
+};
+/** Preserve an operation failure while reporting any incomplete cleanup. */
+export const failBrowserScenarioOperation = async (cleanup, primaryFailure, fallbackCleanupResources = ["browser_transport"]) => {
     try {
-        await session.send("Emulation.setDeviceMetricsOverride", {
-            width: scenario.environment.viewport.width,
-            height: scenario.environment.viewport.height,
-            deviceScaleFactor: scenario.environment.viewport.device_scale_factor,
-            mobile: false,
-        });
-        await session.send("Emulation.setLocaleOverride", {
-            locale: scenario.environment.locale,
-        });
-        await session.send("Emulation.setTimezoneOverride", {
-            timezoneId: scenario.environment.timezone,
-        });
+        await cleanup();
     }
-    finally {
-        await session.detach();
+    catch (cleanupFailure) {
+        const cleanupDetails = cleanupFailure instanceof AnalysisError &&
+            cleanupFailure.cleanup !== undefined
+            ? cleanupFailure.cleanup
+            : {
+                reason: cleanupFailure instanceof Error
+                    ? cleanupFailure.message
+                    : String(cleanupFailure),
+                resources: cleanupFailure instanceof AnalysisError
+                    ? cleanupFailure.cleanupResources
+                    : fallbackCleanupResources,
+            };
+        throw new BrowserObservationError(OPERATION, "cleanup_failed", {
+            cause: new AggregateError([primaryFailure, cleanupFailure], "Browser scenario operation and cleanup both failed", { cause: primaryFailure }),
+            cleanup: cleanupDetails,
+        });
     }
+    throw primaryFailure;
 };
-export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
-    if (scenario.browser.mode === "connect") {
-        const browser = await chromium.connectOverCDP(scenario.browser.cdp_endpoint, { timeout: 0 });
-        try {
-            const target = await findConnectedPage(browser, scenario.browser.target_id);
-            await configureAttachedEnvironment(target.context, target.page, scenario);
-            return { ...target, browser, profilePath: undefined };
-        }
-        catch (cause) {
-            await browser.close();
+const openAttachedScenarioBrowser = async (browserRequest, environment, launcher, signal) => {
+    const lease = await acquireAttachedScenario(browserRequest, signal);
+    let cleanupOwner;
+    try {
+        const priorOwner = lease.admission.cleanupOwner;
+        if (priorOwner !== undefined)
+            await priorOwner.close();
+        throwIfScenarioCancelled(signal);
+        const browser = await launcher.connectOverCDP(browserRequest.cdp_endpoint);
+        const cleanup = new PlaywrightScenarioBrowserCleanupOwner({
+            closeBrowser: () => browser.close(),
+            onSettled: (browserClosed) => {
+                if (browserClosed && lease.admission.cleanupOwner === cleanup)
+                    lease.admission.cleanupOwner = undefined;
+                lease.release();
+            },
+            removeProfile: undefined,
+        });
+        cleanupOwner = cleanup;
+        lease.admission.cleanupOwner = cleanup;
+        throwIfScenarioCancelled(signal);
+        const target = await withPlaywrightExecutionBoundary(() => findConnectedPage(browser, browserRequest.target_id, signal), undefined, signal);
+        throwIfScenarioCancelled(signal);
+        await withPlaywrightExecutionBoundary(() => configureAttachedEnvironment(target.context, target.page, environment, signal), undefined, signal);
+        return {
+            ...target,
+            browser,
+            profilePath: undefined,
+            cleanup,
+        };
+    }
+    catch (cause) {
+        if (cleanupOwner === undefined) {
+            lease.release();
             throw cause;
         }
+        const cleanup = cleanupOwner;
+        return failBrowserScenarioOperation(() => cleanup.close(), cause);
     }
+};
+/** Launch or attach using the caller-selected environment and browser engine. */
+export const openPlaywrightScenarioBrowser = async (scenario, environment, options = {}) => {
+    const launcher = options.launcher ?? chromium;
+    if (scenario.browser.mode === "connect")
+        return openAttachedScenarioBrowser(scenario.browser, scenario.environment, launcher, options.signal);
     const profilePath = await mkdtemp(join(tmpdir(), "rea-browser-scenario-"));
-    await chmod(profilePath, 0o700);
+    let context;
     try {
-        const context = await chromium.launchPersistentContext(profilePath, {
+        await chmod(profilePath, 0o700);
+        context = await launcher.launchPersistentContext(profilePath, {
             executablePath: resolve(scenario.browser.executable_path),
             headless: scenario.browser.headless,
             acceptDownloads: false,
@@ -105,43 +323,28 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
             handleSIGTERM: false,
             timeout: 0,
         });
-        const browser = context.browser();
-        if (browser === null) {
-            await context.close();
-            throw new BrowserObservationError(OPERATION, "protocol_error");
-        }
-        const page = context.pages()[0] ?? (await context.newPage());
-        return { context, page, browser, profilePath };
     }
     catch (cause) {
-        await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
-        throw cause;
+        return failBrowserScenarioOperation(() => rm(profilePath, { recursive: true, force: true, maxRetries: 3 }), cause, ["browser_profile"]);
     }
-};
-export const closePlaywrightScenarioBrowser = async ({ context, browser, profilePath }, signal) => {
-    const cleanup = (async () => {
-        try {
-            // In connect mode Playwright's Browser.close disconnects its CDP client;
-            // it does not close the externally owned browser process.
-            if (profilePath === undefined)
-                await browser.close();
-            else
-                await context.close();
-        }
-        finally {
-            if (profilePath !== undefined)
-                await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
-        }
-    })();
-    // best-effort cleanup: the bounded execution boundary below observes the
-    // same cleanup promise; this early attachment only prevents unhandled rejection.
-    void cleanup.catch(() => undefined);
-    // The shared execution boundary rejects cancellation/timeouts instead of
-    // returning a successful capture whose browser or profile may still exist.
+    const cleanup = new PlaywrightScenarioBrowserCleanupOwner({
+        closeBrowser: () => context.close(),
+        removeProfile: () => rm(profilePath, { recursive: true, force: true, maxRetries: 3 }),
+    });
     try {
-        await withPlaywrightExecutionBoundary(() => cleanup, 1_000, signal);
+        const browser = context.browser();
+        if (browser === null)
+            throw new BrowserObservationError(OPERATION, "protocol_error");
+        const page = context.pages()[0] ?? (await context.newPage());
+        return {
+            context,
+            page,
+            browser,
+            profilePath,
+            cleanup,
+        };
     }
     catch (cause) {
-        throw new BrowserObservationError(OPERATION, "cleanup_failed", { cause });
+        return failBrowserScenarioOperation(() => cleanup.close(), cause);
     }
 };

package/dist/browser/PlaywrightScenarioEvents.js

@@ -1,4 +1,4 @@
-import { browserScenarioEventSchema, } from "../domain/browserScenarioCapture.js";
+import { browserScenarioEventSchema, } from "../domain/browserScenarioCaptureValues.js";
 import { PlaywrightScenarioNetwork } from "./network/PlaywrightScenarioNetwork.js";
 /** Arrival-ordered Playwright event capture with current-step attribution. */
 export class PlaywrightScenarioEvents {

package/dist/browser/PlaywrightScenarioSession.js

@@ -1,11 +1,12 @@
 import {} from "playwright-core";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { BrowserScenarioSecrets } from "./BrowserScenarioSecrets.js";
-import { closePlaywrightScenarioBrowser, openPlaywrightScenarioBrowser, } from "./PlaywrightScenarioBrowser.js";
+import { failBrowserScenarioOperation, openPlaywrightScenarioBrowser, } from "./PlaywrightScenarioBrowser.js";
 import { performPlaywrightScenarioAction } from "./PlaywrightScenarioActions.js";
 import { capturePlaywrightStepArtifacts } from "./PlaywrightScenarioArtifacts.js";
 import { PlaywrightScenarioEvents } from "./PlaywrightScenarioEvents.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
+import { browserScenarioCaptureData, browserScenarioOperationFailure, } from "./BrowserScenarioPartialObservation.js";
 const OPERATION = "capture_browser_scenario";
 const storageSeeds = (blocks, secrets) => {
     const seeds = {};
@@ -66,10 +67,8 @@ export class PlaywrightScenarioSession {
     product = "Chromium";
     version;
     initialUrl;
-    closed = false;
     secrets;
     eventCapture;
-    signal;
     constructor(opened, options) {
         this.opened = opened;
         this.mode = options.mode;
@@ -77,7 +76,6 @@ export class PlaywrightScenarioSession {
             options.mode === "launch" ? "provider-owned" : "external";
         this.secrets = options.secrets;
         this.eventCapture = options.eventCapture;
-        this.signal = options.signal;
         this.version = opened.browser.version();
         this.initialUrl = opened.page.url();
     }
@@ -87,23 +85,28 @@ export class PlaywrightScenarioSession {
         const secrets = BrowserScenarioSecrets.resolve(scenario, environment);
         if (secrets === undefined)
             throw new BrowserObservationError(OPERATION, "secret_unavailable");
-        const opening = openPlaywrightScenarioBrowser(scenario, environment);
+        const startedAt = Date.now();
+        const opening = openPlaywrightScenarioBrowser(scenario, environment, {
+            signal: options.signal,
+        });
         let opened;
+        let events;
         try {
             opened = await withPlaywrightExecutionBoundary(() => opening, undefined, options.signal);
         }
         catch (cause) {
             void opening
-                .then((lateOpened) => closePlaywrightScenarioBrowser(lateOpened, options.signal))
+                .then((lateOpened) => lateOpened.cleanup.close(undefined, options.signal))
                 .catch((cause) => {
                 // best-effort cleanup: late-open cleanup must not mask the boundary failure.
                 void cause;
             });
             throw cause;
         }
+        let session;
         try {
             await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
-            const events = new PlaywrightScenarioEvents({
+            events = new PlaywrightScenarioEvents({
                 page: opened.page,
                 context: opened.context,
                 ownsContext: scenario.browser.mode === "launch",
@@ -112,12 +115,18 @@ export class PlaywrightScenarioSession {
                 network: scenario.capture.network,
                 ...(options.signal === undefined ? {} : { signal: options.signal }),
             });
-            const session = new PlaywrightScenarioSession(opened, {
+            session = new PlaywrightScenarioSession(opened, {
                 mode: scenario.browser.mode,
                 secrets,
                 eventCapture: events,
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
             });
+        }
+        catch (cause) {
+            return failBrowserScenarioOperation(() => opened.cleanup.close(events === undefined
+                ? undefined
+                : () => events?.finish() ?? Promise.resolve(), options.signal), cause);
+        }
+        try {
             await withPlaywrightExecutionBoundary(() => opened.page.goto(secrets.url(scenario.start_url), {
                 waitUntil: "load",
                 timeout: 0,
@@ -125,8 +134,28 @@ export class PlaywrightScenarioSession {
             return session;
         }
         catch (cause) {
-            await closePlaywrightScenarioBrowser(opened, options.signal);
-            throw cause;
+            let cleanup;
+            let cleanupFailure;
+            try {
+                cleanup = await session.close();
+            }
+            catch (failure) {
+                cleanup = "incomplete";
+                cleanupFailure = { cause: failure };
+            }
+            throw browserScenarioOperationFailure(cause, {
+                kind: "browser-scenario-observation",
+                capture: browserScenarioCaptureData({
+                    session,
+                    scenario,
+                    startedAt,
+                    steps: [],
+                    cleanup,
+                    limitations: [
+                        "Scenario navigation failed before the initial state was captured.",
+                    ],
+                }),
+            }, cleanupFailure);
         }
     }
     currentUrl() {
@@ -167,17 +196,7 @@ export class PlaywrightScenarioSession {
         }), undefined, signal);
     }
     async close() {
-        if (this.closed)
-            return this.mode === "launch"
-                ? "terminated-owned-process"
-                : "disconnected-external";
-        this.closed = true;
-        try {
-            await this.eventCapture.finish();
-        }
-        finally {
-            await closePlaywrightScenarioBrowser(this.opened, this.signal);
-        }
+        await this.opened.cleanup.close(() => this.eventCapture.finish());
         return this.mode === "launch"
             ? "terminated-owned-process"
             : "disconnected-external";
@@ -186,13 +205,3 @@ export class PlaywrightScenarioSession {
         return this.secrets.redact(error instanceof Error ? error.message : "browser action failed");
     }
 }
-/** Production Playwright/CDP session factory. */
-export class PlaywrightScenarioSessionFactory {
-    environment;
-    constructor(environment = process.env) {
-        this.environment = environment;
-    }
-    open(scenario, options = {}) {
-        return PlaywrightScenarioSession.open(scenario, this.environment, options);
-    }
-}

package/dist/browser/WebSourceMapFetcher.js

@@ -106,6 +106,12 @@ class SourceMapEncodingError extends Error {
         this.name = "SourceMapEncodingError";
     }
 }
+class SourceMapRedirectLocationError extends Error {
+    constructor(url, location) {
+        super(`Source-map redirect from ${JSON.stringify(url)} supplied an invalid Location URL: ${JSON.stringify(location)}.`);
+        this.name = "SourceMapRedirectLocationError";
+    }
+}
 const fetchOne = async (request, input, signal, host, budget) => {
     if (!approvedUrl(request.fetchUrl, input.allowed_origins))
         return emptySourceMapItem(request, "policy_filtered", "Declared source-map URL is outside the approved exact origins.");
@@ -131,13 +137,25 @@ const fetchOne = async (request, input, signal, host, budget) => {
             throw cause;
         if (cause instanceof SourceMapEncodingError)
             return emptySourceMapItem(request, "invalid", cause.message);
-        return emptySourceMapItem(request, "fetch_failed", cause instanceof SourceMapSizeLimitError
+        return emptySourceMapItem(request, "fetch_failed", cause instanceof SourceMapRedirectLocationError ||
+            cause instanceof SourceMapSizeLimitError ||
+            cause instanceof SourceMapDeadlineError
             ? cause.message
-            : cause instanceof SourceMapDeadlineError
-                ? cause.message
-                : "Source-map fetch or validation failed.");
+            : "Source-map fetch or validation failed.");
     }
 };
+/**
+ * Fetch redirect statuses per WHATWG Fetch (redirect status list:
+ * 301, 302, 303, 307, 308). Single owner for redirect decisions.
+ * 300/304/305/306 carry `Location` without being redirects — following
+ * them would replace the observed failure with an unrelated map.
+ * See https://fetch.spec.whatwg.org/#redirect-status
+ */
+export const isFetchRedirectStatus = (status) => status === 301 ||
+    status === 302 ||
+    status === 303 ||
+    status === 307 ||
+    status === 308;
 const fetchFollowingApprovedRedirects = async (initialUrl, allowedOrigins, signal, host) => {
     let current = initialUrl;
     const visited = new Set();
@@ -163,13 +181,21 @@ const fetchFollowingApprovedRedirects = async (initialUrl, allowedOrigins, signa
             await response.body?.cancel(signal.reason).catch(() => undefined);
             throw signal.reason;
         }
-        if (response.status < 300 || response.status >= 400)
+        // `Location` is a redirect target only for Fetch redirect statuses.
+        // Other 3xx responses retain their own HTTP failure (strict identity:
+        // never replace the observed failure with an unrelated map).
+        if (!isFetchRedirectStatus(response.status))
             return { response, fetchedUrl: current };
         const location = response.headers.get("location");
         if (location === null)
             return { response, fetchedUrl: current };
         await response.body?.cancel();
-        current = new URL(location, current).href;
+        try {
+            current = new URL(location, current).href;
+        }
+        catch {
+            throw new SourceMapRedirectLocationError(current, location);
+        }
     }
 };
 const readBoundedText = async (response, budget, maxBytes, signal) => {

package/dist/browser/assets/ScenarioScriptCapture.js

@@ -14,9 +14,9 @@ const indexResponses = (events) => {
         requests: new Map(),
     };
     for (const event of events) {
-        if (event.kind === "request" && event.transaction_id !== undefined)
+        if (event.kind === "request")
             index.requests.set(event.transaction_id, (index.requests.get(event.transaction_id) ?? 0) + 1);
-        if (event.kind === "response" && event.transaction_id !== undefined)
+        if (event.kind === "response")
             append(index.responses, event.transaction_id, event);
         if (event.kind === "network-content" && event.phase === "response")
             append(index.contents, event.source_event_sequence, event);
@@ -25,33 +25,29 @@ const indexResponses = (events) => {
 };
 const projectRequest = (request, index) => {
     const id = request.transaction_id;
-    const matches = id === undefined ? [] : (index.responses.get(id) ?? []);
+    const matches = index.responses.get(id) ?? [];
     const response = matches.length === 1 ? matches[0] : undefined;
     const bodies = response === undefined ? [] : (index.contents.get(response.sequence) ?? []);
     const body = bodies.length === 1 ? bodies[0]?.body : undefined;
-    const ambiguous = (id !== undefined && index.requests.get(id) !== 1) ||
-        matches.length > 1 ||
-        bodies.length > 1;
+    const ambiguous = index.requests.get(id) !== 1 || matches.length > 1 || bodies.length > 1;
     return {
         source: {
             kind: "scenario-response",
-            transaction_id: id ?? null,
+            transaction_id: id,
             request_sequence: request.sequence,
             response_sequence: ambiguous ? null : (response?.sequence ?? null),
             status: ambiguous ? null : (response?.status ?? null),
         },
         url: request.url.url,
-        content: projectBody(body, id, ambiguous),
+        content: projectBody(body, ambiguous),
     };
 };
 const unavailable = (reason, message) => ({ state: "unavailable", reason, message });
-const projectBody = (body, transactionId, ambiguous) => {
+const projectBody = (body, ambiguous) => {
     if (ambiguous)
         return unavailable("ambiguous-transaction", "The capture does not identify one request, response, and content record for this transaction.");
     if (body === undefined)
-        return unavailable(transactionId === undefined
-            ? "transaction-identity-unavailable"
-            : "response-content-not-retained", "No selected, completed script response bytes were retained for this request.");
+        return unavailable("response-content-not-retained", "No selected, completed script response bytes were retained for this request.");
     if (body.state === "unavailable")
         return unavailable(body.reason, body.message);
     if (body.state !== "captured")

package/dist/browser/assets/ScriptCaptureAdapters.js

@@ -1,4 +1,4 @@
-import { webPageInspectionSchema } from "../../domain/browserObservation.js";
+import { webPageInspectionSchema } from "../../domain/browserObservationSchemas.js";
 import { browserScenarioCaptureSchema } from "../../domain/browserScenarioCapture.js";
 import { parseEvidence } from "../../domain/evidence.js";
 import { pageScripts } from "./PageScriptCapture.js";