codex-chatgpt-control 0.5.1-alpha.3 → 0.5.1-alpha.4

package/dist/src/browser/chatgpt-url.d.ts

@@ -6,3 +6,5 @@ export declare const CHATGPT_HOME = "https://chatgpt.com/";
  */
 export declare function isChatGPTUrl(value: string | undefined): boolean;
 export declare function requireChatGPTUrl(value: string, label: string): string;
+/** Public context for ChatGPT's signed attachment endpoint, never its token. */
+export declare function chatGPTAttachmentContextUrl(value: string | undefined): string | undefined;

package/dist/src/browser/chatgpt-url.js

@@ -26,3 +26,12 @@ export function requireChatGPTUrl(value, label) {
     }
     return value;
 }
+/** Public context for ChatGPT's signed attachment endpoint, never its token. */
+export function chatGPTAttachmentContextUrl(value) {
+    if (!isChatGPTUrl(value))
+        return undefined;
+    const url = new URL(value);
+    if (url.pathname !== "/backend-api/estuary/content")
+        return undefined;
+    return `${url.origin}${url.pathname}`;
+}

package/dist/src/browser/downloads.d.ts

@@ -1,9 +1,23 @@
 import type { DownloadedFile, PageLike } from "../types.js";
+import { ChatGPTControlError } from "../errors.js";
 export type DownloadLike = {
     suggestedFilename?: () => string;
     /** Capability-based stream exposed by Playwright's Download implementation. */
     createReadStream?: () => Promise<AsyncIterable<Uint8Array>>;
     saveAs?: (path: string) => Promise<void>;
-    path?: () => Promise<string | null>;
+    path?: (options?: {
+        timeoutMs?: number;
+    }) => Promise<string | null>;
 };
+export declare class DownloadReceiptTimeoutError extends ChatGPTControlError {
+    constructor(stage: string);
+}
+export declare class DownloadBrowserBlockedError extends ChatGPTControlError {
+    constructor();
+}
+export declare class DownloadReceiptFailedError extends ChatGPTControlError {
+    constructor();
+}
+export declare function isTerminalDownloadError(error: unknown): error is DownloadReceiptTimeoutError | DownloadBrowserBlockedError | DownloadReceiptFailedError;
+export declare function isTerminalDownloadCode(code: string | undefined): boolean;
 export declare function waitForDownloadFromClick(page: PageLike, click: () => Promise<void>, destDir: string, timeoutMs: number, filenameHint?: string): Promise<DownloadedFile>;

package/dist/src/browser/downloads.js

@@ -1,39 +1,161 @@
 import { copyFile, mkdir, stat } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
