dsh-browser-plus 0.0.0-stage → 0.5.0

package/lib/browser/runtime.d.ts

@@ -0,0 +1,225 @@
+/**
+ * Service Definition for the browser capability seam (`ctx.browser`): the
+ * provider registry and provider-selecting execution for browser sessions.
+ * Duplicate ids are rejected. At execution time, a configured provider must
+ * exist and be usable; without one, exactly one usable provider is required,
+ * so selection never depends on registration order.
+ * @module dsh-browser-plus/browser
+ */
+import { Context, Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { BrowserContentRequest, BrowserHandoffState, BrowserContentResult, BrowserDownloadRequest, BrowserExecuteRequest, BrowserExecuteResult, BrowserFillRequest, BrowserFillResult, BrowserHistoryEntry, BrowserNavigateRequest, BrowserOpenOptions, BrowserOpenRequest, BrowserDragRequest, BrowserDragResult, BrowserPointerResult, BrowserPointerTarget, BrowserPressKeyRequest, BrowserClearAuthRequest, BrowserScrapeRequest, BrowserScrapeStatus, BrowserClearAuthResult, BrowserProvider, BrowserRefRequest, BrowserScreenshotRequest, BrowserScreenshotResult, BrowserScrollIntoViewRequest, BrowserScrollRequest, BrowserScrollResult, BrowserSessionId, BrowserSnapshotResult, BrowserSpaceInfo, BrowserTaskInfo, BrowserTaskUpdate, BrowserTab, BrowserTypeRequest, BrowserUploadFileRequest, BrowserUploadFileResult, BrowserWaitForRequest, BrowserWaitForResult, BrowserChallenge, ExportedCookie } from './types.ts';
+export { BrowserError, } from './types.ts';
+export type { BrowserChallenge, BrowserContentFormat, BrowserControlOwner, BrowserContentRequest, BrowserContentResult, BrowserDownloadRequest, BrowserExecuteRequest, BrowserExecuteResult, BrowserFillField, BrowserFillRequest, BrowserFillResult, BrowserHandoffState, BrowserHistoryEntry, BrowserNavigateRequest, BrowserOpenOptions, BrowserOpenRequest, BrowserDragRequest, BrowserDragResult, BrowserPointerResult, BrowserPointerTarget, BrowserPressKeyRequest, BrowserClearAuthRequest, BrowserScrapeRequest, BrowserScrapeStatus, BrowserClearAuthResult, BrowserProvider, BrowserRefRequest, BrowserScreenshotRequest, BrowserScreenshotResult, BrowserScrollIntoViewRequest, BrowserScrollRequest, BrowserScrollResult, BrowserSessionId, BrowserSnapshotElement, BrowserSnapshotResult, BrowserSpaceInfo, BrowserTaskInfo, BrowserTaskStatus, BrowserTaskUpdate, BrowserTab, BrowserTypeRequest, BrowserUploadFileRequest, BrowserUploadFileResult, BrowserWaitForRequest, BrowserWaitForResult, ExportedCookie, } from './types.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        browser: BrowserRuntime;
+    }
+}
+/**
+ * Config for the browser seam. `browserProvider` pins which provider wins;
+ * it is optional (a single registered usable provider auto-selects).
+ */
+export interface BrowserRuntimeConfig {
+    /** Explicit browser provider id. Omitted = auto-select when exactly one usable. */
+    readonly browserProvider?: string;
+}
+/**
+ * The browser access service. Registered as `ctx.browser` (one instance per
+ * context).
+ *
+ * Selection semantics (resolved at execution time, never order-dependent):
+ * - A configured id that is registered and `available()` → that provider.
+ * - A configured id not registered → `BROWSER_PROVIDER_CONFIGURED_MISSING`.
+ * - A configured id registered but unavailable → `BROWSER_PROVIDER_CONFIGURED_UNAVAILABLE`.
+ * - No id configured, exactly one registered usable provider → that provider.
+ * - No id configured, multiple usable providers → `BROWSER_PROVIDER_AMBIGUOUS`.
+ * - No id configured, no usable provider → `BROWSER_PROVIDER_UNAVAILABLE`.
+ */
+export declare class BrowserRuntime extends Service {
+    /** Provider selection config. */
+    static Config: z<BrowserRuntimeConfig>;
+    private providers;
+    private readonly providerId;
+    constructor(ctx: Context, config?: BrowserRuntimeConfig);
+    /**
+     * Register a browser provider. Throws {@link BrowserError}
+     * `BROWSER_DUPLICATE_PROVIDER` if its id is already registered. Returns a
+     * disposer; disposed with the calling fiber.
+     * @param provider - the provider; its `id` is the registry key.
+     * @returns the disposer that unregisters the provider.
+     */
+    registerBrowserProvider(provider: BrowserProvider): () => void;
+    /** Resolve the selected provider or throw the matching {@link BrowserError}. */
+    private resolveProvider;
+    /** Open a new browser session through the selected provider. */
+    open(options?: BrowserOpenOptions): Promise<BrowserSessionId>;
+    /** Open a URL through the selected provider, optionally in a new tab. */
+    openUrl(session: BrowserSessionId, request: BrowserOpenRequest, signal?: AbortSignal): Promise<void>;
+    /** List the session's tabs through the selected provider. */
+    listTabs(session: BrowserSessionId): Promise<readonly BrowserTab[]>;
+    /** Switch to a tab through the selected provider. */
+    switchTab(session: BrowserSessionId, tabId: string): Promise<void>;
+    /** Close one tab through the selected provider. */
+    closeTab(session: BrowserSessionId, tabId: string): Promise<boolean>;
+    /** Close every tab and reset the session through the selected provider. */
+    reset(session: BrowserSessionId): Promise<void>;
+    /** Navigate the session's page through the selected provider. */
+    navigate(session: BrowserSessionId, request: BrowserNavigateRequest, signal?: AbortSignal): Promise<void>;
+    /** Navigate to the previous history entry through the selected provider. */
+    back(session: BrowserSessionId, signal?: AbortSignal): Promise<boolean>;
+    /** Navigate to the next history entry through the selected provider. */
+    forward(session: BrowserSessionId, signal?: AbortSignal): Promise<boolean>;
+    /** Reload the active page through the selected provider. */
+    reload(session: BrowserSessionId, signal?: AbortSignal): Promise<void>;
+    /** Stop loading the active page through the selected provider. */
+    stopLoading(session: BrowserSessionId, signal?: AbortSignal): Promise<void>;
+    /** Execute JS in the session's page context through the selected provider. */
+    execute(session: BrowserSessionId, request: BrowserExecuteRequest, signal?: AbortSignal): Promise<BrowserExecuteResult>;
+    /** Produce an AI-friendly snapshot of the session's page. */
+    snapshot(session: BrowserSessionId, options?: {
+        query?: string;
+        limit?: number;
+    }, signal?: AbortSignal): Promise<BrowserSnapshotResult>;
+    /** Apply device/viewport/media emulation to the session's active tab. */
+    emulate(session: BrowserSessionId, options?: {
+        width?: number;
+        height?: number;
+        deviceScaleFactor?: number;
+        mobile?: boolean;
+        userAgent?: string;
+        colorScheme?: 'light' | 'dark' | 'no-preference';
+        clear?: boolean;
+    }): Promise<{
+        applied: string[];
+    }>;
+    /** Console messages the host captured for the session's active tab. */
+    consoleMessages(session: BrowserSessionId, options?: {
+        limit?: number;
+        level?: string;
+        clear?: boolean;
+    }): Promise<{
+        messages: Array<{
+            level: string;
+            text: string;
+            at: string;
+        }>;
+    }>;
+    /** Network requests the host captured for the session's active tab. */
+    networkRequests(session: BrowserSessionId, options?: {
+        limit?: number;
+        failedOnly?: boolean;
+        urlContains?: string;
+        clear?: boolean;
+    }): Promise<{
+        requests: Array<{
+            method: string;
+            url: string;
+            status?: number;
+            mime?: string;
+            kind?: string;
+            failed?: string;
+            ms?: number;
+            at: string;
+        }>;
+    }>;
+    /** Set how the host answers the next JS dialog, and report the state. */
+    setDialogPolicy(session: BrowserSessionId, policy: {
+        behavior: 'accept' | 'dismiss';
+        promptText?: string;
+    }): Promise<{
+        dialog: unknown;
+        policy: {
+            behavior: 'accept' | 'dismiss';
+            promptText?: string;
+        };
+    }>;
+    /** Drain any pending dialog, then report the last one and the current policy. */
+    inspectDialog(session: BrowserSessionId): Promise<{
+        dialog: unknown;
+        policy: {
+            behavior: 'accept' | 'dismiss';
+            promptText?: string;
+        };
+    }>;
+    /** The last JS dialog the host reported, plus the current policy. */
+    dialogState(session: BrowserSessionId): {
+        dialog: unknown;
+        policy: {
+            behavior: 'accept' | 'dismiss';
+            promptText?: string;
+        };
+    };
+    /** Click one element referenced by an exact snapshot. */
+    clickRef(session: BrowserSessionId, request: BrowserRefRequest, signal?: AbortSignal): Promise<void>;
+    /** Scroll one element referenced by an exact snapshot into view. */
+    scrollIntoView(session: BrowserSessionId, request: BrowserScrollIntoViewRequest, signal?: AbortSignal): Promise<BrowserScrollResult>;
+    /** Fetch page content in a requested format. */
+    content(session: BrowserSessionId, request: BrowserContentRequest, signal?: AbortSignal): Promise<BrowserContentResult>;
+    /** Click at viewport coordinates through the selected provider. */
+    click(session: BrowserSessionId, request: BrowserPointerTarget, signal?: AbortSignal): Promise<BrowserPointerResult>;
+    /** Double-click at viewport coordinates through the selected provider. */
+    doubleClick(session: BrowserSessionId, request: BrowserPointerTarget, signal?: AbortSignal): Promise<BrowserPointerResult>;
+    /** Press on one target, move to another, release, through the selected provider. */
+    drag(session: BrowserSessionId, request: BrowserDragRequest, signal?: AbortSignal): Promise<BrowserDragResult>;
+    hover(session: BrowserSessionId, request: BrowserPointerTarget, signal?: AbortSignal): Promise<BrowserPointerResult>;
+    /** Scroll the active page through the selected provider. */
+    scroll(session: BrowserSessionId, request: BrowserScrollRequest, signal?: AbortSignal): Promise<BrowserScrollResult>;
+    /** Attach a local file to a file input through the selected provider. */
+    uploadFile(session: BrowserSessionId, request: BrowserUploadFileRequest, signal?: AbortSignal): Promise<BrowserUploadFileResult>;
+    /** Wait for an element through the selected provider (bounded polling). */
+    waitForElement(session: BrowserSessionId, request: BrowserWaitForRequest, signal?: AbortSignal): Promise<BrowserWaitForResult>;
+    /** Type into the focused element through the selected provider. */
+    type(session: BrowserSessionId, request: BrowserTypeRequest, signal?: AbortSignal): Promise<void>;
+    /** Press a key into the session's page through the selected provider. */
+    pressKey(session: BrowserSessionId, request: BrowserPressKeyRequest, signal?: AbortSignal): Promise<void>;
+    /** Fill a form's fields in one batch through the selected provider. */
+    fillForm(session: BrowserSessionId, request: BrowserFillRequest, signal?: AbortSignal): Promise<BrowserFillResult>;
+    /** Capture the current page through the selected provider. */
+    screenshot(session: BrowserSessionId, request?: BrowserScreenshotRequest, signal?: AbortSignal): Promise<BrowserScreenshotResult>;
+    /** Check for a human-verification challenge on the active tab. */
+    detectChallenge(session: BrowserSessionId, signal?: AbortSignal): Promise<BrowserChallenge>;
+    /** Return the session's chronological operation log through the provider. */
+    history(session: BrowserSessionId): Promise<readonly BrowserHistoryEntry[]>;
+    /** Replay one recorded operation by sequence number through the provider. */
+    replay(session: BrowserSessionId, seq: number): Promise<void>;
+    /** Download a URL to a local file through the provider. */
+    download(session: BrowserSessionId, request: BrowserDownloadRequest, signal?: AbortSignal): Promise<{
+        readonly path: string;
+    }>;
+    /** Export the session's cookies through the provider. */
+    flushAuth(session: BrowserSessionId): Promise<readonly ExportedCookie[]>;
+    /** Import cookies into the session through the provider. */
+    restoreAuth(session: BrowserSessionId, cookies: readonly ExportedCookie[]): Promise<number>;
+    /** Import cookies from a JSON export on disk through the provider. */
+    importAuth(session: BrowserSessionId, path: string): Promise<{
+        restored: number;
+        failed: number;
+    }>;
+    /** Start a background scrape batch through the provider. */
+    startScrape(session: BrowserSessionId, request: BrowserScrapeRequest): Promise<BrowserScrapeStatus>;
+    /** Progress of one scrape batch through the provider. */
+    scrapeStatus(id: string): Promise<BrowserScrapeStatus>;
+    /** Ask a running scrape batch to stop through the provider. */
+    stopScrape(id: string): Promise<BrowserScrapeStatus>;
+    /** Every scrape batch the provider knows about. */
+    listScrapes(): Promise<readonly BrowserScrapeStatus[]>;
+    /** Remove cookies for one site scope through the provider. */
+    clearAuth(session: BrowserSessionId, request: BrowserClearAuthRequest): Promise<BrowserClearAuthResult>;
+    /** Set the session's browser task label through the selected provider. */
+    setSpace(session: BrowserSessionId, label: string): Promise<void>;
+    /** List browser tasks (legacy spaces) with labels through the selected provider. */
+    listSpaces(): Promise<readonly BrowserSpaceInfo[]>;
+    /** List browser tasks with live collaboration status through the provider. */
+    listTasks(): Promise<readonly BrowserTaskInfo[]>;
+    /** Read one session's task collaboration state through the provider. */
+    getTask(session: BrowserSessionId): Promise<BrowserTaskInfo>;
+    /** Update one session's visible task state through the provider. */
+    updateTask(session: BrowserSessionId, update: BrowserTaskUpdate): Promise<BrowserTaskInfo>;
+    /** Mark one session as waiting for the user or returned to Agent control. */
+    setHandoff(session: BrowserSessionId, state: BrowserHandoffState): Promise<BrowserTaskInfo>;
+    /** Close the session through the selected provider. Idempotent; a missing
+     *  provider is treated as already-closed so teardown paths stay no-ops. */
+    close(session: BrowserSessionId): Promise<void>;
+}
+export default BrowserRuntime;

