@mind-harness/mh-browser 0.2.5 → 0.2.7

package/lib/types/call.d.ts

@@ -0,0 +1,23 @@
+/** One Host call from this package's client. Same shape the UI already reads. */
+export type CallResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+};
+export interface CallInit {
+    method: 'GET' | 'POST';
+    body?: unknown;
+    query?: Record<string, string>;
+}
+/**
+ * `document.baseURI` keeps a mounted page on its prefix. dsh's file upload
+ * resolves the same way.
+ */
+export declare function call<T>(segment: string, init: CallInit, signal?: AbortSignal): Promise<CallResult<T>>;
+//# sourceMappingURL=call.d.ts.map

package/lib/types/card.d.ts

@@ -15,10 +15,9 @@ export type RevealResult = {
 };
 export interface HandoverRowProps {
     sessionId: string;
-    reason: string;
     t: Translate;
     reveal: (sessionId: string, signal: AbortSignal) => Promise<RevealResult>;
 }
-/** The open handover: the reason and the button that raises its window. */
+/** The open handover: a short line and the button that raises its window. */
 export declare function HandoverRow(props: HandoverRowProps): ReactElement;
 //# sourceMappingURL=card.d.ts.map

package/lib/types/client.d.ts

@@ -2,25 +2,19 @@ import { type ReactElement } from 'react';
 import { type RevealResult } from './card.ts';
 import { type Translate } from './locales.ts';
 import { handoverRowDefinition } from './row.ts';
+import type { SettingsFormScope } from './settings-form.ts';
+import { type LocateFor } from './settings.ts';
 /**
  * Cordis services this client reads. `dsh.client.inject` is package load
- * order, not this list. `remote.mhBrowser` is absent until `$mount`.
+ * order, not this list.
  */
-export declare const inject: readonly ["slots", "locale", "remote", "uiConversation"];
-export interface MhBrowserRemote {
+export declare const inject: readonly ["slots", "locale", "uiConversation", "configForms"];
+export interface MhBrowserApi {
     revealHandover(sessionId: string, signal?: AbortSignal): Promise<RevealResult>;
+    locateFor: LocateFor;
 }
-interface RemoteCarrier {
-    $mount(contribution: object): Promise<() => Promise<void>>;
-}
-/** Props the session-scoped chat-node seat passes in. The session id is that seat's. */
 export interface HostRowProps {
     sessionId: string;
-    node: {
-        readonly data: {
-            readonly reason: string;
-        };
-    };
     t: Translate;
 }
 export interface ClientHost {
@@ -31,23 +25,32 @@ export interface ClientHost {
             key: string;
             locale: string;
         }, component: (props: HostRowProps) => ReactElement): () => void;
+        register(options: {
+            name: string;
+            key: string;
+            locale: string;
+        }, component: (props: {
+            t: Translate;
+            view?: 'summary' | 'page';
+        }) => ReactElement | null): () => void;
     };
     locale: {
         register(ns: string, dicts: Record<'zh' | 'en', Record<string, string>>): () => void;
     };
+    configForms: {
+        get<T>(entryId: string): SettingsFormScope<T>;
+    };
     uiConversation: {
         events: {
             register(definition: typeof handoverRowDefinition): () => void;
         };
     };
     effect(execute: () => () => void): unknown;
-    remote: RemoteCarrier & {
-        mhBrowser: MhBrowserRemote;
-    };
     inject(names: readonly string[], apply: (ctx: ClientHost) => void): PromiseLike<unknown>;
 }
+/** Host calls used by the handover row and the settings lookup. */
+export declare function browserApi(): MhBrowserApi;
 export declare function apply(ctx: ClientHost): Promise<() => Promise<void>>;
 /** Register the handover row. The tool call itself keeps the generic tool row. */
-export declare function start(ctx: ClientHost): () => void;
-export {};
+export declare function start(ctx: ClientHost, api?: MhBrowserApi): () => void;
 //# sourceMappingURL=client.d.ts.map

