dsh-builtin-browser 0.1.8 → 0.1.9

package/lib/browser/runtime.d.ts

@@ -94,7 +94,8 @@ export declare class BrowserRuntime extends Service {
     flushAuth(session: BrowserSessionId): Promise<readonly ExportedCookie[]>;
     /** Import cookies into the session through the provider. */
     restoreAuth(session: BrowserSessionId, cookies: readonly ExportedCookie[]): Promise<number>;
-    /** Close the session through the selected provider. Idempotent. */
+    /** 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

@@ -158,9 +158,22 @@ export class BrowserRuntime extends Service {
     async restoreAuth(session, cookies) {
         return this.resolveProvider().restoreAuth(session, cookies);
     }
-    /** Close the session through the selected provider. Idempotent. */
+    /** 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) {
-        return this.resolveProvider().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;

package/lib/browser/types.d.ts

@@ -294,7 +294,8 @@ export interface BrowserProvider {
 export interface BrowserHistoryEntry {
     /** Monotonic sequence number within the session. */
     readonly seq: number;
-    /** The operation name: navigate | execute | click | type | replay. */
+    /** The operation name. Replayable: navigate | execute | click | type.
+     *  Also recorded (non-replayable): fill | download | flushAuth | restoreAuth. */
     readonly action: string;
     /** The operation's arguments. */
     readonly params: Record<string, unknown>;

package/lib/browser-electron/entry.js

@@ -28,10 +28,15 @@ export function apply(ctx, config) {
     // External host (desktop shell) wins; otherwise self-host. The self-hosted
     // child is disposed with the fiber, mirroring the shell's lifetime.
     const host = config.viewHost ?? new RemoteElectronViewHost(defaultHostMainPath());
+    // Own the disposer on THIS plugin's fiber: registerBrowserProvider's effect
+    // is bound to the seam's own fiber (the browser row), so a reload of this
+    // row would otherwise collide with the still-registered provider
+    // (BROWSER_DUPLICATE_PROVIDER) or leave a stale provider behind.
+    const unregister = ctx.browser.registerBrowserProvider(new ElectronBrowserProvider(host, { httpOnly: config.httpOnly }));
     ctx.effect(() => () => {
+        unregister();
         if (config.viewHost === undefined && host instanceof RemoteElectronViewHost) {
             host.dispose();
         }
     });
-    ctx.browser.registerBrowserProvider(new ElectronBrowserProvider(host, { httpOnly: config.httpOnly }));
 }

package/lib/browser-electron/host-main.js

@@ -48,11 +48,14 @@ async function handle(op, msg) {
                     window.on('closed', () => { window = undefined; });
                 }
                 const view = new WebContentsView();
+                // New views start hidden: with several sessions/tabs only the shown
+                // one may be visible (they stack in contentView child order).
                 view.setVisible(false);
                 window.contentView.addChildView(view);
                 const [width, height] = window.getContentSize();
                 view.setBounds({ x: 0, y: 0, width: width ?? 0, height: height ?? 0 });
-                view.setVisible(true);
+                if (views.size === 0)
+                    view.setVisible(true);
                 view.webContents.debugger.attach(CDP_VERSION);
                 views.set(viewId, { webContentsView: view });
                 reply(msg.id, { ok: true });
@@ -80,8 +83,23 @@ async function handle(op, msg) {
                 if (viewId === undefined)
                     throw new Error('showView missing viewId');
                 const entry = views.get(viewId);
-                if (entry !== undefined)
+                if (entry !== undefined) {
+                    // Hide every other view, then show and RAISE the target so the
+                    // human actually sees the active tab/session (topmost child wins).
+                    for (const v of views.values()) {
+                        if (v === entry)
+                            continue;
+                        try {
+                            v.webContentsView.setVisible(false);
+                        }
+                        catch { /* destroyed */ }
+                    }
                     entry.webContentsView.setVisible(true);
+                    if (window !== undefined) {
+                        window.contentView.removeChildView(entry.webContentsView);
+                        window.contentView.addChildView(entry.webContentsView);
+                    }
+                }
                 reply(msg.id, { ok: true });
                 return;
             }
@@ -228,6 +246,12 @@ void app.whenReady().then(() => {
     socket.on('error', error => {
         process.stderr.write(`[dsh-browser host] socket error: ${String(error)}\n`);
     });
+    // The parent owns our lifetime: when it closes the socket (dispose) or dies
+    // without cleanup, exit so no zombie Electron window is left behind.
+    socket.on('close', () => {
+        process.stderr.write('[dsh-browser host] parent connection closed, exiting\n');
+        app.exit(0);
+    });
     // Keep the process alive until the parent closes the socket or kills us.
 });
 // Diagnostics go to stderr, which the parent never parses as protocol.

package/lib/browser-electron/provider.js

@@ -21,11 +21,11 @@ const CHALLENGE_DETECT_EXPRESSION = `(() => {
   const lower = (title + '\\n' + bodyText).toLowerCase()
   const frameSrcs = [...document.querySelectorAll('iframe')].map(f => f.src || '').join(' ')
   const framesLower = frameSrcs.toLowerCase()
-  const hasCfInterstitial = /just a moment|checking your browser|attention required|cf_chl|challenge-platform/i.test(lower)
+  const hasCfInterstitial = /just a moment|checking your browser|attention required|cf_chl/i.test(lower)
     || !!document.querySelector('#challenge-running, #challenge-stage, #cf-chl-container')
   const hasHCaptcha = !!window.hcaptcha || !!document.querySelector('.h-captcha') || /hcaptcha\\.com/i.test(framesLower)
   const hasRecaptcha = !!window.grecaptcha || !!document.querySelector('.g-recaptcha') || /recaptcha\\/api|google\\.com\\/recaptcha/i.test(framesLower)
-  const hasTurnstile = !!window.turnstile || /challenges\\.cloudflare\\.com/i.test(framesLower) || /turnstile/i.test(lower)
+  const hasTurnstile = !!window.turnstile || /challenges\\.cloudflare\\.com/i.test(framesLower) || /turnstile|challenge-platform/i.test(lower)
   const verifyWording = /verify you are human|verify you are not a robot|\\u4eba\\u673a\\u9a8c\\u8bc1|\\u5b89\\u5168\\u9a8c\\u8bc1|enable javascript and cookies|\\u8bf7.*\\u9a8c\\u8bc1/i.test(lower)
   if (hasCfInterstitial) return { blocked: true, kind: 'cloudflare', reason: 'Cloudflare "Just a moment" interstitial' }
   if (hasHCaptcha) return { blocked: true, kind: 'hcaptcha', reason: 'hCaptcha verification' }
@@ -80,7 +80,7 @@ export class ElectronBrowserProvider {
     open() {
         const handle = this.host.createView();
         const id = `browser:${randomUUID()}`;
-        this.sessions.set(id, { id, tabs: [{ id: `tab:${randomUUID()}`, handle }], activeIndex: 0, history: [] });
+        this.sessions.set(id, { id, tabs: [{ id: `tab:${randomUUID()}`, handle }], activeIndex: 0, history: [], nextSeq: 1 });
         return Promise.resolve(id);
     }
     /** Open a URL in the active tab (default) or a new tab. */
@@ -175,15 +175,19 @@ export class ElectronBrowserProvider {
                 }
             }
             signal?.throwIfAborted();
-            const result = await handle.sendCommand(CDP_PAGE_NAVIGATE, { url });
+            // Page.navigate can hang on an unreachable/slow host; bound it like the
+            // evaluate paths so a wedged navigation surfaces as an error instead of
+            // blocking the tool call forever.
+            const timeoutMs = 30_000;
+            const result = await withTimeout(handle.sendCommand(CDP_PAGE_NAVIGATE, { url }), timeoutMs, signal, `browser: navigation timed out after ${timeoutMs}ms`);
             // Page.navigate resolves even when the navigation fails; surface the
             // failure instead of leaving a silent white screen.
             const errorText = result.errorText;
             if (typeof errorText === 'string' && errorText !== '') {
-                this.record(s, 'navigate', { url }, false, { error: errorText });
                 throw new BrowserError(`browser: navigation to "${url}" failed: ${errorText}`, 'BROWSER_NAVIGATION_FAILED');
             }
             this.record(s, 'navigate', { url }, true);
+            this.showActive(s);
         }
         catch (error) {
             if (!(error instanceof BrowserError && error.code === 'BROWSER_NAVIGATION_BLOCKED')) {
@@ -230,10 +234,16 @@ export class ElectronBrowserProvider {
                 return { ok: false, exception };
             }
             const value = result.result?.value ?? null;
-            this.record(s, 'execute', { script: request.script }, true, { result: typeof value === 'string' ? value.slice(0, 500) : JSON.stringify(value).slice(0, 500) });
+            this.record(s, 'execute', {
+                script: request.script,
+                ...request.args !== undefined && request.args.length > 0 ? { args: request.args } : {},
+            }, true, { result: typeof value === 'string' ? value.slice(0, 500) : JSON.stringify(value).slice(0, 500) });
             return { ok: true, value };
         }
         catch (error) {
+            if (error instanceof Error && error.name === 'TimeoutError') {
+                throw new BrowserError(`browser: execute timed out after ${request.timeoutMs ?? 30_000}ms`, 'BROWSER_EXECUTE_TIMEOUT', { cause: error });
+            }
             throw new BrowserError(`browser: execute failed: ${String(error)}`, 'BROWSER_EXECUTE_FAILED', { cause: error });
         }
     }
@@ -333,13 +343,10 @@ export class ElectronBrowserProvider {
       return { ok: true, content: content.slice(0, ${String(maxChars)}), truncated }
     })()`;
         // Honor a per-call timeout: content evaluation can hang on a heavy page,
-        // so a caller-supplied budget bounds it. AbortSignal.any merges the
-        // caller's signal with a timeout.
+        // so a caller-supplied budget bounds it. Unlike a bare signal entry check,
+        // withTimeout also interrupts a call already in flight.
         const timeoutMs = request.timeoutMs ?? 30_000;
-        const timeoutSignal = AbortSignal.timeout(timeoutMs);
-        const result = signal !== undefined
-            ? await handleSendEvaluate(tab.handle, script, AbortSignal.any([signal, timeoutSignal]))
-            : await handleSendEvaluate(tab.handle, script, timeoutSignal);
+        const result = await withTimeout(handleSendEvaluate(tab.handle, script), timeoutMs, signal, `browser: content timed out after ${timeoutMs}ms`);
         if (!result.ok)
             throw new BrowserError(`browser: content evaluation failed: ${result.exception}`, 'BROWSER_CONTENT_FAILED');
         const value = result.value;
@@ -362,7 +369,9 @@ export class ElectronBrowserProvider {
         const { handle } = this.activeTab(s);
         signal?.throwIfAborted();
         await handle.sendCommand('Input.insertText', { text: request.text });
-        this.record(s, 'type', { text: request.text.slice(0, 200) }, true);
+        // Store the full text so replay re-issues the same input; the history
+        // tool truncates long values when rendering.
+        this.record(s, 'type', { text: request.text }, true);
     }
     /**
      * Fill a form's fields in one batch. Runs one page-context script that
@@ -421,7 +430,15 @@ export class ElectronBrowserProvider {
         return vis.length > 0 ? vis : all
       }
       for (const spec of specs) {
-        const els = candidates(spec)
+        let els
+        try {
+          els = candidates(spec)
+        } catch (e) {
+          // A malformed selector must not abort the whole batch; report the
+          // field as failed and continue with the rest.
+          out.push({ ok: false, error: String(e), target: describe(spec) })
+          continue
+        }
         if (els.length === 0) { out.push({ ok: false, error: 'field not found', target: describe(spec) }); continue }
         const el = els[0]
         const tag = el.tagName
@@ -481,7 +498,9 @@ export class ElectronBrowserProvider {
       let submitted = false
       if (${submitFlag}) {
         let last = null
-        for (const spec of specs) { const els = candidates(spec); if (els.length > 0) { last = els[0]; break } }
+        for (const spec of specs) {
+          try { const els = candidates(spec); if (els.length > 0) { last = els[0]; break } } catch { /* skip */ }
+        }
         const form = last && (last.form || last.closest('form'))
         if (form) { form.requestSubmit(); submitted = true }
       }
