rea-agents 6.1.0 → 6.2.0

package/dist/browser/CdpPageCaptureScripts.js

@@ -1,5 +1,5 @@
 import { reconcileCapturedWebScript, stableWebScriptKey, } from "../domain/webInventory.js";
-import { requiredRecord, sourceExcluded, sourceResult, cdpStringValue, } from "./CdpCaptureValues.js";
+import { requiredScriptSource, sourceExcluded, sourceResult, } from "./CdpCaptureValues.js";
 export const captureScripts = async (options) => {
     const { context, events, rawResources, resources, frameIds } = options;
     const state = {
@@ -42,8 +42,7 @@ const buildScriptDraft = async (script, state) => {
 };
 const captureScriptSource = async (script, state) => {
     const { context } = state;
-    const result = requiredRecord(await context.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, context.sessionId, context.signal));
-    const content = cdpStringValue(result.scriptSource) ?? "";
+    const content = requiredScriptSource(await context.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, context.sessionId, context.signal), context.operation);
     return sourceResult(content);
 };
 const keyAndBuildInventory = (drafts, scriptCount) => {

package/dist/browser/CdpSafeMetadata.js

@@ -56,7 +56,7 @@ const parseCsp = (value, baseUrl, allowedOrigins) => {
     for (const rawDirective of (value ?? "").split(";")) {
         const [rawName, ...tokens] = rawDirective.trim().split(/\s+/u);
         const name = (rawName ?? "").toLowerCase();
-        if (!/^[a-z][a-z0-9-]*$/u.test(name))
+        if (!/^[a-z][a-z0-9\x2d]*$/u.test(name))
             continue;
         const sources = [];
         for (const token of tokens) {
@@ -79,9 +79,9 @@ const parseCsp = (value, baseUrl, allowedOrigins) => {
 };
 const cspSource = (token, baseUrl, allowedOrigins) => {
     const lower = token.toLowerCase();
-    if (/^'[a-z0-9-]+'$/u.test(lower))
+    if (/^'[a-z0-9\x2d]+'$/u.test(lower))
         return { kind: "keyword", value: lower };
-    if (/^[a-z][a-z0-9+.-]*:$/u.test(lower))
+    if (/^[a-z][a-z0-9+.\x2d]*:$/u.test(lower))
         return { kind: "scheme", value: lower };
     const hostOrigin = cspHostSourceOrigin(token, baseUrl);
     if (hostOrigin === undefined)
@@ -98,14 +98,14 @@ const cspSource = (token, baseUrl, allowedOrigins) => {
  * `undefined` when the token is not a host-source at all.
  */
 const cspHostSourceOrigin = (token, baseUrl) => {
-    const match = /^(?:([a-z][a-z0-9+.-]*):\/\/)?([^/?#]+)(?:\/[^?#]*)?$/iu.exec(token);
+    const match = /^(?:([a-z][a-z0-9+.\x2d]*):\/\/)?([^\x2f?#]+)(?:\/[^?#]*)?$/iu.exec(token);
     const authority = match?.[2];
     if (authority === undefined || authority.length === 0)
         return undefined;
     const scheme = (match?.[1] ?? schemeOf(baseUrl))?.toLowerCase();
-    if (scheme === undefined || !/^[a-z][a-z0-9+.-]*$/u.test(scheme))
+    if (scheme === undefined || !/^[a-z][a-z0-9+.\x2d]*$/u.test(scheme))
         return undefined;
-    if (!/^(?:\*|(?:\*\.)?[a-z0-9-]+(?:\.[a-z0-9-]+)*\.?)(?::(?:\*|\d+))?$/iu.test(authority))
+    if (!/^(?:\*|(?:\*\.)?[a-z0-9\x2d]+(?:\.[a-z0-9\x2d]+)*\.?)(?::(?:\*|\d+))?$/iu.test(authority))
         return undefined;
     if (authority.includes("*"))
         return null;
@@ -194,7 +194,7 @@ const linkParameters = (value) => {
         const name = (separator < 0 ? raw : raw.slice(0, separator))
             .trim()
             .toLowerCase();
-        if (!/^[a-z][a-z0-9-]*$/u.test(name))
+        if (!/^[a-z][a-z0-9\x2d]*$/u.test(name))
             continue;
         const parameter = separator < 0 ? "" : raw.slice(separator + 1).trim();
         parameters.set(name, unquote(parameter));
@@ -221,7 +221,7 @@ const permissionFeatures = (value) => [
     ...new Set((value ?? "")
         .split(",")
         .map((entry) => entry.split("=", 1)[0]?.trim().toLowerCase() ?? "")
-        .filter((feature) => /^[a-z][a-z0-9-]*$/u.test(feature))),
+        .filter((feature) => /^[a-z][a-z0-9\x2d]*$/u.test(feature))),
 ].sort();
 const wellKnownHint = (url) => {
     try {
@@ -259,7 +259,7 @@ const referrerPolicy = (value) => {
         const token = raw.trim().toLowerCase();
         if (token === "")
             continue;
-        if (!/^[a-z-]+$/u.test(token))
+        if (!/^[a-z\x2d]+$/u.test(token))
             return null;
         if (referrerPolicies.has(token))
             policy = token;
@@ -268,7 +268,7 @@ const referrerPolicy = (value) => {
 };
 const policyToken = (value) => {
     const token = (value ?? "").trim().toLowerCase();
-    return /^[a-z][a-z0-9_.-]*$/u.test(token) ? token : null;
+    return /^[a-z][a-z0-9_.\x2d]*$/u.test(token) ? token : null;
 };
 const nonnegativeInteger = (value) => {
     const number = numberValue(value === undefined ? undefined : Number(value));

package/dist/browser/PlaywrightBrowserScenarioProvider.js

@@ -1,17 +1,11 @@
-import { browserScenarioCaptureSchema, classifyBrowserScenarioCompleteness, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
+import { browserScenarioCaptureSchema, } from "../domain/browserScenarioCapture.js";
+import { classifyBrowserScenarioCompleteness, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCaptureValues.js";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
+import { browserScenarioCleanupObservation, browserScenarioOperationFailure, browserScenarioCaptureData, } from "./BrowserScenarioPartialObservation.js";
 const OPERATION = "capture_browser_scenario";
-let defaultFactory;
-const lazyPlaywrightFactory = {
-    async open(scenario, options) {
-        defaultFactory ??= import("./PlaywrightScenarioSession.js").then(({ PlaywrightScenarioSessionFactory }) => new PlaywrightScenarioSessionFactory());
-        return (await defaultFactory).open(scenario, options);
-    },
-};
-export { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const SNAPSHOT_KINDS = [
     "screenshot",
@@ -147,7 +141,7 @@ const runScenario = async (factory, scenario, options) => {
     const startedAt = Date.now();
     const session = await factory.open(scenario, options.signal === undefined ? {} : { signal: options.signal });
     const steps = [];
-    let cleanup;
+    let operationOutcome = { ok: true };
     try {
         steps.push(await initialStep({
             session,
@@ -169,49 +163,70 @@ const runScenario = async (factory, scenario, options) => {
             failed ||= step.status !== "completed";
         }
     }
-    finally {
-        cleanup = await session.close();
+    catch (cause) {
+        operationOutcome = { ok: false, cause };
+    }
+    let cleanupOutcome;
+    try {
+        cleanupOutcome = { ok: true, cleanup: await session.close() };
+    }
+    catch (cause) {
+        cleanupOutcome = { ok: false, cause };
     }
-    const events = session.events();
+    if (!cleanupOutcome.ok) {
+        const cleanup = browserScenarioCleanupObservation(cleanupOutcome.cause);
+        const partialObservation = {
+            kind: "browser-scenario-observation",
+            capture: browserScenarioCaptureData({
+                session,
+                scenario,
+                startedAt,
+                steps,
+                cleanup: "incomplete",
+                limitations: [
+                    "Scenario observations are partial because browser cleanup could not be confirmed.",
+                ],
+            }),
+        };
+        if (!operationOutcome.ok)
+            throw browserScenarioOperationFailure(operationOutcome.cause, partialObservation, { cause: cleanupOutcome.cause });
+        throw new BrowserObservationError(OPERATION, "cleanup_failed", {
+            cause: cleanupOutcome.cause,
+            cleanup,
+            partialObservation,
+            detail: `Browser scenario cleanup could not be confirmed: ${cleanup.reason}. Collected steps and events are retained in partial_observation. Review the reported resources before retrying.`,
+        });
+    }
+    if (!operationOutcome.ok)
+        throw browserScenarioOperationFailure(operationOutcome.cause, {
+            kind: "browser-scenario-observation",
+            capture: browserScenarioCaptureData({
+                session,
+                scenario,
+                startedAt,
+                steps,
+                cleanup: cleanupOutcome.cleanup,
+                limitations: [
+                    "Scenario capture ended after an operation failed; uncollected steps are not represented.",
+                ],
+            }),
+        });
     const completeness = globalCompleteness(scenario, session, steps);
     return browserScenarioCaptureSchema.parse({
-        browser: {
-            mode: session.mode,
-            process_ownership: session.processOwnership,
-            cleanup,
-            product: session.product,
-            version: session.version,
-        },
-        scenario: {
-            start_origin: new URL(scenario.start_url.url).origin,
-            action_count: scenario.actions.length,
-            secret_references: scenario.secrets.map(({ secret_id: id }) => id).sort(),
-            network_content: scenario.capture.network,
-        },
-        duration_ms: Date.now() - startedAt,
-        steps,
-        events,
+        ...browserScenarioCaptureData({
+            session,
+            scenario,
+            startedAt,
+            steps,
+            cleanup: cleanupOutcome.cleanup,
+        }),
         completeness,
-        limitations: [
-            "Event sequence records provider receipt order; simultaneous browser causality is not inferred.",
-            "Network content is retained only when selected; response bytes are browser-decoded, not compressed wire bytes.",
-            "Request bytes are limited to what Playwright exposes; not_exposed does not establish body absence or multipart file coverage.",
-            "Network content reads settle within 5 seconds each and never wait for unfinished responses or refetch them.",
-            "Playwright scenario events do not expose request initiator stacks; receipt order does not prove causality.",
-            "Storage values are hashed only after declared-secret redaction.",
-            ...(session.eventLimitations?.() ?? []),
-            ...(session.mode === "connect"
-                ? [
-                    "CDP attachment cannot recover pre-attach events or guarantee launch-time context options.",
-                ]
-                : []),
-        ],
     });
 };
 /** Controlled Playwright/CDP scenario driver with exact process ownership. */
 export class PlaywrightBrowserScenarioProvider {
     factory;
-    constructor(factory = lazyPlaywrightFactory) {
+    constructor(factory) {
         this.factory = factory;
     }
     identity() {

package/dist/browser/PlaywrightElectronActiveActions.js

@@ -1,63 +1,9 @@
 import { z } from "zod";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
+import { electronActiveTimelineEventSchema, } from "../domain/javascript/electronActiveObservation.js";
 const OPERATION = "capture_electron_scenario";
-const hookEventSchema = z.strictObject({
-    sequence: z.number().int().min(1),
-    correlation_id: z.string().nullable(),
-    kind: z.enum([
-        "main-handler-invocation",
-        "main-event-invocation",
-        "utility-process-fork",
-        "utility-process-message",
-        "ipc-main-to-renderer",
-        "ipc-utility-to-main",
-        "ipc-renderer-send",
-        "ipc-renderer-invoke",
-        "ipc-renderer-post-message",
-        "app-lifecycle",
-        "window-lifecycle",
-        "web-contents-lifecycle",
-        "navigation",
-        "shell-attempt",
-        "process-lifecycle",
-        "permission",
-        "popup-attempt",
-        "download",
-        "protocol",
-        "preload",
-        "native-addon",
-        "updater",
-        "error",
-    ]),
-    event: z.string().nullable(),
-    phase: z.enum(["attempted", "completed", "blocked", "failed", "observed"]),
-    channel: z.string().nullable(),
-    direction: z
-        .enum([
-        "renderer-to-main",
-        "main-to-renderer",
-        "main-to-utility",
-        "utility-to-main",
-    ])
-        .nullable(),
-    sender: z.string().nullable(),
-    receiver: z.string().nullable(),
-    frame: z.string().nullable(),
-    target: z.string().nullable(),
-    argument_shapes: z.array(z.string()),
-    result_shape: z.string().nullable(),
-    process_type: z.string().nullable(),
-    source: z.string(),
-    capture_method: z.enum(["api-wrapper", "event-emitter", "process-hook"]),
-    artifact_path: z.string().nullable(),
-    artifact_sha256: z
-        .string()
-        .regex(/^[a-f0-9]{64}$/u)
-        .nullable(),
-    error: z.boolean(),
-});
 const hookSnapshotSchema = z.strictObject({
-    events: z.array(hookEventSchema),
+    events: z.array(electronActiveTimelineEventSchema),
     retention_budget_bytes: z.number().int().min(0),
     estimated_retained_bytes: z.number().int().min(0),
     event_serialized_byte_upper_bound: z.number().int().min(0),

package/dist/browser/PlaywrightElectronActiveProvider.js

@@ -14,12 +14,16 @@ import { runElectronActions, readApplicationState, runWithExecutionLimits, } fro
 import { projectElectronActiveCapture } from "./PlaywrightElectronActiveProjection.js";
 const OPERATION = "capture_electron_scenario";
 const STARTUP_TIMEOUT_MS = 60_000;
-/** Public identity for provider-owned Electron runtime experiments. */
-export { PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY } from "./providerIdentities.js";
 import { PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY } from "./providerIdentities.js";
 const hookPath = fileURLToPath(new URL("../../scripts/electron-active-hook.cjs", import.meta.url));
 /** Launch an owned Electron application through the official Playwright API. */
 export class PlaywrightElectronActiveProvider {
+    environment;
+    launch;
+    constructor(environment, launch = (options) => electron.launch(options)) {
+        this.environment = environment;
+        this.launch = launch;
+    }
     identity() {
         return PLAYWRIGHT_ELECTRON_ACTIVE_PROVIDER_IDENTITY;
     }
@@ -42,10 +46,10 @@ export class PlaywrightElectronActiveProvider {
             const captureBaseline = await systemProcessOwnershipHost.captureBaseline?.(options.signal);
             if (options.signal?.aborted)
                 throw new BrowserObservationError(OPERATION, "cancelled");
-            application = await electron.launch({
+            application = await this.launch({
                 executablePath: paths.executable,
                 cwd: paths.root,
-                env: safeElectronEnvironment(runId),
+                env: safeElectronEnvironment(this.environment, runId),
                 args: ["-r", hookPath, paths.application, ...input.args],
                 timeout: Math.max(1, startupDeadline - Date.now()),
             });
@@ -258,7 +262,7 @@ const canonicalPaths = async (input) => {
         : await realpath(input.application_root);
     return { executable, application, root };
 };
-const safeElectronEnvironment = (runId) => Object.fromEntries([
+const safeElectronEnvironment = (environment, runId) => Object.fromEntries([
     ...[
         "HOME",
         "LANG",
@@ -269,7 +273,7 @@ const safeElectronEnvironment = (runId) => Object.fromEntries([
         "DISPLAY",
         "WAYLAND_DISPLAY",
     ]
-        .map((name) => [name, process.env[name]])
+        .map((name) => [name, environment[name]])
         .filter((entry) => entry[1] !== undefined),
     ["REA_PROCESS_RUN_ID", runId],
 ]);

package/dist/browser/PlaywrightScenarioArtifacts.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
-import { browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
+import { browserStepArtifactsSchema, } from "../domain/browserScenarioCaptureValues.js";
 const historyValueSchema = z.strictObject({
     length: z.number().int().min(0),
     navigation_entries: z.array(z.strictObject({

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -2,9 +2,90 @@ 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";
+/** 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.catch(() => {
+                if (this.#closePromise === cleanup)
+                    this.#closePromise = undefined;
+            });
+        }
+        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 allowedBrowserEnvironment = (environment) => {
     const allowed = [
         "DBUS_SESSION_BUS_ADDRESS",
@@ -69,23 +150,57 @@ const configureAttachedEnvironment = async (context, page, scenario) => {
         await session.detach();
     }
 };
-export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
+/** Preserve an operation failure while reporting any incomplete cleanup. */
+export const failBrowserScenarioOperation = async (cleanup, primaryFailure, fallbackCleanupResources = ["browser_transport"]) => {
+    try {
+        await cleanup();
+    }
+    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;
+};
+/** Launch or attach using the caller-selected environment and browser engine. */
+export const openPlaywrightScenarioBrowser = async (scenario, environment, launcher = chromium) => {
     if (scenario.browser.mode === "connect") {
-        const browser = await chromium.connectOverCDP(scenario.browser.cdp_endpoint, { timeout: 0 });
+        const browser = await launcher.connectOverCDP(scenario.browser.cdp_endpoint, { timeout: 0 });
+        const cleanup = new PlaywrightScenarioBrowserCleanupOwner({
+            closeBrowser: () => browser.close(),
+            removeProfile: undefined,
+        });
         try {
             const target = await findConnectedPage(browser, scenario.browser.target_id);
             await configureAttachedEnvironment(target.context, target.page, scenario);
-            return { ...target, browser, profilePath: undefined };
+            return {
+                ...target,
+                browser,
+                profilePath: undefined,
+                cleanup,
+            };
         }
         catch (cause) {
-            await browser.close();
-            throw cause;
+            return failBrowserScenarioOperation(() => cleanup.close(), cause);
         }
     }
     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 +220,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 {