rea-agents 6.2.0 → 6.4.0

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -3,9 +3,14 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { chromium, } from "playwright-core";
 import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { isLiteralLoopbackHostname } from "../domain/browserObservation.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;
@@ -18,13 +23,17 @@ export class PlaywrightScenarioBrowserCleanupOwner {
         this.resources = resources;
         this.#profileRemoved = resources.removeProfile === undefined;
     }
+    get browserClosed() {
+        return this.#browserClosed;
+    }
     close(finishEvents, signal) {
         const cleanup = this.#closePromise ?? this.#closeResources(finishEvents);
         if (this.#closePromise === undefined) {
             this.#closePromise = cleanup;
-            void cleanup.catch(() => {
+            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);
@@ -58,6 +67,9 @@ export class PlaywrightScenarioBrowserCleanupOwner {
             await eventFinalization;
         }
         catch (cause) {
+            // A failed finalization stays failed: the memoized attempt rejects on
+            // every retry so cleanup can never report success for unfinalized
+            // events.
             failures.push(cause);
         }
         if (!this.#browserClosed) {
@@ -86,6 +98,88 @@ export class PlaywrightScenarioBrowserCleanupOwner {
             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);
+    };
+};
+/** One browser admission. The key is the discovery URL this endpoint already parses. */
+export const attachedScenarioLeaseKey = (endpoint, targetId) => {
+    const discovery = new URL("/json/version", endpoint);
+    // One CDP browser serves every loopback stack on one port, so spellings that
+    // reach it through 127.0.0.1 or ::1 must share a single admission.
+    if (isLiteralLoopbackHostname(discovery.hostname))
+        discovery.hostname = "127.0.0.1";
+    return JSON.stringify([discovery.href, targetId]);
+};
+const acquireAttachedScenario = (scenario, signal) => {
+    if (signal?.aborted === true)
+        return Promise.reject(new BrowserObservationError(OPERATION, "cancelled"));
+    const key = attachedScenarioLeaseKey(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",
@@ -102,16 +196,32 @@ const allowedBrowserEnvironment = (environment) => {
         "XAUTHORITY",
         "XDG_RUNTIME_DIR",
     ];
-    return Object.fromEntries(allowed
+    const selected = Object.fromEntries(allowed
         .map((name) => [name, environment[name]])
         .filter((entry) => entry[1] !== undefined));
+    if (process.platform !== "android")
+        return selected;
+    // Android rejects execve() for binaries below Termux's application data
+    // directory. Termux supplies an exec interceptor that rewrites those calls
+    // through the system linker and removes itself for the launched program.
+    // Playwright must retain it for its Chromium child process.
+    const prefix = environment.PREFIX;
+    if (prefix === undefined)
+        return selected;
+    return {
+        ...selected,
+        LD_PRELOAD: `${prefix}/lib/libtermux-exec.so`,
+        TERMUX_EXEC__PROC_SELF_EXE: process.execPath,
+    };
 };
-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 };
@@ -122,33 +232,33 @@ 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);
-    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,
-        });
-    }
-    finally {
-        await session.detach();
-    }
+    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"]) => {
@@ -174,28 +284,59 @@ export const failBrowserScenarioOperation = async (cleanup, primaryFailure, fall
     }
     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 launcher.connectOverCDP(scenario.browser.cdp_endpoint, { timeout: 0 });