@@ -553,7 +572,10 @@ export class ElectronBrowserProvider {
             // a clip this yields the full-page image (CDP default is the viewport).
             params.captureBeyondViewport = true;
         }
-        const result = await handle.sendCommand(CDP_PAGE_CAPTURE_SCREENSHOT, params);
+        // Bound the capture: a view that has not painted can wedge
+        // Page.captureScreenshot indefinitely (observed after view re-showing).
+        const timeoutMs = 30_000;
+        const result = await withTimeout(handle.sendCommand(CDP_PAGE_CAPTURE_SCREENSHOT, params), timeoutMs, signal, `browser: screenshot timed out after ${timeoutMs}ms`);
         const data = result.data;
         if (typeof data !== 'string') {
             throw new BrowserError('browser: screenshot returned no image data', 'BROWSER_SCREENSHOT_FAILED');
@@ -576,7 +598,7 @@ export class ElectronBrowserProvider {
     /** Append one operation to the session's history. */
     record(s, action, params, ok, detail) {
         const entry = {
-            seq: s.history.length + 1,
+            seq: s.nextSeq++,
             action,
             params,
             ok,
@@ -636,8 +658,10 @@ export class ElectronBrowserProvider {
                 const script = entry.params.script;
                 if (typeof script !== 'string')
                     throw new BrowserError(`browser: history seq ${seq} execute has no script`, 'BROWSER_HISTORY_INVALID');
-                const result = await this.execute(session, { script });
-                this.record(s, 'replay', { seq, of: entry.action, script }, result.ok, result.ok ? { result: String(result.value) } : { error: result.exception });
+                const recordedArgs = entry.params.args;
+                const args = Array.isArray(recordedArgs) ? recordedArgs.filter((a) => typeof a === 'string') : undefined;
+                const result = await this.execute(session, { script, ...args !== undefined && args.length > 0 ? { args } : {} });
+                this.record(s, 'replay', { seq, of: entry.action, script, ...args !== undefined && args.length > 0 ? { args } : {} }, result.ok, result.ok ? { result: String(result.value) } : { error: result.exception });
                 return;
             }
             default:
@@ -703,7 +727,13 @@ function withTimeout(promise, ms, signal, message) {
             if (done)
                 return;
             done = true;
-            reject(new Error(message));
+            // A fired timeout must also release the abort listener; { once: true }
+            // only releases it on the next abort, which may never come.
+            if (signal !== undefined)
+                signal.removeEventListener('abort', onAbort);
+            const error = new Error(message);
+            error.name = 'TimeoutError';
+            reject(error);
         }, ms);
         const finish = (fn) => {
             if (done)

package/lib/browser-electron/remote-host.d.ts

@@ -2,9 +2,9 @@
  * Self-hosted Electron browser host (parent side): an
  * {@link ElectronBrowserViewHost} implementation that spawns the plugin's own
  * Electron child process (host-main.js) and drives it over line-delimited
- * JSON-RPC on stdio. This is what makes the plugin work on surfaces without a
- * desktop shell's electronViewHost (plain dsh web): installing the plugin is
- * enough — the browser window appears on first use.
+ * JSON-RPC on a loopback TCP socket. This is what makes the plugin work on
+ * surfaces without a desktop shell's electronViewHost (plain dsh web):
+ * installing the plugin is enough — the browser window appears on first use.
  *
  * Protocol (one JSON object per line, both directions):
  *   -> { id, op: 'createView' } | { id, op: 'destroyView', viewId } |
@@ -28,10 +28,13 @@ export declare class RemoteElectronViewHost implements ElectronBrowserViewHost {
     private pendingSocket;
     private readonly views;
     private readyPromise;
+    private disposed;
     constructor(hostMainPath: string);
-    /** Ensure the child is up and ready (lazy on first use). */
+    /** Ensure the child is up and ready (lazy on first use; restarts after a crash). */
     private ready;
     private start;
+    /** The child died: tear down so the next use starts a fresh child. */
+    private onChildExit;
     createView(): ElectronViewHandle;
     private ensureView;
     showView(handle: ElectronViewHandle): void;

package/lib/browser-electron/remote-host.js

@@ -2,9 +2,9 @@
  * Self-hosted Electron browser host (parent side): an
  * {@link ElectronBrowserViewHost} implementation that spawns the plugin's own
  * Electron child process (host-main.js) and drives it over line-delimited
- * JSON-RPC on stdio. This is what makes the plugin work on surfaces without a
- * desktop shell's electronViewHost (plain dsh web): installing the plugin is
- * enough — the browser window appears on first use.
+ * JSON-RPC on a loopback TCP socket. This is what makes the plugin work on
+ * surfaces without a desktop shell's electronViewHost (plain dsh web):
+ * installing the plugin is enough — the browser window appears on first use.
  *
  * Protocol (one JSON object per line, both directions):
  *   -> { id, op: 'createView' } | { id, op: 'destroyView', viewId } |
@@ -147,6 +147,7 @@ function findElectronExe(store) {
 class ElectronChildClient {
     hostMainPath;
     port;
+    onExit;
     child;
     pending = new Map();
     nextId = 1;
@@ -154,9 +155,12 @@ class ElectronChildClient {
     socket;
     connected = false;
     outbox = [];
-    constructor(hostMainPath, port) {
+    /** Set once the child has exited; further calls fail fast instead of queueing. */
+    dead = false;
+    constructor(hostMainPath, port, onExit) {
         this.hostMainPath = hostMainPath;
         this.port = port;
+        this.onExit = onExit;
         const electron = resolveElectronPath();
         // ELECTRON_RUN_AS_NODE (even an empty string) makes Electron run as plain
         // Node, breaking require('electron'); NODE_OPTIONS can inject flags that
@@ -174,25 +178,45 @@ class ElectronChildClient {
             // Diagnostics only; never parse stderr as protocol.
             process.stderr.write(`[dsh-browser host] ${String(chunk)}`);
         });
+        // A failed spawn (bad/corrupt binary) emits 'error' — without a listener
+        // that would crash the whole DSH process.
+        this.child.on('error', error => {
+            process.stderr.write(`[dsh-browser host] spawn error: ${String(error)}\n`);
+            this.fail(new Error(`dsh-builtin-browser: browser host failed to start: ${String(error)}`));
+        });
         this.child.on('exit', (code, signal) => {
-            const err = new Error(`dsh-builtin-browser: browser host exited (code=${String(code)} signal=${String(signal)})`);
-            for (const pending of this.pending.values())
-                pending.reject(err);
-            this.pending.clear();
+            this.fail(new Error(`dsh-builtin-browser: browser host exited (code=${String(code)} signal=${String(signal)})`));
         });
     }
+    /** Reject everything in flight, mark the client dead, and notify the host. */
+    fail(err) {
+        if (this.dead)
+            return;
+        this.dead = true;
+        this.connected = false;
+        for (const pending of this.pending.values())
+            pending.reject(err);
+        this.pending.clear();
+        this.outbox = [];
+        this.onExit?.();
+    }
     /** Accept the child's connection (called by the server). */
     attach(socket) {
         this.socket = socket;
         this.connected = true;
         socket.setEncoding('utf8');
+        // Without an 'error' listener a remote reset (ECONNRESET/EPIPE) throws an
+        // uncaught 'error' event and crashes the whole DSH process; 'close' below
+        // does the cleanup.
+        socket.on('error', error => {
+            process.stderr.write(`[dsh-browser host] socket error: ${String(error)}\n`);
+        });
         socket.on('data', chunk => this.onData(chunk));
         socket.on('close', () => {
             this.connected = false;
-            const err = new Error('dsh-builtin-browser: browser host connection closed');
-            for (const pending of this.pending.values())
-                pending.reject(err);
-            this.pending.clear();
+            if (!this.dead) {
+                this.fail(new Error('dsh-builtin-browser: browser host connection closed'));
+            }
         });
         // Flush anything queued while disconnected.
         if (this.outbox.length > 0) {
@@ -231,6 +255,9 @@ class ElectronChildClient {
     }
     /** Send one command and await the reply. */
     call(op, payload = {}) {
+        if (this.dead) {
+            return Promise.reject(new Error('dsh-builtin-browser: browser host is not running'));
+        }
         const id = this.nextId++;
         const line = JSON.stringify({ id, op, ...payload });
         return new Promise((resolve, reject) => {
@@ -294,10 +321,11 @@ export class RemoteElectronViewHost {
     pendingSocket;
     views = new Map();
     readyPromise;
+    disposed = false;
     constructor(hostMainPath) {
         this.hostMainPath = hostMainPath;
     }
-    /** Ensure the child is up and ready (lazy on first use). */
+    /** Ensure the child is up and ready (lazy on first use; restarts after a crash). */
     ready() {
         if (this.readyPromise !== undefined)
             return this.readyPromise;
@@ -316,10 +344,15 @@ export class RemoteElectronViewHost {
             server.once('error', reject);
             server.listen(0, '127.0.0.1', () => resolve());
         });
+        // A later server error (rare on a loopback ephemeral port) must not crash
+        // the process; the client's fail path handles the actual recovery.
+        server.on('error', error => {
+            process.stderr.write(`[dsh-browser host] rpc server error: ${String(error)}\n`);
+        });
         const address = server.address();
         const port = typeof address === 'object' && address !== null ? address.port : 0;
         this.server = server;
-        this.client = new ElectronChildClient(this.hostMainPath, port);
+        this.client = new ElectronChildClient(this.hostMainPath, port, () => this.onChildExit());
         if (this.pendingSocket !== undefined) {
             this.client.attach(this.pendingSocket);
             this.pendingSocket = undefined;
@@ -327,6 +360,18 @@ export class RemoteElectronViewHost {
         // Wait for the child's connection + readiness ping.
         await withTimeout(this.client.call('ping'), READY_TIMEOUT_MS, 'browser host did not become ready');
     }
+    /** The child died: tear down so the next use starts a fresh child. */
+    onChildExit() {
+        if (this.disposed)
+            return;
+        this.client = undefined;
+        this.server?.close();
+        this.server = undefined;
+        this.pendingSocket = undefined;
+        this.readyPromise = undefined;
+        // Keep the views map: handles still resolve to ids; a fresh child simply
+        // has no such views yet, and reset_session reopens clean sessions.
+    }
     createView() {
         // The seam is synchronous; the provider uses the handle immediately, so
         // commands are deferred until the child is up and the view materialized.
@@ -346,7 +391,11 @@ export class RemoteElectronViewHost {
         return view;
     }
     showView(handle) {
-        void this.ready().then(() => this.client?.call('showView', { viewId: handle.id }));
+        // Fire-and-forget by design (visibility is best-effort), but a rejected
+        // promise must not become an unhandled rejection (crash on Node >= 15).
+        void this.ready()
+            .then(() => this.client?.call('showView', { viewId: handle.id }))
+            .catch(() => { });
     }
     destroyView(handle) {
         const view = this.views.get(handle.id);
@@ -359,6 +408,7 @@ export class RemoteElectronViewHost {
     }
     /** Shut the child and the RPC server down. */
     dispose() {
+        this.disposed = true;
         this.client?.kill();
         this.client = undefined;
         this.server?.close();

package/lib/index.d.ts

@@ -1,15 +1,16 @@
 /**
- * dsh-browser plugin entry: aggregates the shared-browser capability pieces.
- * The cordis.patch.yml rows reference subpath exports:
- *   - `dsh-browser/browser`            -> the ctx.browser seam (Service Definition)
- *   - `dsh-browser/browser-electron`   -> the Electron CDP provider
- *   - `dsh-browser/tool-browser`       -> the model-facing browser_* tools
+ * dsh-builtin-browser plugin entry: aggregates the shared-browser capability
+ * pieces. The cordis.patch.yml rows reference subpath exports:
+ *   - `dsh-builtin-browser/browser`          -> the ctx.browser seam (Service)
+ *   - `dsh-builtin-browser/browser-electron` -> the Electron CDP provider
+ *   - `dsh-builtin-browser/tool-browser`     -> the model-facing browser_* tools
  * This root entry only re-exports for programmatic use; the loader rows are
  * the composition surface.
- * @module dsh-browser
+ * @module dsh-builtin-browser
  */
 export { BrowserError } from './browser/types.ts';
-export type { BrowserClickRequest, BrowserContentFormat, BrowserContentRequest, BrowserContentResult, BrowserExecuteRequest, BrowserExecuteResult, BrowserNavigateRequest, BrowserOpenRequest, BrowserProvider, BrowserScreenshotRequest, BrowserScreenshotResult, BrowserSessionId, BrowserSnapshotElement, BrowserSnapshotResult, BrowserTab, BrowserTypeRequest, } from './browser/types.ts';
+export type { BrowserChallenge, BrowserClickRequest, BrowserContentFormat, BrowserContentRequest, BrowserContentResult, BrowserExecuteRequest, BrowserExecuteResult, BrowserFillField, BrowserFillRequest, BrowserFillResult, BrowserNavigateRequest, BrowserOpenRequest, BrowserProvider, BrowserScreenshotRequest, BrowserScreenshotResult, BrowserSessionId, BrowserSnapshotElement, BrowserSnapshotResult, BrowserTab, BrowserTypeRequest, ExportedCookie, } from './browser/types.ts';
 export { BrowserRuntime } from './browser/runtime.ts';
 export { ElectronBrowserProvider } from './browser-electron/provider.ts';
 export type { ElectronBrowserViewHost, ElectronViewHandle } from './browser-electron/provider.ts';
+export { RemoteElectronViewHost, defaultHostMainPath } from './browser-electron/remote-host.ts';

package/lib/index.js

@@ -1,13 +1,14 @@
 /**
- * dsh-browser plugin entry: aggregates the shared-browser capability pieces.
- * The cordis.patch.yml rows reference subpath exports:
- *   - `dsh-browser/browser`            -> the ctx.browser seam (Service Definition)
- *   - `dsh-browser/browser-electron`   -> the Electron CDP provider
- *   - `dsh-browser/tool-browser`       -> the model-facing browser_* tools
+ * dsh-builtin-browser plugin entry: aggregates the shared-browser capability
+ * pieces. The cordis.patch.yml rows reference subpath exports:
+ *   - `dsh-builtin-browser/browser`          -> the ctx.browser seam (Service)
+ *   - `dsh-builtin-browser/browser-electron` -> the Electron CDP provider
+ *   - `dsh-builtin-browser/tool-browser`     -> the model-facing browser_* tools
  * This root entry only re-exports for programmatic use; the loader rows are
  * the composition surface.
- * @module dsh-browser
+ * @module dsh-builtin-browser
  */
 export { BrowserError } from "./browser/types.js";
 export { BrowserRuntime } from "./browser/runtime.js";
 export { ElectronBrowserProvider } from "./browser-electron/provider.js";
+export { RemoteElectronViewHost, defaultHostMainPath } from "./browser-electron/remote-host.js";

package/lib/tool-browser/index.d.ts

@@ -32,7 +32,7 @@ export interface Config {
 export declare function apply(ctx: Context, config?: Config): void;
 /** Test hook: inspect and reset the plugin-level session map (used by tests). */
 export declare const internals: {
-    /** The per-task session map (task key -> provider session id). */
+    /** A copy of the per-task session map (task key -> provider session id). */
     readonly sessions: ReadonlyMap<string, BrowserSessionId>;
     /** Drop one task's mapping without closing the provider session. */
     clearSession(key?: string): void;