package/lib/types/config.d.ts

@@ -1,14 +1,27 @@
 import z from '@deepseek-ai/schemastery';
-import type { BrowserName } from './types.ts';
-export interface BrowserConfig {
-    presence: {
-        maxBytes: number;
-    };
-    browser: BrowserName;
-    profileDir?: string;
-    headless: boolean;
-}
-export declare const browserConfig: z<BrowserConfig>;
+export declare const browserConfig: z<Schemastery.ObjectS<NoInfer<{
+    presence: z<Schemastery.ObjectS<NoInfer<{
+        maxBytes: z<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        maxBytes: z<number, number, "defined">;
+    }>>, "defined">;
+    browser: z<"auto" | "chrome" | "msedge" | "chromium", "auto" | "chrome" | "msedge" | "chromium", "volatile-defined">;
+    executablePath: z<string, string, "volatile">;
+    profileDir: z<string, string, "plain">;
+    headless: z<boolean, boolean, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    presence: z<Schemastery.ObjectS<NoInfer<{
+        maxBytes: z<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        maxBytes: z<number, number, "defined">;
+    }>>, "defined">;
+    browser: z<"auto" | "chrome" | "msedge" | "chromium", "auto" | "chrome" | "msedge" | "chromium", "volatile-defined">;
+    executablePath: z<string, string, "volatile">;
+    profileDir: z<string, string, "plain">;
+    headless: z<boolean, boolean, "defined">;
+}>>, "plain">;
+/** What {@link browserConfig} returns. `browser` and `executablePath` are read with `get()`. */
+export type BrowserConfig = ReturnType<typeof browserConfig>;
 /**
  * Browser profile directory when the configuration names none. Each dsh profile gets its own:
  * a browser profile directory admits one running browser, so two dsh profiles sharing one
@@ -17,4 +30,6 @@ export declare const browserConfig: z<BrowserConfig>;
 export declare function defaultProfileDir(profile: {
     name: string;
 } | undefined, home?: string): string;
+/** One subdirectory of the default profile root per browser, so logins do not cross browsers. */
+export declare function profileDirFor(root: string, browser: string): string;
 //# sourceMappingURL=config.d.ts.map

package/lib/types/index.d.ts

@@ -1,11 +1,32 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { BrowserConfig } from './config.ts';
+import { browserConfig } from './config.ts';
 import { MhBrowserService } from './service/service.ts';
 export declare const name = "mh-browser";
 export declare const inject: string[];
 export type Config = BrowserConfig;
-export declare const Config: import("@deepseek-ai/schemastery").default<BrowserConfig>;
-export declare function apply(ctx: Context, config: Config): Promise<void>;
+export declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+    presence: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+        maxBytes: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        maxBytes: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    }>>, "defined">;
+    browser: import("@deepseek-ai/schemastery").default<"auto" | "chrome" | "msedge" | "chromium", "auto" | "chrome" | "msedge" | "chromium", "volatile-defined">;
+    executablePath: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+    profileDir: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    headless: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    presence: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<NoInfer<{
+        maxBytes: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    }>>, Schemastery.ObjectT<NoInfer<{
+        maxBytes: import("@deepseek-ai/schemastery").default<number, number, "defined">;
+    }>>, "defined">;
+    browser: import("@deepseek-ai/schemastery").default<"auto" | "chrome" | "msedge" | "chromium", "auto" | "chrome" | "msedge" | "chromium", "volatile-defined">;
+    executablePath: import("@deepseek-ai/schemastery").default<string, string, "volatile">;
+    profileDir: import("@deepseek-ai/schemastery").default<string, string, "plain">;
+    headless: import("@deepseek-ai/schemastery").default<boolean, boolean, "defined">;
+}>>, "plain">;
+export declare function apply(ctx: Context, config: Config | NonNullable<Parameters<typeof browserConfig>[0]>): Promise<void>;
 export { MhBrowserService };
 export { readAgentView } from './representation/agent-view.ts';
 export type { AgentViewDoc, AgentViewLink, AgentViewRead } from './representation/agent-view.ts';

