rea-agents 3.2.1 → 4.0.0

package/dist/browser/PlaywrightScenarioArtifacts.js

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
-import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
 const historyValueSchema = z.strictObject({
     length: z.number().int().min(0),
@@ -79,7 +78,7 @@ const navigationType = (value) => {
             return "unknown";
     }
 };
-const captureHistory = async (page) => {
+const captureHistory = async (page, secrets) => {
     try {
         const raw = historyValueSchema.parse(await page.evaluate(`(() => ({
         length: window.history.length,
@@ -92,10 +91,10 @@ const captureHistory = async (page) => {
       }))()`));
         const value = {
             length: raw.length,
-            current_url: sanitizeBrowserUrl(page.url()),
+            current_url: secrets.sanitizeUrl(page.url()),
             navigation_entries: raw.navigation_entries.map(({ type, name }) => ({
                 type: navigationType(type),
-                name: sanitizeBrowserUrl(name),
+                name: secrets.sanitizeUrl(name),
             })),
         };
         return { state: "captured", value };
@@ -105,9 +104,12 @@ const captureHistory = async (page) => {
     }
 };
 const captureStorage = async (input) => {
-    const { context, page, scenario, secrets } = input;
+    const { context, page, secrets } = input;
     try {
-        const cookies = await context.cookies(scenario.allowed_origins);
+        const pageUrl = new URL(page.url());
+        const cookies = pageUrl.protocol === "http:" || pageUrl.protocol === "https:"
+            ? await context.cookies(pageUrl.href)
+            : [];
         const pageStorage = storageValueSchema.parse(await page.evaluate(`(() => ({
         local_storage: Object.entries(window.localStorage),
         session_storage: Object.entries(window.sessionStorage)
@@ -137,33 +139,19 @@ const captureStorage = async (input) => {
         return missing("storage capture failed");
     }
 };
-const isAllowedPage = (page, allowedOrigins) => {
-    try {
-        return allowedOrigins.has(new URL(page.url()).origin);
-    }
-    catch {
-        return false;
-    }
-};
 /** Capture selected step artifacts without retaining data after scope loss. */
 export const capturePlaywrightStepArtifacts = async (input) => {
-    const { context, page, scenario, secrets, requested } = input;
-    const allowed = isAllowedPage(page, new Set(scenario.allowed_origins));
-    const denied = () => missing("current page is outside approved origins");
-    const state = (kind, capture) => !requested.has(kind)
-        ? Promise.resolve(notRequested())
-        : allowed || kind === "url"
-            ? capture()
-            : Promise.resolve(denied());
+    const { context, page, secrets, requested } = input;
+    const state = (kind, capture) => (!requested.has(kind) ? Promise.resolve(notRequested()) : capture());
     return browserStepArtifactsSchema.parse({
         screenshot: await state("screenshot", () => captureScreenshot(page)),
         dom: await state("dom", () => captureDom({ page, secrets })),
         accessibility: await state("accessibility", () => captureAccessibility({ page, secrets })),
         url: await state("url", async () => ({
             state: "captured",
-            value: sanitizeBrowserUrl(page.url()),
+            value: secrets.sanitizeUrl(page.url()),
         })),
-        history: await state("history", () => captureHistory(page)),
-        storage: await state("storage", () => captureStorage({ context, page, scenario, secrets })),
+        history: await state("history", () => captureHistory(page, secrets)),
+        storage: await state("storage", () => captureStorage({ context, page, secrets })),
     });
 };

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -1,8 +1,9 @@
 import { chmod, mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { chromium, } from "playwright-core";
 import { BrowserObservationError } from "../domain/errors.js";
+import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 const OPERATION = "capture_browser_scenario";
 const allowedBrowserEnvironment = (environment) => {
     const allowed = [
@@ -24,15 +25,7 @@ const allowedBrowserEnvironment = (environment) => {
         .map((name) => [name, environment[name]])
         .filter((entry) => entry[1] !== undefined));
 };
-const originAllowed = (value, allowedOrigins) => {
-    try {
-        return allowedOrigins.has(new URL(value).origin);
-    }
-    catch {
-        return false;
-    }
-};
-const findConnectedPage = async (browser, targetId, allowedOrigins) => {
+const findConnectedPage = async (browser, targetId) => {
     for (const context of browser.contexts())
         for (const page of context.pages()) {
             const session = await context.newCDPSession(page);
@@ -40,9 +33,6 @@ const findConnectedPage = async (browser, targetId, allowedOrigins) => {
                 const { targetInfo } = await session.send("Target.getTargetInfo");
                 if (targetInfo.targetId !== targetId)
                     continue;
-                if (page.url() !== "about:blank" &&
-                    !originAllowed(page.url(), allowedOrigins))
-                    throw new BrowserObservationError(OPERATION, "target_not_allowed");
                 return { context, page };
             }
             finally {
@@ -83,7 +73,7 @@ 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, new Set(scenario.allowed_origins));
+            const target = await findConnectedPage(browser, scenario.browser.target_id);
             await configureAttachedEnvironment(target.context, target.page, scenario);
             return { ...target, browser, profilePath: undefined };
         }
@@ -96,8 +86,8 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
     await chmod(profilePath, 0o700);
     try {
         const context = await chromium.launchPersistentContext(profilePath, {
-            executablePath: scenario.browser.executable_path,
-            headless: true,
+            executablePath: resolve(scenario.browser.executable_path),
+            headless: scenario.browser.headless,
             acceptDownloads: false,
             viewport: {
                 width: scenario.environment.viewport.width,
@@ -108,7 +98,7 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
             timezoneId: scenario.environment.timezone,
             colorScheme: scenario.environment.color_scheme,
             reducedMotion: scenario.environment.reduced_motion,
-            serviceWorkers: "block",
+            serviceWorkers: scenario.environment.service_workers,
             env: allowedBrowserEnvironment(environment),
             handleSIGHUP: false,
             handleSIGINT: false,
@@ -128,15 +118,28 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
         throw cause;
     }
 };
-export const closePlaywrightScenarioBrowser = async ({ context, browser, profilePath, }) => {
+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 });
+        }
+    })();
+    void cleanup.catch(() => undefined);
+    // The shared execution boundary rejects cancellation/timeouts instead of
+    // returning a successful capture whose browser or profile may still exist.
     try {
-        if (profilePath === undefined)
-            await browser.close();
-        else
-            await context.close();
+        await withPlaywrightExecutionBoundary(() => cleanup, 1_000, signal);
     }
-    finally {
-        if (profilePath !== undefined)
-            await rm(profilePath, { recursive: true, force: true, maxRetries: 3 });
+    catch (cause) {
+        throw new BrowserObservationError(OPERATION, "cleanup_failed", { cause });
     }
 };

package/dist/browser/PlaywrightScenarioEvents.js

@@ -1,4 +1,3 @@
-import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { browserScenarioEventSchema, } from "../domain/browserScenarioCapture.js";
 /** Arrival-ordered Playwright event capture with current-step attribution. */
 export class PlaywrightScenarioEvents {
@@ -7,11 +6,43 @@ export class PlaywrightScenarioEvents {
     sequence = 0;
     enabled;
     secrets;
-    allowedOrigins;
+    ownsContext;
+    pages = new Set();
+    incompleteFamilies = new Set();
     constructor(options) {
         this.enabled = options.enabled;
         this.secrets = options.secrets;
-        this.allowedOrigins = new Set(options.allowedOrigins);
+        this.ownsContext = options.ownsContext === true;
+        this.pages.add(options.page);
+        if (this.ownsContext && this.enabled.size > 0)
+            (options.context ?? options.page.context()).on("page", (page) => this.popup(page));
+        if (this.enabled.has("network")) {
+            const context = options.context ?? options.page.context();
+            const inScope = (request) => {
+                if (this.ownsContext)
+                    return true;
+                try {
+                    return this.pages.has(request.frame().page());
+                }
+                catch {
+                    // Initial popup navigations can lack a frame. Never guess ownership
+                    // from a URL in a shared context; connect captures are attach-limited.
+                    return false;
+                }
+            };
+            context.on("request", (request) => {
+                if (inScope(request))
+                    this.request("request", request);
+            });
+            context.on("response", (response) => {
+                if (inScope(response.request()))
+                    this.response(response);
+            });
+            context.on("requestfailed", (request) => {
+                if (inScope(request))
+                    this.request("request-failed", request);
+            });
+        }
         this.observePage(options.page);
     }
     setStep(index) {
@@ -23,6 +54,16 @@ export class PlaywrightScenarioEvents {
     lastSequence() {
         return this.sequence;
     }
+    /** Report selected popup event families with unrecoverable pre-discovery gaps. */
+    limitations() {
+        const popupGaps = [...this.incompleteFamilies].map((family) => `Popup ${family} events before Page discovery are unavailable; later events are retained.`);
+        return this.enabled.has("network") && !this.ownsContext
+            ? [
+                "Shared-context network capture excludes requests without a known root or descendant Page frame.",
+                ...popupGaps,
+            ]
+            : popupGaps;
+    }
     result() {
         return {
             retained: this.items.length,
@@ -41,80 +82,33 @@ export class PlaywrightScenarioEvents {
     }
     observePage(page) {
         if (this.enabled.has("console"))
-            page.on("console", (message) => {
-                if (this.pageInScope(page))
-                    this.console(message);
-            });
+            page.on("console", (message) => this.console(message));
         if (this.enabled.has("page-errors"))
             page.on("pageerror", (error) => {
-                if (this.pageInScope(page))
-                    this.push({
-                        kind: "page-error",
-                        message: this.secrets.redact(error.message),
-                        stack: error.stack === undefined
-                            ? null
-                            : this.secrets.redact(error.stack),
-                    });
-            });
-        if (this.enabled.has("network")) {
-            page.on("request", (request) => {
-                if (this.pageInScope(page))
-                    this.request("request", request);
-            });
-            page.on("response", (response) => {
-                if (this.pageInScope(page))
-                    this.response(response);
-            });
-            page.on("requestfailed", (request) => {
-                if (this.pageInScope(page))
-                    this.request("request-failed", request);
+                this.push({
+                    kind: "page-error",
+                    message: this.secrets.redact(error.message),
+                    stack: error.stack === undefined ? null : this.secrets.redact(error.stack),
+                });
             });
-        }
         if (this.enabled.has("websockets"))
-            page.on("websocket", (socket) => {
-                if (this.pageInScope(page))
-                    this.webSocket(page, socket);
-            });
+            page.on("websocket", (socket) => this.webSocket(socket));
         if (this.enabled.has("frames")) {
-            page.on("frameattached", (frame) => {
-                if (this.pageInScope(page))
-                    this.frame("frame-attached", frame);
-            });
-            page.on("framedetached", (frame) => {
-                if (this.pageInScope(page))
-                    this.frame("frame-detached", frame);
-            });
-            page.on("framenavigated", (frame) => {
-                if (this.pageInScope(page))
-                    this.frame("frame-navigated", frame);
-            });
+            page.on("frameattached", (frame) => this.frame("frame-attached", frame));
+            page.on("framedetached", (frame) => this.frame("frame-detached", frame));
+            page.on("framenavigated", (frame) => this.frame("frame-navigated", frame));
         }
         if (this.enabled.has("workers"))
-            page.on("worker", (worker) => {
-                if (this.pageInScope(page))
-                    this.worker(page, worker);
-            });
-        if (this.enabled.has("popups"))
-            page.on("popup", (popup) => {
-                if (this.pageInScope(page))
-                    this.popup(popup);
-            });
+            page.on("worker", (worker) => this.worker(worker));
+        // Any selected family needs descendant discovery in shared contexts.
+        // Popup lifecycle records remain gated on their own selector below.
+        if (this.enabled.size > 0)
+            page.on("popup", (popup) => this.popup(popup));
         if (this.enabled.has("downloads"))
-            page.on("download", (download) => {
-                if (this.pageInScope(page))
-                    this.download(download);
-            });
-    }
-    pageInScope(page) {
-        try {
-            return this.allowedOrigins.has(new URL(page.url()).origin);
-        }
-        catch {
-            return false;
-        }
+            page.on("download", (download) => this.download(download));
     }
     safeUrl(value) {
-        return sanitizeBrowserUrl(this.secrets.redact(value));
+        return this.secrets.sanitizeUrl(value);
     }
     console(message) {
         const location = message.location();
@@ -164,21 +158,12 @@ export class PlaywrightScenarioEvents {
             failure: null,
         });
     }
-    webSocket(page, socket) {
+    webSocket(socket) {
         const url = this.safeUrl(socket.url());
         this.push({ kind: "websocket-opened", url });
-        socket.on("framesent", ({ payload }) => {
-            if (this.pageInScope(page))
-                this.webSocketFrame("websocket-frame-sent", url, payload);
-        });
-        socket.on("framereceived", ({ payload }) => {
-            if (this.pageInScope(page))
-                this.webSocketFrame("websocket-frame-received", url, payload);
-        });
-        socket.on("close", () => {
-            if (this.pageInScope(page))
-                this.push({ kind: "websocket-closed", url });
-        });
+        socket.on("framesent", ({ payload }) => this.webSocketFrame("websocket-frame-sent", url, payload));
+        socket.on("framereceived", ({ payload }) => this.webSocketFrame("websocket-frame-received", url, payload));
+        socket.on("close", () => this.push({ kind: "websocket-closed", url }));
     }
     webSocketFrame(kind, url, payload) {
         const bytes = Buffer.byteLength(payload);
@@ -211,34 +196,38 @@ export class PlaywrightScenarioEvents {
             name: frame.name() === "" ? null : this.secrets.redact(frame.name()),
         });
     }
-    worker(page, worker) {
+    worker(worker) {
         const details = {
             url: this.safeUrl(worker.url()),
             name: null,
         };
         this.push({ kind: "worker-created", ...details });
-        worker.on("close", () => {
-            if (this.pageInScope(page))
-                this.push({ kind: "worker-closed", ...details });
-        });
+        worker.on("close", () => this.push({ kind: "worker-closed", ...details }));
     }
     popup(page) {
-        if (!this.pageInScope(page)) {
-            void page.close().catch(() => undefined);
+        if (this.pages.has(page))
             return;
-        }
+        this.pages.add(page);
+        for (const family of [
+            "frames",
+            "workers",
+            "websockets",
+            "downloads",
+        ])
+            if (this.enabled.has(family))
+                this.incompleteFamilies.add(family);
         const opened = {
             url: page.url() === "" ? null : this.safeUrl(page.url()),
             name: null,
         };
-        this.push({ kind: "popup-opened", ...opened });
-        page.on("close", () => this.pageInScope(page)
-            ? this.push({
+        if (this.enabled.has("popups")) {
+            this.push({ kind: "popup-opened", ...opened });
+            page.on("close", () => this.push({
                 kind: "popup-closed",
                 url: page.url() === "" ? null : this.safeUrl(page.url()),
                 name: null,
-            })
-            : undefined);
+            }));
+        }
         this.observePage(page);
     }
     download(download) {

package/dist/browser/PlaywrightScenarioSession.js

@@ -7,14 +7,6 @@ import { capturePlaywrightStepArtifacts } from "./PlaywrightScenarioArtifacts.js
 import { PlaywrightScenarioEvents } from "./PlaywrightScenarioEvents.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 const OPERATION = "capture_browser_scenario";
-const originAllowed = (value, allowedOrigins) => {
-    try {
-        return allowedOrigins.has(new URL(value).origin);
-    }
-    catch {
-        return false;
-    }
-};
 const storageSeeds = (blocks, secrets) => {
     const seeds = {};
     for (const { origin, entries } of blocks)
@@ -44,78 +36,6 @@ const installStorageSeeds = async (context, page, scenario, secrets) => {
       window.sessionStorage.setItem(name, value);
   })()`);
 };
-const installHttpPolicy = async (input) => {
-    const { context, scenario, secrets, ownedPages, claimOwnedPage } = input;
-    const routes = scenario.request_replay.mode === "exact"
-        ? new Map(scenario.request_replay.routes.map((route) => [
-            `${route.method} ${secrets.url(route.request)}`,
-            route,
-        ]))
-        : new Map();
-    await context.route("**/*", async (route, request) => {
-        let requestPage;
-        try {
-            requestPage = request.frame().page();
-        }
-        catch {
-            requestPage = undefined;
-        }
-        if (scenario.browser.mode === "connect" &&
-            requestPage !== undefined &&
-            !ownedPages.has(requestPage))
-            await claimOwnedPage(requestPage);
-        if (scenario.browser.mode === "connect" &&
-            (requestPage === undefined || !ownedPages.has(requestPage))) {
-            await route.continue();
-            return;
-        }
-        if (!originAllowed(request.url(), new Set(scenario.allowed_origins))) {
-            await route.abort("blockedbyclient");
-            return;
-        }
-        const replay = routes.get(`${request.method()} ${request.url()}`);
-        if (replay !== undefined) {
-            await fulfillReplayRoute(route, replay.response, secrets);
-            return;
-        }
-        if (scenario.request_replay.mode === "exact" &&
-            scenario.request_replay.unmatched === "abort") {
-            await route.abort("blockedbyclient");
-            return;
-        }
-        await route.continue();
-    });
-};
-const fulfillReplayRoute = async (route, response, secrets) => {
-    if (response.kind === "redirect") {
-        await route.fulfill({
-            status: response.status,
-            headers: { location: secrets.url(response.destination) },
-        });
-        return;
-    }
-    await route.fulfill({
-        status: response.status,
-        headers: Object.fromEntries(response.headers.map(({ name, value }) => [name, secrets.value(value)])),
-        ...(response.body === undefined
-            ? {}
-            : { body: secrets.value(response.body) }),
-    });
-};
-const installWebSocketPolicy = async (owner, scenario) => {
-    const allowed = new Set(scenario.allowed_origins);
-    await owner.routeWebSocket("**/*", async (route) => {
-        const url = new URL(route.url());
-        const httpOrigin = `${url.protocol === "wss:" ? "https:" : "http:"}//${url.host}`;
-        if (!allowed.has(httpOrigin) ||
-            (scenario.request_replay.mode === "exact" &&
-                scenario.request_replay.unmatched === "abort")) {
-            await route.close({ code: 1008, reason: "outside scenario policy" });
-            return;
-        }
-        route.connectToServer();
-    });
-};
 const blockAttachedServiceWorkers = async (page) => {
     const controller = await page.evaluate("Boolean(navigator.serviceWorker?.controller)");
     if (controller)
@@ -135,57 +55,29 @@ const blockAttachedServiceWorkers = async (page) => {
 const initializePage = async (context, page, scenario, secrets) => {
     context.setDefaultTimeout(0);
     context.setDefaultNavigationTimeout(0);
-    const ownedPages = new Set([page]);
     if (scenario.browser.mode === "connect")
         await blockAttachedServiceWorkers(page);
-    await installWebSocketPolicy(scenario.browser.mode === "launch" ? context : page, scenario);
-    const claimOwnedPage = async (candidate) => {
-        if (ownedPages.has(candidate))
-            return true;
-        const opener = await candidate.opener();
-        if (opener === null || !ownedPages.has(opener))
-            return false;
-        await installWebSocketPolicy(candidate, scenario);
-        ownedPages.add(candidate);
-        return true;
-    };
-    await installHttpPolicy({
-        context,
-        scenario,
-        secrets,
-        ownedPages,
-        claimOwnedPage,
-    });
-    page.on("popup", (popup) => {
-        if (scenario.browser.mode === "connect")
-            void claimOwnedPage(popup).catch(async () => {
-                await popup.close().catch(() => undefined);
-            });
-        else
-            ownedPages.add(popup);
-    });
     await installStorageSeeds(context, page, scenario, secrets);
-    return ownedPages;
 };
 export class PlaywrightScenarioSession {
     opened;
-    scenario;
-    secrets;
-    eventCapture;
     mode;
     processOwnership;
     product = "Chromium";
     version;
     initialUrl;
     closed = false;
-    constructor(opened, scenario, secrets, eventCapture) {
+    secrets;
+    eventCapture;
+    signal;
+    constructor(opened, options) {
         this.opened = opened;
-        this.scenario = scenario;
-        this.secrets = secrets;
-        this.eventCapture = eventCapture;
-        this.mode = scenario.browser.mode;
+        this.mode = options.mode;
         this.processOwnership =
-            scenario.browser.mode === "launch" ? "provider-owned" : "external";
+            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();
     }
@@ -202,7 +94,7 @@ export class PlaywrightScenarioSession {
         }
         catch (cause) {
             void opening
-                .then((lateOpened) => closePlaywrightScenarioBrowser(lateOpened))
+                .then((lateOpened) => closePlaywrightScenarioBrowser(lateOpened, options.signal))
                 .catch(() => undefined);
             throw cause;
         }
@@ -210,11 +102,17 @@ export class PlaywrightScenarioSession {
             await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
             const events = new PlaywrightScenarioEvents({
                 page: opened.page,
+                context: opened.context,
+                ownsContext: scenario.browser.mode === "launch",
                 enabled: new Set(scenario.capture.events),
                 secrets,
-                allowedOrigins: scenario.allowed_origins,
             });
-            const session = new PlaywrightScenarioSession(opened, scenario, secrets, events);
+            const session = new PlaywrightScenarioSession(opened, {
+                mode: scenario.browser.mode,
+                secrets,
+                eventCapture: events,
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+            });
             await withPlaywrightExecutionBoundary(() => opened.page.goto(secrets.url(scenario.start_url), {
                 waitUntil: "load",
                 timeout: 0,
@@ -222,13 +120,16 @@ export class PlaywrightScenarioSession {
             return session;
         }
         catch (cause) {
-            await closePlaywrightScenarioBrowser(opened);
+            await closePlaywrightScenarioBrowser(opened, options.signal);
             throw cause;
         }
     }
     currentUrl() {
         return this.opened.page.url();
     }
+    sanitizeUrl(value) {
+        return this.secrets.sanitizeUrl(value);
+    }
     setStep(index) {
         this.eventCapture.setStep(index);
     }
@@ -241,6 +142,10 @@ export class PlaywrightScenarioSession {
     events() {
         return this.eventCapture.result();
     }
+    /** Preserve event coverage gaps for the aggregate capture's completeness. */
+    eventLimitations() {
+        return this.eventCapture.limitations();
+    }
     async perform(action, signal) {
         await withPlaywrightExecutionBoundary(() => performPlaywrightScenarioAction({
             page: this.opened.page,
@@ -252,7 +157,6 @@ export class PlaywrightScenarioSession {
         return withPlaywrightExecutionBoundary(() => capturePlaywrightStepArtifacts({
             context: this.opened.context,
             page: this.opened.page,
-            scenario: this.scenario,
             secrets: this.secrets,
             requested,
         }), undefined, signal);
@@ -263,7 +167,7 @@ export class PlaywrightScenarioSession {
                 ? "terminated-owned-process"
                 : "disconnected-external";
         this.closed = true;
-        await closePlaywrightScenarioBrowser(this.opened);
+        await closePlaywrightScenarioBrowser(this.opened, this.signal);
         return this.mode === "launch"
             ? "terminated-owned-process"
             : "disconnected-external";