-import { localGuardTimeout, withTimeout } from "../commands/timeouts.js";
+import { ChatGPTControlError } from "../errors.js";
+import { createDeadline, remainingMs } from "../commands/deadline.js";
+import { withTimeout } from "../commands/timeouts.js";
+import { coordinatedEventRegistrationBarrier, withCoordinatedMutationGuard } from "../runtime/coordinated-page.js";
+export class DownloadReceiptTimeoutError extends ChatGPTControlError {
+    constructor(stage) {
+        super(`Download ${stage} did not complete before the deadline. Completion is unverified; inspect the existing download before retrying.`, "download_unavailable", false, undefined, { code: "download_receipt_timeout", resumable: false });
+    }
+}
+export class DownloadBrowserBlockedError extends ChatGPTControlError {
+    constructor() {
+        super("Chrome displayed ERR_BLOCKED_BY_CLIENT during the download. Inspect the existing download and Chrome restrictions before retrying; completion is unverified.", "download_unavailable", false, undefined, { code: "download_blocked_by_browser", resumable: false });
+    }
+}
+export class DownloadReceiptFailedError extends ChatGPTControlError {
+    constructor() {
+        super("The browser did not provide a verified download receipt. Inspect the existing download before retrying; completion is unverified.", "download_unavailable", false, undefined, { code: "download_receipt_failed", resumable: false });
+    }
+}
+export function isTerminalDownloadError(error) {
+    return error instanceof DownloadReceiptTimeoutError || error instanceof DownloadBrowserBlockedError || error instanceof DownloadReceiptFailedError;
+}
+export function isTerminalDownloadCode(code) {
+    return code === "download_receipt_timeout" || code === "download_blocked_by_browser" || code === "download_receipt_failed";
+}
+async function checkBrowserDownloadError(page, deadline) {
+    if (typeof page.evaluate !== "function")
+        return;
+    // A missing or stalled diagnostic must leave time for the native receipt.
+    // Both probes are read-only, bounded by the existing operation deadline,
+    // and return an enum instead of exporting error-page URLs or body text.
+    const timeoutMs = Math.min(1000, Math.floor(remainingMs(deadline) / 4));
+    if (timeoutMs <= 0)
+        return;
+    let state;
+    try {
+        state = await withTimeout(page.evaluate(function inspectBrowserDownloadError() {
+            if (!document.body?.getAttribute("class")?.split(/\s+/).includes("neterror"))
+                return "unavailable";
+            const frames = document.querySelectorAll("#main-frame-error");
+            if (frames.length !== 1)
+                return "unavailable";
+            const codes = frames[0].querySelectorAll(".error-code");
+            return codes.length === 1 && codes[0].textContent?.trim() === "ERR_BLOCKED_BY_CLIENT"
+                ? "blocked_by_client" : "unavailable";
+        }, undefined, { timeoutMs }), timeoutMs, "Browser download diagnostic timed out.");
+    }
+    catch {
+        return;
+    }
+    if (state === "blocked_by_client")
+        throw new DownloadBrowserBlockedError();
+}
+async function downloadStep(deadline, stage, run, capMs) {
+    const timeoutMs = Math.min(remainingMs(deadline), capMs ?? Number.MAX_SAFE_INTEGER);
+    const timeoutError = new DownloadReceiptTimeoutError(stage);
+    if (timeoutMs <= 0)
+        throw timeoutError;
+    try {
+        return await withTimeout(run(), timeoutMs, timeoutError.message);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === timeoutError.message)
+            throw timeoutError;
+        throw error;
+    }
+}
 export async function waitForDownloadFromClick(page, click, destDir, timeoutMs, filenameHint) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647) {
+        throw new Error("Download timeout must be positive and within the supported timer range.");
+    }
+    const deadline = createDeadline(timeoutMs);
+    await checkBrowserDownloadError(page, deadline);
     const absoluteDest = resolve(destDir);