package/lib/types/locales.d.ts

@@ -1,11 +1,37 @@
 /** Dictionary namespace for the handover row. */
 export declare const NS = "mh-browser";
 export declare const zh: {
-    readonly waiting: "浏览器交给你了：{reason}";
-    readonly reveal: "去浏览器";
+    readonly waiting: "这一步要你在浏览器里做";
+    readonly reveal: "打开浏览器里的页面";
     readonly notHandingOver: "这次交接已经结束";
     readonly noTab: "没有可以去的页面";
     readonly failed: "没能切到浏览器";
+    readonly browserLabel: "浏览器";
+    readonly browserHint: "保存后，浏览器空闲时会关掉再按这个选择打开。已经打开的标签页会关掉。";
+    readonly pathLabel: "浏览器路径";
+    readonly pathHint: "留空就用自动找到的。可以填绝对路径，也可以用 ~。保存后同样在空闲时重启。";
+    readonly pathInvalid: "需要绝对路径，或以 ~ 开头";
+    readonly pathSearching: "正在查找…";
+    readonly pathMissing: "未找到{name}，请填写路径";
+    readonly pathHelp: "说明";
+    readonly pathDoesNotExist: "不存在";
+    readonly pathIsDirectory: "是目录";
+    readonly pathDenied: "没有权限（{code}）";
+    readonly auto: "自动";
+    readonly browserUsing: "当前使用：{name}。";
+    readonly browserNone: "没有找到 Chrome 或 Edge。";
+    readonly installChrome: "安装 Chrome";
+    readonly chrome: "Google Chrome";
+    readonly msedge: "Microsoft Edge";
+    readonly chromium: "Chromium";
+    readonly overridden: "已覆盖";
+    readonly reset: "恢复";
+    readonly save: "保存";
+    readonly saving: "保存中";
+    readonly settingsUnavailable: "这个配置现在不可用";
+    readonly settingsReadOnly: "这次启动的配置不能在页面上改";
+    readonly settingsSaveFailed: "没有保存：设置可能在别处改过，或这个值不被接受。修改还在，检查后可以再保存";
+    readonly discard: "放弃修改";
 };
 export type CardKey = keyof typeof zh;
 export declare const en: Record<CardKey, string>;

package/lib/types/location.d.ts

@@ -0,0 +1,14 @@
+/** Where a browser name resolves when no path is configured. */
+import type { BrowserChoice, BrowserName } from './types.ts';
+export type { BrowserChoice, BrowserName };
+export interface BrowserLocationMiss {
+    path: string;
+    reason: string;
+}
+export type BrowserLocation = {
+    found: string;
+    browser?: BrowserName;
+} | {
+    missing: BrowserLocationMiss[];
+};
+//# sourceMappingURL=location.d.ts.map

package/lib/types/location.js

@@ -0,0 +1,3 @@
+/** Where a browser name resolves when no path is configured. */
+export {};
+//# sourceMappingURL=location.js.map

package/lib/types/routes.d.ts

