@steipete/oracle 0.20.0 → 0.20.2

package/dist/bin/oracle-cli.js

@@ -15,8 +15,8 @@ import { collectPaths, collectModelList, collectTextValues, parseFloatOption, pa
 import { copyToClipboard } from "../src/cli/clipboard.js";
 import { isGpt6ProAlias } from "../src/cli/browserConfig.js";
 import { buildMarkdownBundle } from "../src/cli/markdownBundle.js";
-import { shouldDetachSession, stopDetachedWorker } from "../src/cli/detach.js";
-import { launchDetachedSession } from "../src/cli/detachedSession.js";
+import { detachedCancellationExitCode, shouldDetachSession, shouldExitAfterTopLevelSigint, stopDetachedWorker, } from "../src/cli/detach.js";
+import { clearDetachedSessionCancellation, detachedSessionCancellationPath, launchDetachedSession, requestDetachedSessionCancellation, waitForDetachedSessionCancellation, } from "../src/cli/detachedSession.js";
 import { applyHiddenAliases } from "../src/cli/hiddenAliases.js";
 import { isMediaFile } from "../src/browser/prompt.js";
 import { formatCompactNumber } from "../src/cli/format.js";
@@ -25,7 +25,7 @@ import { warnIfOversizeBundle } from "../src/cli/bundleWarnings.js";
 import { formatRenderedMarkdown } from "../src/cli/renderOutput.js";
 import { resolveRenderFlag, resolveRenderPlain } from "../src/cli/renderFlags.js";
 import { resolveGeminiModelId } from "../src/oracle/geminiModels.js";
-import { isErrorLogged } from "../src/cli/errorUtils.js";
+import { formatCliError, isErrorLogged } from "../src/cli/errorUtils.js";
 import { resolveOutputPath } from "../src/cli/writeOutputPath.js";
 import { getCliVersion } from "../src/version.js";
 import { resolveNotificationSettings, deriveNotificationSettingsFromMetadata, } from "../src/cli/notifier.js";
@@ -37,6 +37,7 @@ import { isAzureOpenAICandidateModel, validateProviderRouting, } from "../src/or
 import { buildSessionLifecycle, formatSessionLifecycleBlock } from "../src/cli/sessionLifecycle.js";
 import { buildDetachedPerfTraceEnv, createPerfTrace, isTraceValueFlag, } from "../src/cli/perfTrace.js";
 import { resolveBrowserFollowupReference } from "../src/cli/followup.js";
+import { BrowserRunCancelledError } from "../src/oracle/errors.js";
 const VERSION = getCliVersion();
 const CLI_ENTRYPOINT = fileURLToPath(import.meta.url);
 const LEGACY_FLAG_ALIASES = new Map([
@@ -1357,6 +1358,8 @@ async function runRootCommand(options) {
             browserRequestedModel: cliModelArg,
             browserModelLabel: resolveBrowserModelLabel(cliModelArg, activeModel),
         });
+        config.modelIsImplicitDefault =
+            optionUsesDefault("model") && !userConfig.model && !options.browserModelLabel;
         return resolvedOptions.browserResumeConversationUrl
             ? { ...config, resumeConversationUrl: resolvedOptions.browserResumeConversationUrl }
             : config;
@@ -1673,18 +1676,28 @@ async function waitForDetachedStartGate() {
     }
 }
 async function attachToDetachedSession(sessionId, workerPid) {
+    const cancellationMarker = sessionStore
+        .getPaths(sessionId)
+        .then((paths) => detachedSessionCancellationPath(paths.dir, workerPid));
     let cancelled = false;
+    let cancellationRequest;
     const cancelWorker = () => {
         cancelled = true;
-        try {
-            stopDetachedWorker(workerPid);
-        }
-        catch (error) {
+        cancellationRequest ??= cancellationMarker
+            .then((markerPath) => requestDetachedSessionCancellation(markerPath))
+            .catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
-            console.error(chalk.red(`Unable to stop detached worker ${workerPid}: ${message}`));
-        }
+            console.error(chalk.red(`Unable to request cancellation from worker ${workerPid}: ${message}`));
+            try {
+                stopDetachedWorker(workerPid);
+            }
+            catch (stopError) {
+                const stopMessage = stopError instanceof Error ? stopError.message : String(stopError);
+                console.error(chalk.red(`Unable to stop detached worker ${workerPid}: ${stopMessage}`));
+            }
+        });
     };