-    await mkdir(absoluteDest, { recursive: true });
-    const downloadPromise = page.waitForEvent?.("download", { timeout: timeoutMs, timeoutMs });
-    if (downloadPromise === undefined) {
+    await downloadStep(deadline, "destination preparation", () => mkdir(absoluteDest, { recursive: true }));
+    if (typeof page.waitForEvent !== "function") {
         throw new Error("The active browser page does not expose download events.");
     }
-    await withTimeout(click(), localGuardTimeout(timeoutMs, 10000), "Download control click did not complete before the local guard timeout.");
-    const download = await downloadPromise;
-    const sourcePath = typeof download.path === "function" ? await download.path() : null;
-    const suggestedFilename = filenameHint
-        ?? download.suggestedFilename?.()
-        ?? (sourcePath === null ? undefined : basename(sourcePath))
-        ?? `chatgpt-download-${Date.now()}`;
-    const targetPath = join(absoluteDest, basename(suggestedFilename));
-    if (typeof download.saveAs === "function") {
-        await download.saveAs(targetPath);
-    }
-    else if (sourcePath !== null) {
-        if (resolve(sourcePath) !== resolve(targetPath)) {
-            await copyFile(sourcePath, targetPath);
+    // Arm before activation. Promise.all observes both rejections immediately,
+    // including a late event rejection after a failed or timed-out click.
+    const nativeTimeoutMs = remainingMs(deadline);
+    if (nativeTimeoutMs <= 0)
+        throw new DownloadReceiptTimeoutError("event registration");
+    const activation = new AbortController();
+    let failure;
+    const assertActive = () => {
+        if (failure !== undefined)
+            throw failure;
+        if (activation.signal.aborted || remainingMs(deadline) <= 0)
+            throw new DownloadReceiptTimeoutError("control click");
+    };
+    try {
+        const rawWait = page.waitForEvent("download", { timeout: nativeTimeoutMs, timeoutMs: nativeTimeoutMs });
+        const registration = coordinatedEventRegistrationBarrier(rawWait);
+        let receiptFailed = false;
+        const downloadPromise = downloadStep(deadline, "event receipt", () => rawWait).catch(error => {
+            receiptFailed = true;
+            failure = isTerminalDownloadError(error) ? error : new DownloadReceiptFailedError();
+            activation.abort(failure);
+            throw failure;
+        });
+        const [download] = await Promise.all([
+            downloadPromise,
+            (async () => {
+                // Actor fairness may choose a queued mutation before another read.
+                // Registration must finish before the activating click is even queued.
+                if (registration !== undefined)
+                    await downloadStep(deadline, "event registration", () => registration);
+                try {
+                    await downloadStep(deadline, "control click", () => withCoordinatedMutationGuard(activation.signal, assertActive, click), 10_000);
+                }
+                catch (error) {
+                    if (!receiptFailed)
+                        await checkBrowserDownloadError(page, deadline);
+                    throw error;
+                }
+                if (!receiptFailed)
+                    await checkBrowserDownloadError(page, deadline);
+            })()
+        ]);
+        // saveAs is already a complete capability; an optional path() call can hang
+        // on bridge implementations and is unnecessary when saveAs is available.
+        const sourcePath = typeof download.saveAs !== "function" && typeof download.path === "function"
+            ? await downloadStep(deadline, "source path", () => download.path({ timeoutMs: remainingMs(deadline) })) : null;
+        const suggestedFilename = filenameHint
+            ?? download.suggestedFilename?.()
+            ?? (sourcePath === null ? undefined : basename(sourcePath))
+            ?? `chatgpt-download-${Date.now()}`;
+        const targetPath = join(absoluteDest, basename(suggestedFilename));
+        if (typeof download.saveAs === "function") {
+            await downloadStep(deadline, "file save", () => download.saveAs(targetPath));
+        }
+        else if (sourcePath !== null) {
+            if (resolve(sourcePath) !== resolve(targetPath)) {
+                await downloadStep(deadline, "file copy", () => copyFile(sourcePath, targetPath));
+            }
+        }
+        else {
+            throw new Error("The browser download object exposes neither saveAs() nor a completed local path().");
         }
+        const saved = await downloadStep(deadline, "file verification", () => stat(targetPath));
+        if (saved.size <= 0) {
+            throw new Error(`Downloaded file is empty: ${targetPath}`);
+        }
+        return {
+            path: targetPath,
+            suggestedFilename,
+            bytes: saved.size
+        };
     }
-    else {
-        throw new Error("The browser download object exposes neither saveAs() nor a completed local path().");
+    catch (error) {
+        throw failure ?? (isTerminalDownloadError(error) ? error : new DownloadReceiptFailedError());
     }
-    const saved = await stat(targetPath);
-    if (saved.size <= 0) {
-        throw new Error(`Downloaded file is empty: ${targetPath}`);
+    finally {
+        // Cancels locally queued activation only. A native download already in
+        // progress, or its native event listener, is not claimed to be cancelled.
+        activation.abort();
     }
-    return {
-        path: targetPath,
-        suggestedFilename,
-        bytes: saved.size
-    };
 }

package/dist/src/browser/page-state.js

@@ -2,6 +2,7 @@ import { classifyVisibleText } from "../safety/blockers.js";
 import { compactVisibleText } from "../safety/redaction.js";
 import { escapeRegExp, localeLabels } from "../dom/locale-labels.js";
 import { withTimeout } from "../commands/timeouts.js";
+import { chatGPTAttachmentContextUrl } from "./chatgpt-url.js";
 export function parseConversationId(url) {
     let parsed;
     try {
@@ -19,6 +20,11 @@ export function parseConversationId(url) {
 export async function readPageState(page) {
     const rawUrl = typeof page.url === "function" ? await Promise.resolve(page.url()).catch(() => "") : "";
     const url = typeof rawUrl === "string" ? rawUrl : "";
+    // This is a file transfer endpoint, not a conversation surface. Keep the
+    // internal URL for origin checks without inspecting error-page content.
+    if (chatGPTAttachmentContextUrl(url) !== undefined) {
+        return { url, visibleText: "", signedIn: false };
+    }
     const rawTitle = typeof page.title === "function" ? await page.title().catch(() => undefined) : undefined;
     const title = typeof rawTitle === "string" ? rawTitle : undefined;
     const surface = await readPageSurfaceSnapshot(page);

package/dist/src/client.d.ts

@@ -38,6 +38,11 @@ export type ChatGPTClientOptions = RuntimeEnv & {
  */
 export type ChatGPTOperationsOptions = Readonly<{
     stateRoot?: string;
+    /** Explicit private-file connection to a normal Node journal authority. */
+    journalService?: Readonly<{
+        descriptorPath: string;
+        timeoutMs?: number;
+    }>;
     adapter?: OperationBrowserAdapter;
     adapterFactory?: OperationAdapterFactory;
     handleAdapterFactory?: OperationHandleAdapterFactory;

package/dist/src/client.js

@@ -23,7 +23,8 @@ import { streamFromRunResult } from "./runner/stream.js";
 import { redactReportValue } from "./safety/report-redaction.js";
 import { explainCommandBlocker } from "./diagnostics/blockers.js";
 import { OperationClient, OperationClientError } from "./operations/client.js";
-import { OperationJournal } from "./operations/journal.js";
+import { JOURNAL_RUNTIME_UNAVAILABLE_MESSAGE, OperationJournal, OperationJournalError } from "./operations/journal.js";
+import { createJournalRpcClientFromDescriptor } from "./operations/journal-rpc-client.js";
 import { OperationService } from "./operations/service.js";
 import { OPERATION_CONTROL_REQUEST_SCHEMA_VERSION, OPERATION_REQUEST_SCHEMA_VERSION } from "./operations/types.js";
 import { createRuntimeEnvSession } from "./runtime/runtime-session.js";
@@ -634,7 +635,14 @@ function runtimeEnv(options) {
 }
 async function createOperationClientForChatGPT(options, runtimeEnvironment, owner) {
     const operationOptions = options.operations ?? {};
-    const journal = await OperationJournal.open(operationOptions.stateRoot === undefined ? {} : { stateRoot: operationOptions.stateRoot });
+    if (operationOptions.journalService !== undefined && operationOptions.stateRoot !== undefined) {
+        throw new OperationJournalError("journal_service_configuration_conflict", "The journal service owns its state root; configure either journalService or stateRoot.");
+    }
+    const journal = operationOptions.journalService === undefined
+        ? await OperationJournal.open(operationOptions.stateRoot === undefined ? {} : { stateRoot: operationOptions.stateRoot })
+        : await createJournalRpcClientFromDescriptor(operationOptions.journalService.descriptorPath, {
+            ...(operationOptions.journalService.timeoutMs === undefined ? {} : { timeoutMs: operationOptions.journalService.timeoutMs })
+        });
     const serviceOptions = {
         ...(operationOptions.maxCasRetries === undefined ? {} : { maxCasRetries: operationOptions.maxCasRetries }),
         ...(options.now === undefined ? {} : { now: () => options.now().getTime() })
@@ -1158,11 +1166,15 @@ function transactionalWorkBlockerResult(data, code, uncertain, recoverable) {
 }
 function transactionalWorkError(operationId, error, controlActionId, parentHandle) {
     const code = safeOwnErrorCode(error) ?? "operation_error";
-    const message = `Transactional Work operation failed (${code.replaceAll("_", " ")}).`;
+    const runtimeUnavailable = code === "journal_runtime_unavailable";
+    const serviceUnavailable = JOURNAL_SERVICE_FAILURE_CODES.has(code);
+    const indeterminate = code === "journal_rpc_outcome_indeterminate";
+    const message = runtimeUnavailable ? JOURNAL_RUNTIME_UNAVAILABLE_MESSAGE : serviceUnavailable ? journalServiceFailureMessage(code) : `Transactional Work operation failed (${code.replaceAll("_", " ")}).`;
     const blocker = code === "adapter_unavailable"
         || code === "browser_bridge_unavailable"
         || code === "target_evidence_unavailable"
-        || code === "backend_unavailable";
+        || code === "backend_unavailable"
+        || runtimeUnavailable || serviceUnavailable;
     const data = parentHandle === undefined
         ? {
             operationId,
@@ -1177,11 +1189,21 @@ function transactionalWorkError(operationId, error, controlActionId, parentHandl
         };
     return {
         ok: false,
-        status: blocker ? "blocked" : "error",
+        status: indeterminate ? "partial" : blocker ? "blocked" : "error",
         data,
         warnings: [],
-        ...(blocker ? { blocker: { kind: transactionalBlockerKind(code), code, message, resumable: true } } : {}),
-        error: { name: "OperationError", message, recoverable: blocker },
+        ...(blocker ? { blocker: {
+                kind: transactionalBlockerKind(code), code, message, resumable: !runtimeUnavailable && !serviceUnavailable,
+                ...(runtimeUnavailable ? { remediation: [{
+                            label: "Use a supported transactional host",
+                            instruction: "Start the packaged journal service in a supported Node host and configure operations.journalService.descriptorPath in the browser client.",
+                            userActionRequired: false
+                        }] } : serviceUnavailable ? { remediation: [{
+                            ...journalServiceRemediation(code),
+                            userActionRequired: false
+                        }] } : {})
+            } } : {}),
+        error: { name: "OperationError", message, recoverable: blocker && !runtimeUnavailable && !serviceUnavailable },
         context: { timestamp: new Date().toISOString(), experience: "work" }
     };
 }
@@ -1619,17 +1641,52 @@ function transactionalBlockerKind(code) {
         return "upload_failed";
     return "unknown";
 }
+const JOURNAL_SERVICE_FAILURE_CODES = new Set([
+    "journal_rpc_unavailable", "journal_rpc_authentication_failed", "journal_rpc_protocol_error",
+    "journal_rpc_limit_exceeded", "journal_rpc_outcome_indeterminate", "journal_rpc_request_rejected",
+    "journal_rpc_unsupported_platform"
+]);
+function journalServiceFailureMessage(code) {
+    if (code === "journal_rpc_unsupported_platform") {
+        return "The private-file journal service requires POSIX file ownership and permissions and is unavailable on Windows.";
+    }
+    return code === "journal_rpc_outcome_indeterminate"
+        ? "The journal service connection ended without confirming a durable write. Preserve the operation identity and reconcile its state before any further browser action."
+        : "The configured journal service could not provide authenticated operation state. Restore its private connection before continuing.";
+}
+function journalServiceRemediation(code) {
+    return code === "journal_rpc_unsupported_platform" ? {
+        label: "Use a supported journal host",
+        instruction: "On Windows, use the local journal in an ordinary Node browser host without operations.journalService. The private-file journal service requires a POSIX host. Preserve any existing operation identity."
+    } : {
+        label: "Reconnect the same journal",
+        instruction: "Restore the private journal-service connection, then inspect or reconcile the same operation identity. Never create a new operation ID to retry an uncertain Send."
+    };
+}
 function transactionalAskError(operationId, error) {
     const code = safeOwnErrorCode(error) ?? "operation_error";
-    const blocker = code === "adapter_unavailable" || code === "browser_bridge_unavailable" || code === "target_evidence_unavailable";
-    const message = `Transactional operation failed (${code.replaceAll("_", " ")}).`;
+    const runtimeUnavailable = code === "journal_runtime_unavailable";
+    const serviceUnavailable = JOURNAL_SERVICE_FAILURE_CODES.has(code);
+    const indeterminate = code === "journal_rpc_outcome_indeterminate";
+    const blocker = runtimeUnavailable || serviceUnavailable || code === "adapter_unavailable" || code === "browser_bridge_unavailable" || code === "target_evidence_unavailable";
+    const message = runtimeUnavailable ? JOURNAL_RUNTIME_UNAVAILABLE_MESSAGE : serviceUnavailable ? journalServiceFailureMessage(code) : `Transactional operation failed (${code.replaceAll("_", " ")}).`;
     return {
         ok: false,
-        status: blocker ? "blocked" : "error",
+        status: indeterminate ? "partial" : blocker ? "blocked" : "error",
         data: { operationId },
         warnings: [],
-        ...(blocker ? { blocker: { kind: transactionalBlockerKind(code), code, message, resumable: true } } : {}),
-        error: { name: "OperationError", message, recoverable: blocker },
+        ...(blocker ? { blocker: {
+                kind: transactionalBlockerKind(code), code, message, resumable: !runtimeUnavailable && !serviceUnavailable,
+                ...(runtimeUnavailable ? { remediation: [{
+                            label: "Use a supported transactional host",
+                            instruction: "Start the packaged journal service in a supported Node host and configure operations.journalService.descriptorPath in the browser client.",
+                            userActionRequired: false
+                        }] } : serviceUnavailable ? { remediation: [{
+                            ...journalServiceRemediation(code),
+                            userActionRequired: false
+                        }] } : {})
+            } } : {}),
+        error: { name: "OperationError", message, recoverable: blocker && !runtimeUnavailable && !serviceUnavailable },
         context: { timestamp: new Date().toISOString() }
     };
 }

package/dist/src/commands/artifacts.js

@@ -1,11 +1,11 @@
 import { copyFile, mkdir, stat, writeFile } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
-import { waitForDownloadFromClick } from "../browser/downloads.js";
+import { isTerminalDownloadCode, isTerminalDownloadError, waitForDownloadFromClick } from "../browser/downloads.js";
 import { readPageState } from "../browser/page-state.js";
 import { listPageArtifacts, readLatestImageDataUrl } from "../dom/artifacts.js";
 import { cssSelectors, requiredLocator } from "../dom/selectors.js";
 import { localeLabels } from "../dom/locale-labels.js";
-import { resultOk } from "../errors.js";
+import { resultError, resultOk } from "../errors.js";
 import { contextFromPage } from "./context.js";
 import { ensurePage } from "./session.js";
 import { localGuardTimeout, withTimeout } from "./timeouts.js";
@@ -112,7 +112,7 @@ export async function downloadLatestArtifact(env, args) {
     const timeoutMs = args.timeoutMs ?? 120000;
     if (args.prefer !== "visible_image_source") {
         const byDownload = await tryDownloadControl(page, args, timeoutMs);
-        if (byDownload.ok || args.prefer === "download_control") {
+        if (byDownload.ok || isTerminalDownloadCode(byDownload.blocker?.code) || args.prefer === "download_control") {
             return byDownload;
         }
     }
@@ -156,7 +156,7 @@ async function tryDownloadControl(page, args, timeoutMs) {
         return resultOk(downloaded, await contextFromPage(page));
     }
     catch (error) {
-        return artifactDownloadBlocker(error, await contextFromPage(page));
+        return artifactDownloadBlocker(error, await contextFromPage(page, {}, { minimal: isTerminalDownloadError(error) }));
     }
 }
 async function saveLatestVisibleImageSource(page, destDir, timeoutMs) {
@@ -395,6 +395,8 @@ function artifactSelectorBlocker(error, context) {
     };
 }
 function artifactDownloadBlocker(error, context) {
+    if (isTerminalDownloadError(error))
+        return resultError(error, context);
     return {
         ok: false,
         status: "unsupported",

package/dist/src/commands/chat-popover.d.ts

@@ -0,0 +1,37 @@
+import type { PageLike } from "../types.js";
+export type ChatPopoverSnapshot = {
+    view: "simple" | "advanced";
+    rootIndex: number;
+    triggerId?: string;
+    toggleIndex: number;
+    modelOptions: Array<{
+        label: string;
+        checked: boolean;
+        index: number;
+    }>;
+    activeModel?: string;
+    effort?: string;
+    speed?: "Standard" | "Fast";
+    speedIndex?: number;
+    slider?: {
+        index: number;
+        minimum: number;
+        maximum: number;
+        current: number;
+        valueText?: string;
+    };
+};
+/** Inactive model radios retain geometry. Require an owned, active, non-inert view. */
+export declare function readChatPopover(page: PageLike): Promise<{
+    snapshot?: ChatPopoverSnapshot;
+    acted: boolean;
+}>;
+export declare function closeChatPopover(page: PageLike, before?: ChatPopoverSnapshot): Promise<boolean>;
+export declare function setChatPopoverView(page: PageLike, view: ChatPopoverSnapshot["view"]): Promise<ChatPopoverSnapshot | undefined>;
+/** Opens the model view for evidence; does not probe slider values during inspection. */
+export declare function inspectChatPopover(page: PageLike): Promise<ChatPopoverSnapshot | undefined>;
+export declare function selectChatPopoverModel(page: PageLike, labels: string[]): Promise<string | undefined>;
+/** Search the observed bounded range during mutation, restoring an unmatched search. */
+export declare function selectChatPopoverEffort(page: PageLike, labels: string[]): Promise<string | undefined>;
+/** The optional Work fast-mode checkbox is independent of model and effort. */
+export declare function selectChatPopoverSpeed(page: PageLike, labels: string[]): Promise<string | undefined>;