+const openAttachedScenarioBrowser = async (browserRequest, environment, launcher, signal, retainCleanup) => {
+    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;
+        const close = () => cleanup.close();
         try {
-            const target = await findConnectedPage(browser, scenario.browser.target_id);
-            await configureAttachedEnvironment(target.context, target.page, scenario);
-            return {
-                ...target,
-                browser,
-                profilePath: undefined,
-                cleanup,
-            };
+            return await failBrowserScenarioOperation(close, cause);
         }
-        catch (cause) {
-            return failBrowserScenarioOperation(() => cleanup.close(), cause);
+        catch (failure) {
+            if (failure !== cause)
+                retainCleanup?.(close);
+            throw failure;
         }
     }
+};
+/** 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, options.retainCleanup);
     const profilePath = await mkdtemp(join(tmpdir(), "rea-browser-scenario-"));
     let context;
     try {
@@ -219,10 +360,26 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment, launc
             handleSIGINT: false,
             handleSIGTERM: false,
             timeout: 0,
+            // Termux's Chromium cannot create its renderer process through Android's
+            // executable boundary. Single-process mode keeps the browser and page in
+            // the Termux-launched process so scenario navigation remains available.
+            args: process.platform === "android"
+                ? ["--no-sandbox", "--single-process"]
+                : [],
         });
     }
     catch (cause) {
-        return failBrowserScenarioOperation(() => rm(profilePath, { recursive: true, force: true, maxRetries: 3 }), cause, ["browser_profile"]);
+        const cleanup = () => rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
+        try {
+            return await failBrowserScenarioOperation(cleanup, cause, [
+                "browser_profile",
+            ]);
+        }
+        catch (failure) {
+            if (failure !== cause)
+                options.retainCleanup?.(cleanup);
+            throw failure;
+        }
     }
     const cleanup = new PlaywrightScenarioBrowserCleanupOwner({
         closeBrowser: () => context.close(),
@@ -242,6 +399,14 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment, launc
         };
     }
     catch (cause) {
-        return failBrowserScenarioOperation(() => cleanup.close(), cause);
+        const close = () => cleanup.close();
+        try {
+            return await failBrowserScenarioOperation(close, cause);
+        }
+        catch (failure) {
+            if (failure !== cause)
+                options.retainCleanup?.(close);
+            throw failure;
+        }
     }
 };

package/dist/browser/PlaywrightScenarioSession.js

@@ -5,16 +5,21 @@ import { failBrowserScenarioOperation, openPlaywrightScenarioBrowser, } from "./
 import { performPlaywrightScenarioAction } from "./PlaywrightScenarioActions.js";
 import { capturePlaywrightStepArtifacts } from "./PlaywrightScenarioArtifacts.js";
 import { PlaywrightScenarioEvents } from "./PlaywrightScenarioEvents.js";
+import { PlaywrightScenarioStorage } from "./PlaywrightScenarioStorage.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 import { browserScenarioCaptureData, browserScenarioOperationFailure, } from "./BrowserScenarioPartialObservation.js";
 const OPERATION = "capture_browser_scenario";
-const storageSeeds = (blocks, secrets) => {
-    const seeds = {};
-    for (const { origin, entries } of blocks)
-        (seeds[origin] ??= []).push(...entries.map(({ name, value }) => [name, secrets.value(value)]));
-    return seeds;
+const throwIfScenarioCancelled = (signal) => {
+    if (signal?.aborted === true)
+        throw new BrowserObservationError(OPERATION, "cancelled");
 };
-const installStorageSeeds = async (context, page, scenario, secrets) => {
+const throwCleanupFailures = (failures) => {
+    if (failures.length === 1)
+        throw failures[0];
+    if (failures.length > 1)
+        throw new AggregateError(failures, "Browser scenario cleanup failed");
+};
+const installCookies = async (context, scenario, secrets) => {
     await context.addCookies(scenario.storage.cookies.map((cookie) => ({
         name: cookie.name,
         value: secrets.value(cookie.value),
@@ -23,19 +28,6 @@ const installStorageSeeds = async (context, page, scenario, secrets) => {
         secure: cookie.secure,
         sameSite: cookie.same_site,
     })));
-    const storage = {
-        local: storageSeeds(scenario.storage.local_storage, secrets),
-        session: storageSeeds(scenario.storage.session_storage, secrets),
-    };
-    const payload = JSON.stringify(storage).replaceAll("<", "\\u003c");
-    await page.addInitScript(`(() => {
-    const seeds = ${payload};
-    const local = seeds.local[window.location.origin] ?? [];
-    const session = seeds.session[window.location.origin] ?? [];
-    for (const [name, value] of local) window.localStorage.setItem(name, value);
-    for (const [name, value] of session)
-      window.sessionStorage.setItem(name, value);
-  })()`);
 };
 const blockAttachedServiceWorkers = async (page) => {
     const controller = await page.evaluate("Boolean(navigator.serviceWorker?.controller)");
@@ -58,7 +50,7 @@ const initializePage = async (context, page, scenario, secrets) => {
     context.setDefaultNavigationTimeout(0);
     if (scenario.browser.mode === "connect")
         await blockAttachedServiceWorkers(page);
-    await installStorageSeeds(context, page, scenario, secrets);
+    await installCookies(context, scenario, secrets);
 };
 export class PlaywrightScenarioSession {
     opened;
@@ -69,6 +61,9 @@ export class PlaywrightScenarioSession {
     initialUrl;
     secrets;
     eventCapture;
+    storage;
+    signal;
+    #storageReleased = false;
     constructor(opened, options) {
         this.opened = opened;
         this.mode = options.mode;
@@ -76,70 +71,55 @@ export class PlaywrightScenarioSession {
             options.mode === "launch" ? "provider-owned" : "external";
         this.secrets = options.secrets;
         this.eventCapture = options.eventCapture;
+        this.storage = options.storage;
+        this.signal = options.signal;
         this.version = opened.browser.version();
         this.initialUrl = opened.page.url();
     }
     static async open(scenario, environment, options) {
-        if (options.signal?.aborted === true)
-            throw new BrowserObservationError(OPERATION, "cancelled");
+        throwIfScenarioCancelled(options.signal);
         const secrets = BrowserScenarioSecrets.resolve(scenario, environment);
         if (secrets === undefined)
             throw new BrowserObservationError(OPERATION, "secret_unavailable");
         const startedAt = Date.now();
-        const opening = openPlaywrightScenarioBrowser(scenario, environment);
+        const opening = openPlaywrightScenarioBrowser(scenario, environment, {
+            signal: options.signal,
+            ...(options.retainCleanup === undefined
+                ? {}
+                : { retainCleanup: options.retainCleanup }),
+        });
         let opened;
-        let events;
         try {
             opened = await withPlaywrightExecutionBoundary(() => opening, undefined, options.signal);
         }
         catch (cause) {
-            void opening
-                .then((lateOpened) => lateOpened.cleanup.close(undefined, options.signal))
-                .catch((cause) => {
-                // best-effort cleanup: late-open cleanup must not mask the boundary failure.
-                void cause;
+            const lateCleanup = () => opening.then((lateOpened) => lateOpened.cleanup.close(undefined, options.signal), () => undefined);
+            options.retainCleanup?.(() => withPlaywrightExecutionBoundary(lateCleanup, 1_000));
+            void lateCleanup().catch((cleanupCause) => {
+                // best-effort cleanup: retainCleanup keeps the retry capability.
+                void cleanupCause;
             });
             throw cause;
         }
-        let session;
-        try {
-            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
-            events = new PlaywrightScenarioEvents({
-                page: opened.page,
-                context: opened.context,
-                ownsContext: scenario.browser.mode === "launch",
-                enabled: new Set(scenario.capture.events),
-                secrets,
-                network: scenario.capture.network,
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-            });
-            session = new PlaywrightScenarioSession(opened, {
-                mode: scenario.browser.mode,
-                secrets,
-                eventCapture: events,
-            });
-        }
-        catch (cause) {
-            return failBrowserScenarioOperation(() => opened.cleanup.close(events === undefined
-                ? undefined
-                : () => events?.finish() ?? Promise.resolve(), options.signal), cause);
-        }
+        const session = await this.initializeSession(opened, scenario, secrets, options);
         try {
             await withPlaywrightExecutionBoundary(() => opened.page.goto(secrets.url(scenario.start_url), {
                 waitUntil: "load",
                 timeout: 0,
             }), undefined, options.signal);
+            await withPlaywrightExecutionBoundary(() => session.storage?.settle() ?? Promise.resolve(), undefined, options.signal);
             return session;
         }
         catch (cause) {
             let cleanup;
             let cleanupFailure;
             try {
-                cleanup = await session.close();
+                cleanup = await session.close(true);
             }
             catch (failure) {
                 cleanup = "incomplete";
                 cleanupFailure = { cause: failure };
+                options.retainCleanup?.(() => session.close());
             }
             throw browserScenarioOperationFailure(cause, {
                 kind: "browser-scenario-observation",
@@ -156,6 +136,76 @@ export class PlaywrightScenarioSession {
             }, cleanupFailure);
         }
     }
+    static async initializeSession(opened, scenario, secrets, options) {
+        let events;
+        let storage;
+        try {
+            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
+            storage = await PlaywrightScenarioStorage.create(opened, scenario, secrets, {
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+                ...(options.retainCleanup === undefined
+                    ? {}
+                    : { retainCleanup: options.retainCleanup }),
+            });
+            await storage?.initialize(opened.page, opened.context);
+            throwIfScenarioCancelled(options.signal);
+            events = new PlaywrightScenarioEvents({
+                page: opened.page,
+                context: opened.context,
+                ownsContext: scenario.browser.mode === "launch",
+                enabled: new Set(scenario.capture.events),
+                secrets,
+                network: scenario.capture.network,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+            });
+            return new PlaywrightScenarioSession(opened, {
+                mode: scenario.browser.mode,
+                secrets,
+                eventCapture: events,
+                storage,
+                signal: options.signal,
+            });
+        }
+        catch (cause) {
+            let storageReleased = false;
+            const cleanup = async () => {
+                let storageFailure;
+                let browserFailure;
+                if (!storageReleased) {
+                    try {
+                        await storage?.close(options.signal?.aborted === true);
+                    }
+                    catch (failure) {
+                        storageFailure = { cause: failure };
+                    }
+                }
+                try {
+                    await opened.cleanup.close(events === undefined
+                        ? undefined
+                        : () => events?.finish() ?? Promise.resolve(), options.signal);
+                }
+                catch (failure) {
+                    browserFailure = { cause: failure };
+                }
+                if (opened.cleanup.browserClosed)
+                    storageReleased = true;
+                throwCleanupFailures([
+                    ...(storageReleased || storageFailure === undefined
+                        ? []
+                        : [storageFailure.cause]),
+                    ...(browserFailure === undefined ? [] : [browserFailure.cause]),
+                ]);
+            };
+            try {
+                return await failBrowserScenarioOperation(cleanup, cause);
+            }
+            catch (failure) {
+                if (failure !== cause)
+                    options.retainCleanup?.(cleanup);
+                throw failure;
+            }
+        }
+    }
     currentUrl() {
         return this.opened.page.url();
     }
@@ -184,8 +234,10 @@ export class PlaywrightScenarioSession {
             action,
             secrets: this.secrets,
         }), "timeout_ms" in action ? action.timeout_ms : undefined, signal);
+        await withPlaywrightExecutionBoundary(() => this.storage?.settle() ?? Promise.resolve(), undefined, signal);
     }
     async capture(requested, signal) {
+        await withPlaywrightExecutionBoundary(() => this.storage?.settle() ?? Promise.resolve(), undefined, signal);
         return withPlaywrightExecutionBoundary(() => capturePlaywrightStepArtifacts({
             context: this.opened.context,
             page: this.opened.page,
@@ -193,8 +245,31 @@ export class PlaywrightScenarioSession {
             requested,
         }), undefined, signal);
     }
-    async close() {
-        await this.opened.cleanup.close(() => this.eventCapture.finish());
+    async close(stopLoading = this.signal?.aborted === true) {
+        let storageFailure;
+        let browserFailure;
+        if (!this.#storageReleased) {
+            try {
+                await this.storage?.close(stopLoading);
+            }
+            catch (failure) {
+                storageFailure = { cause: failure };
+            }
+        }
+        try {
+            await this.opened.cleanup.close(() => this.eventCapture.finish());
+        }
+        catch (failure) {
+            browserFailure = { cause: failure };
+        }
+        if (this.opened.cleanup.browserClosed)
+            this.#storageReleased = true;
+        throwCleanupFailures([
+            ...(this.#storageReleased || storageFailure === undefined
+                ? []
+                : [storageFailure.cause]),
+            ...(browserFailure === undefined ? [] : [browserFailure.cause]),
+        ]);
         return this.mode === "launch"
             ? "terminated-owned-process"
             : "disconnected-external";
@@ -203,13 +278,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) {
-        this.environment = environment;
-    }
-    open(scenario, options = {}) {
-        return PlaywrightScenarioSession.open(scenario, this.environment, options);
-    }
-}