@@ -0,0 +1,43 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Context } from '@deepseek-ai/cordis';
+import type { BrowserLocation } from './location.ts';
+import { type BrowserChoice } from './types.ts';
+interface ApiRouteHost {
+    webServer: {
+        register(route: {
+            kind: 'prefix';
+            path: string;
+            handler(req: IncomingMessage, res: ServerResponse): Promise<void>;
+        }): () => void;
+    };
+    connection: {
+        admit(request: {
+            headers: IncomingMessage['headers'];
+        }): {
+            readonly peer: unknown;
+        } | {
+            readonly rejection: 401 | 403;
+        };
+    };
+    effect(execute: () => () => void): unknown;
+}
+export interface BrowserRouteHost extends ApiRouteHost {
+    mhBrowser: {
+        locateFor(browser: BrowserChoice, signal?: AbortSignal): Promise<BrowserLocation>;
+        revealHandover(sessionId: string, signal?: AbortSignal): Promise<{
+            status: 'revealed' | 'not-handing-over' | 'no-tab';
+        }>;
+    };
+}
+/**
+ * Routes for the browser client. A composition without `webServer` never
+ * starts this plugin; the browser tools do not depend on it.
+ */
+export declare const browserRoutesPlugin: {
+    name: string;
+    inject: readonly string[];
+    apply(ctx: Context): void;
+};
+export declare function registerBrowserRoutes(ctx: BrowserRouteHost): void;
+export {};
+//# sourceMappingURL=routes.d.ts.map

package/lib/types/row.d.ts

@@ -4,12 +4,10 @@
  * the same key and hides the row; a hidden row is omitted from group order.
  */
 export declare const HANDOVER_KIND = "browser-handover";