-    process.once("SIGINT", cancelWorker);
+    process.on("SIGINT", cancelWorker);
     try {
         const { attachSession } = await import("../src/cli/sessionDisplay.js");
         await attachSession(sessionId, {
@@ -1695,9 +1708,15 @@ async function attachToDetachedSession(sessionId, workerPid) {
     }
     finally {
         process.off("SIGINT", cancelWorker);
-        if (cancelled) {
-            process.exitCode = 130;
+        await cancellationRequest;
+        const finalStatus = (await sessionStore.readSession(sessionId).catch(() => null))?.status;
+        if (cancellationRequest &&
+            finalStatus &&
+            ["completed", "partial", "cancelled", "error"].includes(finalStatus)) {
+            // The parent may publish its request after the worker's final cleanup.
+            await clearDetachedSessionCancellation(await cancellationMarker);
         }
+        process.exitCode = detachedCancellationExitCode(cancelled, finalStatus, process.exitCode);
     }
 }
 async function restartSession(sessionId, options) {
@@ -1879,6 +1898,10 @@ async function restartSession(sessionId, options) {
 async function executeSession(sessionId) {
     let metadata = null;
     let writer = null;
+    const cancellation = new AbortController();
+    const stopCancellationMonitor = new AbortController();
+    let cancellationMarker;
+    let cancellationMonitor;
     try {
         metadata = await sessionStore.readSession(sessionId);
         if (!metadata) {
@@ -1892,6 +1915,18 @@ async function executeSession(sessionId) {
         const sessionMode = getSessionMode(metadata);
         const browserConfig = getBrowserConfigFromMetadata(metadata);
         writer = sessionStore.createLogWriter(sessionId);
+        if (sessionMode === "browser") {
+            const paths = await sessionStore.getPaths(sessionId);
+            cancellationMarker = detachedSessionCancellationPath(paths.dir, process.pid);
+            cancellationMonitor = waitForDetachedSessionCancellation({
+                markerPath: cancellationMarker,
+                signal: stopCancellationMonitor.signal,
+            }).then((requested) => {
+                if (requested) {
+                    cancellation.abort(new BrowserRunCancelledError("Browser run cancelled by the user."));
+                }
+            });
+        }
         const userConfig = (await loadUserConfig()).config;
         const notifications = deriveNotificationSettingsFromMetadata(metadata, process.env, userConfig.notify);
         const { performSessionRun } = await import("../src/cli/sessionRunner.js");
@@ -1905,18 +1940,22 @@ async function executeSession(sessionId) {
             write: writer.writeChunk,
             version: VERSION,
             notifications,
+            signal: sessionMode === "browser" ? cancellation.signal : undefined,
         });
     }
     catch (error) {
-        process.exitCode = 1;
+        const cancelled = error instanceof BrowserRunCancelledError;
+        process.exitCode = cancelled ? 130 : 1;
         const message = error instanceof Error ? error.message : String(error);
         if (!metadata) {
-            console.error(chalk.red(message));
+            if (!cancelled)
+                console.error(chalk.red(message));
             return;
         }
-        writer?.logLine(`ERROR: Detached session worker failed: ${message}`);
+        if (!cancelled)
+            writer?.logLine(`ERROR: Detached session worker failed: ${message}`);
         const latest = await sessionStore.readSession(sessionId).catch(() => null);
-        if (latest && !["completed", "partial", "error"].includes(latest.status)) {
+        if (latest && !["completed", "partial", "error", "cancelled"].includes(latest.status)) {
             await sessionStore.updateSession(sessionId, {
                 status: "error",
                 completedAt: new Date().toISOString(),
@@ -1930,6 +1969,14 @@ async function executeSession(sessionId) {
         }
     }
     finally {
+        stopCancellationMonitor.abort();
+        await cancellationMonitor?.catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            writer?.logLine(`ERROR: Detached cancellation monitor failed: ${message}`);
+        });
+        if (cancellationMarker) {
+            await clearDetachedSessionCancellation(cancellationMarker).catch(() => undefined);
+        }
         writer?.stream.end();
     }
 }
@@ -2048,7 +2095,7 @@ async function main() {
         console.log(chalk.yellow("\nCancelled."));
         process.exitCode = 130;
         // Browser/serve modes install their own SIGINT cleanup after this top-level handler.
-        if (process.listenerCount("SIGINT") <= 1) {
+        if (shouldExitAfterTopLevelSigint(process.listenerCount("SIGINT"))) {
             process.exit(130);
         }
     };
@@ -2061,13 +2108,7 @@ async function main() {
     }
 }
 void main().catch((error) => {
-    if (error instanceof Error) {
-        if (!isErrorLogged(error)) {
-            console.error(chalk.red("✖"), error.message);
-        }
-    }
-    else {
-        console.error(chalk.red("✖"), error);
-    }
+    if (!isErrorLogged(error))
+        console.error(chalk.red("✖"), formatCliError(error));
     process.exitCode = 1;
 });

package/dist/src/browser/actions/modelSelection.js

@@ -15,10 +15,28 @@ const MODEL_BUTTON_POLL_MS = 250;
 export async function ensureModelSelection(Runtime, desiredModel, logger, strategy = "select", options = {}) {
     const buttonWaitMs = options.buttonWaitMs ?? MODEL_BUTTON_WAIT_MS;
     const buttonPollMs = options.buttonPollMs ?? MODEL_BUTTON_POLL_MS;
-    const deadline = Date.now() + Math.max(0, buttonWaitMs);
+    const probeDeadline = Date.now() + Math.max(0, buttonWaitMs);
+    let deadline;
     let result;
     let announcedWait = false;
     for (;;) {
+        if (options.implicitDefault && strategy === "select") {
+            // Wait for observable selection before a default-driven switch, just as selection waits for the picker.
+            const observed = await Runtime.evaluate({
+                expression: buildModelSelectionExpression(desiredModel, "current"),
+                awaitPromise: true,
+                returnByValue: true,
+            }).catch(() => null);
+            const label = observed?.result?.value?.label;
+            if ((typeof label !== "string" || !label.trim()) && Date.now() < probeDeadline) {
+                await delay(buttonPollMs);
+                continue;
+            }
+            if (typeof label === "string" && isNewerModelLabel(label, desiredModel)) {
+                logger(`[browser] Model selection warning: no model was specified, so Oracle's default will switch ChatGPT from "${label}" to "${desiredModel}" before submission. Pass --model explicitly or --browser-model-strategy current to keep the selected model.`);
+            }
+        }
+        deadline ??= Date.now() + Math.max(0, buttonWaitMs);
         const outcome = await Runtime.evaluate({
             expression: buildModelSelectionExpression(desiredModel, strategy),
             awaitPromise: true,
@@ -76,6 +94,18 @@ export async function ensureModelSelection(Runtime, desiredModel, logger, strate
         }
     }
 }
+function isNewerModelLabel(current, target) {
+    const latest = /^(?:Latest|最新|최신)$/i;
+    if (latest.test(current.trim()))
+        return !latest.test(target.trim());
+    const version = (label) => {
+        const match = label.match(/(?:^|gpt[- ]*|thinking\s+)(\d+)(?:\.(\d+))?/i);
+        return match ? [Number(match[1]), Number(match[2] ?? 0)] : null;
+    };
+    const from = version(current);
+    const to = version(target);
+    return Boolean(from && to && (from[0] > to[0] || (from[0] === to[0] && from[1] > to[1])));
+}
 function assertResolvedModelSelection(desiredModel, resolvedLabel) {
     const desired = desiredModel.toLowerCase();
     const resolved = resolvedLabel.toLowerCase();
@@ -85,7 +115,8 @@ function assertResolvedModelSelection(desiredModel, resolvedLabel) {
         // The advanced radio is localized, but only the documented exact labels are
         // evidence of GPT-6 Astra. Do not let a generic picker result verify Latest.
         if (resolvedLabel.normalize("NFC").trim() === "Latest" ||
-            resolvedLabel.normalize("NFC").trim() === "最新") {
+            resolvedLabel.normalize("NFC").trim() === "最新" ||
+            resolvedLabel.normalize("NFC").trim() === "최신") {
             return;
         }
         throw new Error(`Model picker selected "${resolvedLabel}" while "${desiredModel}" requires GPT-6 Astra (Latest).`);
@@ -187,7 +218,7 @@ function buildModelSelectionExpression(targetModel, strategy) {
     // Sol or an arbitrary localized menu row can never satisfy a Latest request.
     const isLatestModelLabel = (value) => {
       const label = String(value ?? '').normalize('NFC').trim();
-      return label === 'Latest' || label === '最新';
+      return label === 'Latest' || label === '最新' || label === '최신';
     };
     const normalizedTokens = Array.from(new Set([normalizedTarget, ...LABEL_TOKENS]))
       .map((token) => normalizeText(token))
@@ -1442,8 +1473,9 @@ function buildModelMatchersLiteral(targetModel) {
         testIdTokens.add("gpt56");
     }
     if (base === "latest") {
-        // ChatGPT's Japanese advanced-model radio is named exactly "最新".
+        // Exact Japanese and Korean labels for the advanced-model Latest radio.
         push("最新", labelTokens);
+        push("최신", labelTokens);
     }
     // Numeric variations (5.5 <-> 55 <-> gpt-5-5)
     if (base.includes("5.5") || base.includes("5-5") || base.includes("55")) {

package/dist/src/browser/actions/thinkingTime.js

@@ -1030,11 +1030,12 @@ function buildThinkingTimeExpression(level, desiredModel) {
           .filter(Boolean);
         if (selections.length !== 1) return null;
         const { label, index, level } = selections[0];
-        // This adapter owns the observed five-tier layout only. A different range
-        // or contradictory announcement must not turn a numeric guess into proof.
-        if (thumb.getAttribute('aria-valuemin') !== '0' || thumb.getAttribute('aria-valuemax') !== '4' ||
-            thumb.getAttribute('aria-valuenow') !== String(index)) return null;
-        return { control, label, index, level };
+        // Quota-limited accounts expose four tiers; the fourth remains Extra High.
+        // Require an observed range and matching label/index before trusting either.
+        const maximum = thumb.getAttribute('aria-valuemax');
+        if (thumb.getAttribute('aria-valuemin') !== '0' || !['3', '4'].includes(maximum) ||
+            index > Number(maximum) || thumb.getAttribute('aria-valuenow') !== String(index)) return null;
+        return { control, label, index, level, maximum: Number(maximum) };
       };
       let current = resolve();
       const finish = (result) => { closeOpenMenus(); return result; };
@@ -1054,6 +1055,10 @@ function buildThinkingTimeExpression(level, desiredModel) {
         }
         return finish(failure('option-not-found'));
       }
+      const unavailable = () => finish(failure('option-disabled', {
+        label: 'Pro', notice: 'the available four-tier effort slider does not include Pro',
+      }));
+      if (targetIndex > current.maximum) return unavailable();
       if (current.level === target) return finish({ status: 'already-selected', label: current.label });
       const deadline = performance.now() + MAX_WAIT_MS;
       for (let attempt = 0; attempt < 4 && performance.now() < deadline; attempt += 1) {
@@ -1069,6 +1074,7 @@ function buildThinkingTimeExpression(level, desiredModel) {
           if (next && next.index !== previousIndex) { current = next; break; }
         }
         if (!current) return finish(failure('selection-unverified'));
+        if (targetIndex > current.maximum) return unavailable();
         if (current.level === target) return finish({ status: 'switched', label: current.label });
       }
       return finish(failure('selection-unverified'));

package/dist/src/browser/browserConnection.js

@@ -0,0 +1,59 @@
+import { withoutBrowserCancellation } from "./cancellation.js";
+const connections = new Map();
+// CRI exposes no ref API. Retain approval while idle without keeping a CLI alive.
+function refTransport(client, active) {
+    const socket = client._ws?._socket;
+    if (active)
+        socket?.ref();
+    else
+        socket?.unref();
+}
+export async function acquireBrowserConnection(endpoint, connect) {
+    let pending = connections.get(endpoint);
+    if (!pending) {
+        pending = Promise.resolve().then(async () => {
+            const client = await withoutBrowserCancellation(connect);
+            const connection = { client, users: 0 };
+            client.on?.("disconnect", () => {
+                if (connections.get(endpoint) === pending)
+                    connections.delete(endpoint);
+            });
+            return connection;
+        });
+        connections.set(endpoint, pending);
+    }
+    let connection;
+    try {
+        connection = await pending;
+    }
+    catch (error) {
+        if (connections.get(endpoint) === pending)
+            connections.delete(endpoint);
+        throw error;
+    }
+    connection.users += 1;
+    refTransport(connection.client, true);
+    let released = false;
+    return new Proxy({}, {
+        ownKeys: () => Reflect.ownKeys(connection.client),
+        getOwnPropertyDescriptor: (_target, key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(connection.client, key);
+            return descriptor ? { ...descriptor, configurable: true } : undefined;
+        },
+        get(_target, key) {
+            const target = connection.client;
+            if (key === "close") {
+                return async () => {
+                    if (released)
+                        return;
+                    released = true;
+                    connection.users -= 1;
+                    if (connection.users === 0)
+                        refTransport(target, false);
+                };
+            }
+            const value = Reflect.get(target, key, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}

package/dist/src/browser/chatgptImages.js

@@ -209,7 +209,7 @@ function detectImageFile(buffer) {
     }
     return null;
 }
-function resolveSiblingImagePath(basePath, index, extension) {
+export function resolveSiblingImagePath(basePath, index, extension) {
     const ext = path.extname(basePath);
     const dir = path.dirname(basePath);
     const stem = ext ? path.basename(basePath, ext) : path.basename(basePath);

package/dist/src/browser/chromeLifecycle.js

@@ -1,4 +1,5 @@
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { EventEmitter } from "node:events";
 import * as childProcess from "node:child_process";
 import net from "node:net";
 import path from "node:path";
@@ -7,6 +8,8 @@ import { launch, Launcher, } from "chrome-launcher";
 import { cleanupStaleProfileState } from "./profileState.js";
 import { delay } from "./utils.js";
 import { isWsl, resolveWslChromeLaunchRoute } from "./wslHost.js";
+import { BrowserCancellation } from "./cancellation.js";
+import { acquireBrowserConnection } from "./browserConnection.js";
 export async function launchChrome(config, userDataDir, logger) {
     const { connectHost, debugBindAddress, usePatchedLauncher } = resolveWslChromeLaunchRoute();
     const debugPort = config.debugPort ?? parseDebugPortEnv();
@@ -388,21 +391,32 @@ export async function closeRemoteChromeTarget(host, port, targetId, logger) {
     }
 }
 export async function listRemoteChromeTargets(options) {
-    if (!options.browserWSEndpoint) {
-        const targets = await CDP.List({ host: options.host, port: options.port });
-        return targets;
-    }
-    const browser = await connectToBrowserWebSocket(options.host, options.port, options.browserWSEndpoint, options.logger ?? (() => { }), options.approvalWaitMs);
+    const logger = options.logger ?? (() => { });
+    const cancellation = new BrowserCancellation(options.signal, logger);
     try {
-        const result = await browser.Target.getTargets();
-        return (result.targetInfos ?? []).map((target) => ({
-            targetId: target.targetId,
-            type: target.type,
-            url: target.url,
-        }));
+        return await cancellation.run(async () => {
+            if (!options.browserWSEndpoint) {
+                const targets = await cancellation.call(() => CDP.List({ host: options.host, port: options.port }));
+                return targets;
+            }
+            const browser = await cancellation.acquire(() => connectToBrowserWebSocket(options.host, options.port, options.browserWSEndpoint, logger, options.approvalWaitMs), (lateBrowser) => lateBrowser.close());
+            try {
+                const client = cancellation.client(browser);
+                const result = await client.Target.getTargets();
+                return (result.targetInfos ?? []).map((target) => ({
+                    targetId: target.targetId,
+                    type: target.type,
+                    url: target.url,
+                    title: target.title,
+                }));
+            }
+            finally {
+                await browser.close().catch(() => undefined);
+            }
+        });
     }
     finally {
-        await browser.close().catch(() => undefined);
+        cancellation.dispose();
     }
 }
 export async function connectToRemoteChromeTarget(host, port, logger, options) {
@@ -418,37 +432,43 @@ export async function connectToRemoteChromeTarget(host, port, logger, options) {
     }
     const browser = await connectToBrowserWebSocket(host, port, options.browserWSEndpoint, logger, options.approvalWaitMs);
     let targetId = options.targetId;
+    let createdTargetId;
     try {
         if (!targetId) {
             const created = await browser.Target.createTarget({
                 url: options.targetUrl ?? "about:blank",
             });
             targetId = created.targetId;
+            createdTargetId = targetId;
             logger(`Opened dedicated remote Chrome tab targeting ${options.targetUrl ?? "about:blank"}`);
         }
         const attached = await browser.Target.attachToTarget({ targetId, flatten: true });
         const client = createSessionBoundChromeClient(browser, attached.sessionId);
+        let closing;
         return {
             client,
             targetId,
             browserWSEndpoint: options.browserWSEndpoint,
-            close: async (closeOptions) => {
-                await browser.Target.detachFromTarget({ sessionId: attached.sessionId }).catch(() => undefined);
+            close: (closeOptions) => (closing ??= (async () => {
                 if (options.closeTargetOnDispose && targetId && !closeOptions?.preserveTarget) {
                     await browser.Target.closeTarget({ targetId }).catch(() => undefined);
                 }
-                await browser.close().catch(() => undefined);
-            },
+                await client.close();
+            })()),
         };
     }
     catch (error) {
+        if (createdTargetId) {
+            await browser.Target.closeTarget({ targetId: createdTargetId }).catch(() => undefined);
+        }
         await browser.close().catch(() => undefined);
         throw error;
     }
 }
 async function connectToBrowserWebSocket(host, port, browserWSEndpoint, logger, approvalWaitMs) {
+    const acquire = () => acquireBrowserConnection(browserWSEndpoint, async () => (await CDP({ target: browserWSEndpoint, local: true })));
     if (!approvalWaitMs || approvalWaitMs <= 0) {
-        return (await CDP({ target: browserWSEndpoint, local: true }));
+        return acquire();
     }
     logger(`[browser] Waiting for Chrome remote debugging approval for ${host}:${port}...`);
     const startedAt = Date.now();
@@ -463,8 +483,8 @@ async function connectToBrowserWebSocket(host, port, browserWSEndpoint, logger,
             let timeout;
             let expired = false;
             try {
-                const connecting = CDP({ target: browserWSEndpoint, local: true }).then(async (client) => {
-                    // An approval arriving after our deadline must not leak a connection.
+                const connecting = acquire().then(async (client) => {
+                    // Release this waiter; another request may still be awaiting the same approval.
                     if (expired)
                         await client.close().catch(() => undefined);
                     return client;
@@ -543,6 +563,37 @@ async function connectToNewTarget(host, port, url, logger, messages) {
 }
 function createSessionBoundChromeClient(browser, sessionId) {
     const browserWithEvents = browser;
+    const events = new EventEmitter();
+    const bridges = new Map();
+    let closing;
+    const remove = (name, listener) => {
+        events.removeListener(name, listener);
+        if (events.listenerCount(name) === 0) {
+            const bridge = bridges.get(name);
+            if (bridge)
+                browserWithEvents.removeListener(name, bridge);
+            bridges.delete(name);
+        }
+    };
+    const listen = (name, listener, once = false) => {
+        if (closing)
+            return () => { };
+        if (!bridges.has(name)) {
+            const bridge = (...args) => events.emit(name, ...args);
+            bridges.set(name, bridge);
+            browserWithEvents.on(name, bridge);
+        }
+        if (once)
+            events.once(name, listener);
+        else
+            events.on(name, listener);
+        return () => remove(name, listener);
+    };
+    const onDetached = (event) => {
+        if (event.sessionId === sessionId)
+            events.emit("disconnect");
+    };
+    browserWithEvents.on("Target.detachedFromTarget", onDetached);
     const bindDomain = (domainName) => {
         const domain = browser[domainName];
         const eventName = (name) => `${domainName}.${name}.${sessionId}`;
@@ -550,25 +601,34 @@ function createSessionBoundChromeClient(browser, sessionId) {
             get(target, prop, receiver) {
                 if (prop === "on") {
                     return (name, listener) => {
-                        const domainEvent = target[name];
-                        if (typeof domainEvent === "function") {
-                            return domainEvent(sessionId, listener);
-                        }
-                        browserWithEvents.on(eventName(name), listener);
-                        return () => browserWithEvents.removeListener(eventName(name), listener);
+                        return listen(eventName(name), listener);
                     };
                 }
                 if (prop === "off" || prop === "removeListener") {
                     return (name, listener) => {
-                        const off = browserWithEvents.off ?? browserWithEvents.removeListener.bind(browserWithEvents);
-                        off(eventName(name), listener);
+                        remove(eventName(name), listener);
                     };
                 }
                 const value = Reflect.get(target, prop, receiver);
                 if (typeof value !== "function") {
                     return value;
                 }
-                return (...args) => value(...args, sessionId);
+                if (value.category === "event") {
+                    return (listener) => listener
+                        ? listen(eventName(String(prop)), listener)
+                        : new Promise((resolve) => listen(eventName(String(prop)), resolve, true));
+                }
+                return (...args) => {
+                    if (closing)
+                        return Promise.reject(new Error("Chrome page session is closed."));
+                    if (typeof args[0] === "function") {
+                        return value({}, sessionId, args[0]);
+                    }
+                    if (typeof args[1] === "function") {
+                        return value(args[0], sessionId, args[1]);
+                    }
+                    return value(...args, sessionId);
+                };
             },
         });
     };
@@ -587,14 +647,23 @@ function createSessionBoundChromeClient(browser, sessionId) {
         Input: bindDomain("Input"),
         DOM: bindDomain("DOM"),
         Emulation: bindDomain("Emulation"),
-        on: browserWithEvents.on.bind(browserWithEvents),
-        once: browserWithEvents.once.bind(browserWithEvents),
-        off: browserWithEvents.off?.bind(browserWithEvents) ??
-            browserWithEvents.removeListener.bind(browserWithEvents),
-        removeListener: browserWithEvents.removeListener.bind(browserWithEvents),
-        close: async () => {
-            await browser.Target.detachFromTarget({ sessionId }).catch(() => undefined);
-        },
+        on: (name, listener) => listen(name, listener),
+        once: (name, listener) => listen(name, listener, true),
+        off: remove,
+        removeListener: remove,
+        close: () => (closing ??= (async () => {
+            for (const [name, bridge] of bridges)
+                browserWithEvents.removeListener(name, bridge);
+            bridges.clear();
+            events.removeAllListeners();
+            browserWithEvents.removeListener("Target.detachedFromTarget", onDetached);
+            try {
+                await browser.Target.detachFromTarget({ sessionId }).catch(() => undefined);
+            }
+            finally {
+                await browser.close();
+            }
+        })()),
     };
 }
 export async function connectWithNewTab(port, logger, initialUrl, host, options) {