package/lib/browser/runtime.js

@@ -0,0 +1,302 @@
+/**
+ * Service Definition for the browser capability seam (`ctx.browser`): the
+ * provider registry and provider-selecting execution for browser sessions.
+ * Duplicate ids are rejected. At execution time, a configured provider must
+ * exist and be usable; without one, exactly one usable provider is required,
+ * so selection never depends on registration order.
+ * @module dsh-browser-plus/browser
+ */
+import { Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { BrowserError } from "./types.js";
+export { BrowserError, } from "./types.js";
+/**
+ * The browser access service. Registered as `ctx.browser` (one instance per
+ * context).
+ *
+ * Selection semantics (resolved at execution time, never order-dependent):
+ * - A configured id that is registered and `available()` → that provider.
+ * - A configured id not registered → `BROWSER_PROVIDER_CONFIGURED_MISSING`.
+ * - A configured id registered but unavailable → `BROWSER_PROVIDER_CONFIGURED_UNAVAILABLE`.
+ * - No id configured, exactly one registered usable provider → that provider.
+ * - No id configured, multiple usable providers → `BROWSER_PROVIDER_AMBIGUOUS`.
+ * - No id configured, no usable provider → `BROWSER_PROVIDER_UNAVAILABLE`.
+ */
+export class BrowserRuntime extends Service {
+    /** Provider selection config. */
+    static Config = z.object({
+        browserProvider: z.string(),
+    });
+    providers = new Map();
+    providerId;
+    constructor(ctx, config = {}) {
+        super(ctx, 'browser');
+        this.providerId = config.browserProvider;
+    }
+    /**
+     * Register a browser provider. Throws {@link BrowserError}
+     * `BROWSER_DUPLICATE_PROVIDER` if its id is already registered. Returns a
+     * disposer; disposed with the calling fiber.
+     * @param provider - the provider; its `id` is the registry key.
+     * @returns the disposer that unregisters the provider.
+     */
+    registerBrowserProvider(provider) {
+        if (this.providers.has(provider.id)) {
+            throw new BrowserError(`a browser provider with id "${provider.id}" is already registered`, 'BROWSER_DUPLICATE_PROVIDER');
+        }
+        // Bind the generator to this instance instead of aliasing `this` to a
+        // local (no-this-alias): the effect body mutates the instance registry.
+        const dispose = this.ctx.effect(function* () {
+            this.providers.set(provider.id, provider);
+            yield () => this.providers.delete(provider.id);
+        }.bind(this), 'browser.registerProvider()');
+        // ctx.effect's disposer returns Promise<void>; our disposer API is
+        // synchronous fire-and-forget — discard the (always-resolved) promise.
+        return () => void dispose();
+    }
+    /** Resolve the selected provider or throw the matching {@link BrowserError}. */
+    resolveProvider() {
+        const { providerId, providers } = this;
+        if (providerId !== undefined) {
+            const provider = providers.get(providerId);
+            if (!provider) {
+                throw new BrowserError(`configured browser provider "${providerId}" is not registered`, 'BROWSER_PROVIDER_CONFIGURED_MISSING');
+            }
+            if (!provider.available()) {
+                throw new BrowserError(`configured browser provider "${providerId}" is registered but unavailable`, 'BROWSER_PROVIDER_CONFIGURED_UNAVAILABLE');
+            }
+            return provider;
+        }
+        const usable = [...providers.values()].filter(provider => provider.available());
+        const [single] = usable;
+        if (single === undefined) {
+            throw new BrowserError('no usable browser provider is registered', 'BROWSER_PROVIDER_UNAVAILABLE');
+        }
+        if (usable.length > 1) {
+            const ids = usable.map(provider => provider.id).join(', ');
+            throw new BrowserError(`multiple usable browser providers are registered (${ids}); configure one explicitly`, 'BROWSER_PROVIDER_AMBIGUOUS');
+        }
+        return single;
+    }
+    /** Open a new browser session through the selected provider. */
+    async open(options) {
+        return this.resolveProvider().open(options);
+    }
+    /** Open a URL through the selected provider, optionally in a new tab. */
+    async openUrl(session, request, signal) {
+        return this.resolveProvider().openUrl(session, request, signal);
+    }
+    /** List the session's tabs through the selected provider. */
+    async listTabs(session) {
+        return this.resolveProvider().listTabs(session);
+    }
+    /** Switch to a tab through the selected provider. */
+    async switchTab(session, tabId) {
+        return this.resolveProvider().switchTab(session, tabId);
+    }
+    /** Close one tab through the selected provider. */
+    async closeTab(session, tabId) {
+        return this.resolveProvider().closeTab(session, tabId);
+    }
+    /** Close every tab and reset the session through the selected provider. */
+    async reset(session) {
+        return this.resolveProvider().reset(session);
+    }
+    /** Navigate the session's page through the selected provider. */
+    async navigate(session, request, signal) {
+        return this.resolveProvider().navigate(session, request, signal);
+    }
+    /** Navigate to the previous history entry through the selected provider. */
+    async back(session, signal) {
+        return this.resolveProvider().back(session, signal);
+    }
+    /** Navigate to the next history entry through the selected provider. */
+    async forward(session, signal) {
+        return this.resolveProvider().forward(session, signal);
+    }
+    /** Reload the active page through the selected provider. */
+    async reload(session, signal) {
+        return this.resolveProvider().reload(session, signal);
+    }
+    /** Stop loading the active page through the selected provider. */
+    async stopLoading(session, signal) {
+        return this.resolveProvider().stopLoading(session, signal);
+    }
+    /** Execute JS in the session's page context through the selected provider. */
+    async execute(session, request, signal) {
+        return this.resolveProvider().execute(session, request, signal);
+    }
+    /** Produce an AI-friendly snapshot of the session's page. */
+    async snapshot(session, options = {}, signal) {
+        return this.resolveProvider().snapshot(session, options, signal);
+    }
+    /** Apply device/viewport/media emulation to the session's active tab. */
+    async emulate(session, options = {}) {
+        return this.resolveProvider().emulate(session, options);
+    }
+    /** Console messages the host captured for the session's active tab. */
+    async consoleMessages(session, options = {}) {
+        return this.resolveProvider().consoleMessages(session, options);
+    }
+    /** Network requests the host captured for the session's active tab. */
+    async networkRequests(session, options = {}) {
+        return this.resolveProvider().networkRequests(session, options);
+    }
+    /** Set how the host answers the next JS dialog, and report the state. */
+    async setDialogPolicy(session, policy) {
+        return this.resolveProvider().setDialogPolicy(session, policy);
+    }
+    /** Drain any pending dialog, then report the last one and the current policy. */
+    async inspectDialog(session) {
+        return this.resolveProvider().inspectDialog(session);
+    }
+    /** The last JS dialog the host reported, plus the current policy. */
+    dialogState(session) {
+        return this.resolveProvider().dialogState(session);
+    }
+    /** Click one element referenced by an exact snapshot. */
+    async clickRef(session, request, signal) {
+        return this.resolveProvider().clickRef(session, request, signal);
+    }
+    /** Scroll one element referenced by an exact snapshot into view. */
+    async scrollIntoView(session, request, signal) {
+        return this.resolveProvider().scrollIntoView(session, request, signal);
+    }
+    /** Fetch page content in a requested format. */
+    async content(session, request, signal) {
+        return this.resolveProvider().content(session, request, signal);
+    }
+    /** Click at viewport coordinates through the selected provider. */
+    async click(session, request, signal) {
+        return this.resolveProvider().click(session, request, signal);
+    }
+    /** Double-click at viewport coordinates through the selected provider. */
+    async doubleClick(session, request, signal) {
+        return this.resolveProvider().doubleClick(session, request, signal);
+    }
+    /** Press on one target, move to another, release, through the selected provider. */
+    async drag(session, request, signal) {
+        return this.resolveProvider().drag(session, request, signal);
+    }
+    async hover(session, request, signal) {
+        return this.resolveProvider().hover(session, request, signal);
+    }
+    /** Scroll the active page through the selected provider. */
+    async scroll(session, request, signal) {
+        return this.resolveProvider().scroll(session, request, signal);
+    }
+    /** Attach a local file to a file input through the selected provider. */
+    async uploadFile(session, request, signal) {
+        return this.resolveProvider().uploadFile(session, request, signal);
+    }
+    /** Wait for an element through the selected provider (bounded polling). */
+    async waitForElement(session, request, signal) {
+        return this.resolveProvider().waitForElement(session, request, signal);
+    }
+    /** Type into the focused element through the selected provider. */
+    async type(session, request, signal) {
+        return this.resolveProvider().type(session, request, signal);
+    }
+    /** Press a key into the session's page through the selected provider. */
+    async pressKey(session, request, signal) {
+        return this.resolveProvider().pressKey(session, request, signal);
+    }
+    /** Fill a form's fields in one batch through the selected provider. */
+    async fillForm(session, request, signal) {
+        return this.resolveProvider().fillForm(session, request, signal);
+    }
+    /** Capture the current page through the selected provider. */
+    async screenshot(session, request, signal) {
+        return this.resolveProvider().screenshot(session, request, signal);
+    }
+    /** Check for a human-verification challenge on the active tab. */
+    async detectChallenge(session, signal) {
+        return this.resolveProvider().detectChallenge(session, signal);
+    }
+    /** Return the session's chronological operation log through the provider. */
+    async history(session) {
+        return this.resolveProvider().history(session);
+    }
+    /** Replay one recorded operation by sequence number through the provider. */
+    async replay(session, seq) {
+        return this.resolveProvider().replay(session, seq);
+    }
+    /** Download a URL to a local file through the provider. */
+    async download(session, request, signal) {
+        return this.resolveProvider().download(session, request, signal);
+    }
+    /** Export the session's cookies through the provider. */
+    async flushAuth(session) {
+        return this.resolveProvider().flushAuth(session);
+    }
+    /** Import cookies into the session through the provider. */
+    async restoreAuth(session, cookies) {
+        return this.resolveProvider().restoreAuth(session, cookies);
+    }
+    /** Import cookies from a JSON export on disk through the provider. */
+    async importAuth(session, path) {
+        return this.resolveProvider().importAuth(session, path);
+    }
+    /** Start a background scrape batch through the provider. */
+    async startScrape(session, request) {
+        return this.resolveProvider().startScrape(session, request);
+    }
+    /** Progress of one scrape batch through the provider. */
+    async scrapeStatus(id) {
+        return this.resolveProvider().scrapeStatus(id);
+    }
+    /** Ask a running scrape batch to stop through the provider. */
+    async stopScrape(id) {
+        return this.resolveProvider().stopScrape(id);
+    }
+    /** Every scrape batch the provider knows about. */
+    async listScrapes() {
+        return this.resolveProvider().listScrapes();
+    }
+    /** Remove cookies for one site scope through the provider. */
+    async clearAuth(session, request) {
+        return this.resolveProvider().clearAuth(session, request);
+    }
+    /** Set the session's browser task label through the selected provider. */
+    async setSpace(session, label) {
+        return this.resolveProvider().setSpace(session, label);
+    }
+    /** List browser tasks (legacy spaces) with labels through the selected provider. */
+    async listSpaces() {
+        return this.resolveProvider().listSpaces();
+    }
+    /** List browser tasks with live collaboration status through the provider. */
+    async listTasks() {
+        return this.resolveProvider().listTasks();
+    }
+    /** Read one session's task collaboration state through the provider. */
+    async getTask(session) {
+        return this.resolveProvider().getTask(session);
+    }
+    /** Update one session's visible task state through the provider. */
+    async updateTask(session, update) {
+        return this.resolveProvider().updateTask(session, update);
+    }
+    /** Mark one session as waiting for the user or returned to Agent control. */
+    async setHandoff(session, state) {
+        return this.resolveProvider().setHandoff(session, state);
+    }
+    /** Close the session through the selected provider. Idempotent; a missing
+     *  provider is treated as already-closed so teardown paths stay no-ops. */
+    async close(session) {
+        try {
+            await this.resolveProvider().close(session);
+        }
+        catch (error) {
+            const code = error instanceof BrowserError ? error.code : undefined;
+            if (code === 'BROWSER_PROVIDER_UNAVAILABLE'
+                || code === 'BROWSER_PROVIDER_CONFIGURED_MISSING'
+                || code === 'BROWSER_PROVIDER_CONFIGURED_UNAVAILABLE'
+                || code === 'BROWSER_PROVIDER_AMBIGUOUS') {
+                return; // provider gone; nothing to close
+            }
+            throw error;
+        }
+    }
+}
+export default BrowserRuntime;