-export interface HandoverRowData {
-    readonly reason: string;
-}
+/** The row carries no call payload. The reason stays on the question card. */
+export type HandoverRowData = Record<string, never>;
 interface OpenCall {
     readonly callId: string;
-    readonly reason: string;
     readonly seq: number;
 }
 export interface HandoverTurnState {

package/lib/types/service/browser.d.ts

@@ -1,11 +1,18 @@
 import type { BrowserContext } from 'playwright';
+import type { BrowserLocation } from '../location.ts';
 import type { BrowserName } from '../types.ts';
+import { type LocateEnv } from './locate.ts';
 export interface LaunchOptions {
     browser: BrowserName;
     headless: boolean;
     profileDir: string;
-    /** Test hook: point at a missing executable to exercise the not-found message. */
+    /** Absolute path of the browser to launch. `~` is already expanded. */
     executablePath?: string;
+    /**
+     * Pass `channel`. False when a path was configured without naming a browser:
+     * the path is launched as itself.
+     */
+    channel?: boolean;
 }
 /**
  * Playwright appends `--no-sandbox` unless this is true, and branded Chrome
@@ -15,11 +22,15 @@ export interface LaunchOptions {
  */
 export declare function chromiumSandboxEnabled(browser: BrowserName, platform?: NodeJS.Platform): boolean;
 /**
- * One persistent context for the whole process. `chromium` omits `channel`
- * so Playwright uses its own browser; the others use a local install.
- * A missing browser is reported and not downloaded.
+ * One persistent context for the whole process. An installed browser is located
+ * here and passed as `executablePath`; `channel` names which install that was.
+ * `chromium` omits `channel` so Playwright uses its own browser unless a path
+ * is configured. A missing browser is reported and not downloaded. A launch
+ * that fails after the executable was found is reported as Playwright said.
  */
-export declare function launchBrowser(options: LaunchOptions): Promise<BrowserContext>;
+export declare function launchBrowser(options: LaunchOptions, env?: LocateEnv): Promise<BrowserContext>;
+/** Playwright's own Chromium, or why that file cannot be run. */
+export declare function bundledChromiumLocation(access: LocateEnv['access']): BrowserLocation;
 /**
  * Process id of the browser's main process. Playwright gives none for a
  * persistent context. Asks the browser first; on POSIX the profile's

package/lib/types/service/control.d.ts

@@ -13,6 +13,11 @@ export declare class Control {
     private readonly tabs;
     private readonly since;
     private readonly named;
+    /**
+     * A handover is waiting, or the person holds a tab. The browser is not
+     * restarted out from under either.
+     */
+    busy(): boolean;
     /** Whether the person holds any tab, or a handover is waiting. */
     of(owner: string): 'model' | 'person';
     /** The person holds this tab until they hand it back. */

package/lib/types/service/extension.d.ts

@@ -11,6 +11,7 @@ export declare function extensionDir(): string;
 export declare class Extension {
     private readonly context;
     private readonly id;
+    private readonly browserSession;
     private workerPage;
     private constructor();
     static load(context: BrowserContext, browserSession: CDPSession): Promise<Extension>;
@@ -30,6 +31,12 @@ export declare class Extension {
     private answer;
     private worker;
 }
+/**
+ * The service worker, reloading the extension once when it is gone.
+ * A worker that comes back on its own during the first wait is used as it is.
+ * After a reload that still has no worker, the extension was turned off.
+ */
+export declare function restoreWorker(context: BrowserContext, id: string, reload: () => Promise<void>, signal?: AbortSignal, appearMs?: number): Promise<Worker>;
 /** The extension's service worker. Looks once more after the wait times out. */
 export declare function findWorker(context: BrowserContext, id: string, timeoutMs?: number): Promise<Worker>;
 //# sourceMappingURL=extension.d.ts.map

package/lib/types/service/launch-plan.d.ts

@@ -0,0 +1,30 @@
+import type { BrowserLocation } from '../location.ts';
+import type { BrowserChoice, BrowserName } from '../types.ts';
+import { type LocateEnv } from './locate.ts';
+/** What one launch uses. `channel` is false when the path does not name a browser channel. */
+export interface LaunchPlan {
+    browser: BrowserName;
+    channel: boolean;
+    profileDir: string;
+    executablePath?: string;
+    /** Written after the browser starts. Absent when a path was given without naming a browser. */
+    remember?: BrowserName;
+}
+/**
+ * Which browser, path, and profile directory to launch.
+ * A configured path is checked and never replaced. Automatic selection keeps the
+ * remembered browser while it can be found, then Chrome, then Edge.
+ * Playwright's Chromium is used only when it is selected, or when it is the remembered one.
+ */
+export declare function planLaunch(input: {
+    choice: BrowserChoice;
+    configured: string | undefined;
+    root: string;
+    /** The default profile root gets one subdirectory per browser. A configured directory does not. */
+    split: boolean;
+    env: LocateEnv;
+    remembered: BrowserName | undefined;
+    bundled: BrowserLocation;
+    signal?: AbortSignal;
+}): Promise<LaunchPlan>;
+//# sourceMappingURL=launch-plan.d.ts.map

package/lib/types/service/locate.d.ts

@@ -0,0 +1,81 @@
+import type { BrowserLocation, BrowserLocationMiss } from '../location.ts';
+import type { BrowserName, MissingBrowser } from '../types.ts';
+/** A browser the person installs. Playwright's Chromium is not located this way. */
+export type InstalledBrowser = Exclude<BrowserName, 'chromium'>;
+/** `ok`, or the errno from checking that the file can be executed. */
+export type PathAccess = 'ok' | {
+    code: string;
+};
+/**
+ * Everything location reads from the machine. Tests pass a stand-in, so a
+ * case does not depend on what that machine has installed.
+ */
+export interface LocateEnv {
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    home: string;
+    /** Whether `path` can be executed. */
+    access(path: string): PathAccess;
+    /**
+     * Paths from the platform's own lookup, already resolved. Called only after
+     * every fixed candidate missed. An empty list means the lookup found nothing
+     * or did not run.
+     */
+    discover(browser: InstalledBrowser, signal?: AbortSignal): Promise<string[]>;
+}
+/** The fixed paths checked for `browser` on `env`, in the order they are tried. */
+export declare function candidatePaths(browser: InstalledBrowser, env: LocateEnv): string[];
+/**
+ * `configured` is used as given: a path that cannot be run is a failure, and
+ * nothing else is searched. `~` expands to `env.home`.
+ */
+export declare function checkConfigured(configured: string, env: LocateEnv): {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    path: string;
+    code: string;
+};
+/** Failure for a path the configuration names. */
+export declare function configuredPathError(path: string, code: string): Error;
+/** Chrome and Edge were both missed. The message asks for Chrome only. */
+export declare class BrowserNotFoundError extends Error {
+    readonly notFound: MissingBrowser;
+    constructor(misses: {
+        browser: InstalledBrowser;
+        missing: BrowserLocationMiss[];
+    }[]);
+}
+/**
+ * The installed browser to launch when the choice is automatic.
+ * The remembered browser wins while it can still be found; otherwise Chrome, then Edge.
+ */
+export declare function resolveAuto(env: LocateEnv, remembered: BrowserName | undefined, signal?: AbortSignal): Promise<{
+    browser: InstalledBrowser;
+    path: string;
+}>;
+/** Failure listing every path that was tried. */
+export declare function browserNotFoundError(browser: InstalledBrowser, missing: BrowserLocationMiss[]): Error;
+/**
+ * The path to launch. A configured path is checked and never replaced.
+ * `chromium` without one returns undefined, so Playwright uses its own build.
+ * An installed browser that cannot be found throws.
+ */
+export declare function resolveExecutable(browser: BrowserName, configured: string | undefined, env: LocateEnv, signal?: AbortSignal): Promise<string | undefined>;
+/**
+ * Where `browser` is installed when the configuration names no path.
+ * Fixed candidates first, then `env.discover`.
+ */
+export declare function locateInstalled(browser: InstalledBrowser, env: LocateEnv, signal?: AbortSignal): Promise<BrowserLocation>;
+/** `path` is Playwright's Chromium. Missing or not executable is `missing`. */
+export declare function locateBundled(path: string, access: LocateEnv['access']): BrowserLocation;
+/** This machine: fixed paths, then Spotlight, App Paths, or `PATH`. */
+export declare function hostLocateEnv(): LocateEnv;
+/** A `.app` bundle path reported by Spotlight, turned into its executable. */
+export declare function executableInApp(reported: string, binary: string): string | undefined;
+/** The default value from `reg query ... /ve` output. */
+export declare function regValue(stdout: string): string | undefined;
+/** Text for an errno from {@link LocateEnv.access}. */
+export declare function reasonForCode(code: string): string;
+//# sourceMappingURL=locate.d.ts.map

package/lib/types/service/profile.d.ts

@@ -0,0 +1,11 @@
+import type { BrowserName } from '../types.ts';
+/** The browser recorded after the last successful launch, if the file names one. */
+export declare function readLastBrowser(root: string): Promise<BrowserName | undefined>;
+/** Remember which browser actually launched, so automatic selection keeps using it. */
+export declare function writeLastBrowser(root: string, browser: BrowserName): Promise<void>;
+/**
+ * Move a profile that older versions kept in the root into `browser`'s subdirectory.
+ * A root without Chrome's `Local State`, or one whose subdirectory already exists, stays as it is.
+ */
+export declare function migrateLegacyProfile(root: string, browser: string): Promise<void>;
+//# sourceMappingURL=profile.d.ts.map

package/lib/types/service/service.d.ts

@@ -1,15 +1,19 @@
-import { Context } from '@deepseek-ai/cordis';
-import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { Context, Service } from '@deepseek-ai/cordis';
 import type { BrowserConfig } from '../config.ts';
+import type { BrowserLocation } from '../location.ts';
 import type { HeldPage, PresenceReceipt, PresenceRecord, PresenceSource } from '../presence/record.ts';
 import type { PendingOp } from '../presence/fold.ts';
-import type { Download, FetchResponseBody, InvokeCall, InvokeSent, PageError, PageOp, PageView, TabInfo, WaitFor } from '../types.ts';
+import type { BrowserChoice, Download, FetchResponseBody, InvokeCall, InvokeSent, PageError, PageOp, PageView, TabInfo, WaitFor } from '../types.ts';
 import { type Taken } from './control.ts';
 import { testHooks, type TestHooks } from './test-hooks.ts';
 declare module '@deepseek-ai/cordis' {
     interface Context {
         mhBrowser: MhBrowserService;
     }
+    interface Events {
+        /** Volatile config was committed on this plugin fiber. Paths are key arrays. */
+        'loader/volatile-update'(paths: readonly (readonly string[])[]): void;
+    }
 }
 export type WriteTarget = {
     root: string;
@@ -29,14 +33,27 @@ export interface HandBack extends Taken {
  * the session's browser. `act` returns a snapshot, including on a page that
  * also has an Agent View.
  */
-export declare class MhBrowserService extends TypertRemoteService {
-    static Config: import("@deepseek-ai/schemastery").default<BrowserConfig>;
+export declare class MhBrowserService extends Service {
     private readonly windows;
-    private readonly launchOptions;
+    private readonly headless;
+    /** Profile root. The default root gets one subdirectory per browser at launch. */
+    private readonly profileRoot;
+    /** A configured profile directory is used as given, without a per-browser subdirectory. */
+    private readonly splitProfile;
+    private readonly browserName;
+    private readonly executablePath;
+    /** Tests replace the machine lookup. Unset uses this machine. */
+    private locator;
     private context;
     private readonly pids;
     private ready;
     private closing;
+    /** A browser restart was requested and has not run yet. */
+    private relaunchWanted;
+    /** Counts browser and path changes. A start that sampled the latest one clears the restart. */
+    private configEpoch;
+    /** The running browser is being closed so the new configuration can start. */
+    private replacing;
     /** The browser is not running. The next call that needs a page starts it. */
     private exited;
     private readonly exits;
@@ -112,6 +129,13 @@ export declare class MhBrowserService extends TypertRemoteService {
     /** The person asked for the browser: start it if it exited, past the exit limit. */
     startForPerson(): Promise<void>;
     [testHooks](): TestHooks;
+    /**
+     * Where `browser` would be launched from when no path is configured.
+     * The configured path is not consulted: the answer is what an empty path uses.
+     * `auto` reports the browser automatic selection would launch.
+     */
+    locateFor(browser: BrowserChoice, signal?: AbortSignal): Promise<BrowserLocation>;
+    private locateAuto;
     act(owner: string, tab: string, op: PageOp, signal?: AbortSignal): Promise<PageView>;
     holdHandover(owner: string, tab: string): void;
     releaseHandover(owner: string): void;
@@ -152,6 +176,7 @@ export declare class MhBrowserService extends TypertRemoteService {
     /**
      * The person took over between turns. The next message they send is the
      * hand-back. A handover that is still waiting on its card is not.
+     * The addresses are read before a waiting restart closes the pages.
      */
     takePersonHandback(owner: string): HandBack | undefined;
     /**
@@ -243,5 +268,14 @@ export declare class MhBrowserService extends TypertRemoteService {
     private presenceUrls;
     private snapshotNamed;
     private exclusive;
+    private locateEnv;
+    private idle;
+    /**
+     * Close and start again when a configuration change is waiting and nothing
+     * is using the browser. A browser that is not running keeps the new values
+     * for the next start. The close is not counted as a crash.
+     */
+    private relaunchIfIdle;
+    private replaceBrowser;
 }
 //# sourceMappingURL=service.d.ts.map

package/lib/types/service/test-hooks.d.ts

@@ -1,3 +1,4 @@
+import type { LocateEnv } from './locate.ts';
 /** Key of the hooks tests use to crash the browser and reach a live page. Not exported by the package. */
 export declare const testHooks: unique symbol;
 export interface TestHooks {
@@ -9,5 +10,7 @@ export interface TestHooks {
     pages(): unknown[];
     /** The main browser process id recorded at start. */
     pid(): number | undefined;
+    /** Use this lookup instead of the machine's. `undefined` restores the machine. */
+    useLocator(env: LocateEnv | undefined): void;
 }
 //# sourceMappingURL=test-hooks.d.ts.map