@comecaramelos/dsh-chrome-mcp 0.0.1 → 2.0.0

package/lib/host/controller/notes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Controller — live-mirror announcements.
+ *
+ * The two answers the card can only learn from here: the resolved selection
+ * (with the WSL + Windows-executable state, keyed on the *selection*, not a
+ * probe), and where the bridge console output goes. Both land in the live mirror
+ * and reach the card through one volatile commit (see ./publish.ts).
+ */
+import type { BridgeStderrNotice } from "../types/index.js";
+import type { Controller } from "./state.js";
+/**
+ * Publish the resolved selection into the mirror — with the one state the card
+ * can only learn from here, and with the static notice that goes with it. The
+ * Windows-executable state is keyed on the *selection*, not on any probe: a
+ * Windows binary answers `--version` just fine across the interop boundary, so a
+ * healthy-looking pill is exactly what a broken Windows selection looks like
+ * until the first tool call fails.
+ */
+export declare function noteSelection(controller: Controller): void;
+/**
+ * Announce where the bridge's console output goes — one line per change of
+ * state, keyed on what actually happened, so neither the "log" capture nor
+ * a switch to console echo is silent.
+ */
+export declare function noteStderr(controller: Controller, built: BridgeStderrNotice): void;
+//# sourceMappingURL=notes.d.ts.map

package/lib/host/controller/notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.d.ts","sourceRoot":"","sources":["../../../src/host/controller/notes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAM5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAe1D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAUlF"}

package/lib/host/controller/notes.js

@@ -0,0 +1,44 @@
+import { flagsSkipCheck } from "../flags.js";
+import { isWindowsExecutablePath } from "../platform.js";
+import { publishLive } from "./publish.js";
+/**
+ * Publish the resolved selection into the mirror — with the one state the card
+ * can only learn from here, and with the static notice that goes with it. The
+ * Windows-executable state is keyed on the *selection*, not on any probe: a
+ * Windows binary answers `--version` just fine across the interop boundary, so a
+ * healthy-looking pill is exactly what a broken Windows selection looks like
+ * until the first tool call fails.
+ */
+export function noteSelection(controller) {
+    const { state } = controller;
+    state.live.effectiveChromePath = state.runningChromePath;
+    state.live.effectiveSource = state.runningChromeSource;
+    const windowsUnderWsl = !flagsSkipCheck(state.runningFlags) && controller.wslHost && isWindowsExecutablePath(state.runningChromePath);
+    state.live.wslWindowsExecutable = windowsUnderWsl;
+    // The log's pointer is the run, named: a headless host sees no notice, and
+    // "connect mode" on its own is not an action.
+    if (windowsUnderWsl && !state.wslNoticeShown) {
+        state.wslNoticeShown = true;
+        controller.ctx.logger.warn(`dsh-chrome-mcp(${controller.config.serverName}): running under WSL with a Windows executable selected ("${state.runningChromePath}") — that binary cannot be launched from here; run Prelaunch Windows Chrome (the card's action, or the prelaunch_windows_chrome tool) to drive it in connect mode`);
+    }
+    publishLive(controller);
+}
+/**
+ * Announce where the bridge's console output goes — one line per change of
+ * state, keyed on what actually happened, so neither the "log" capture nor
+ * a switch to console echo is silent.
+ */
+export function noteStderr(controller, built) {
+    const { state } = controller;
+    const key = built.redirect !== "" ? `file:${built.redirect}` : "console";
+    if (state.stderrNotice === key)
+        return;
+    state.stderrNotice = key;
+    if (built.redirect !== "") {
+        controller.ctx.logger.info(`dsh-chrome-mcp(${controller.config.serverName}): bridge stderr → ${built.redirect}`);
+    }
+    else {
+        controller.ctx.logger.info(`dsh-chrome-mcp(${controller.config.serverName}): bridge stderr → console (echo)`);
+    }
+}
+//# sourceMappingURL=notes.js.map

package/lib/host/controller/notes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes.js","sourceRoot":"","sources":["../../../src/host/controller/notes.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3C;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,UAAsB;IAChD,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC;IAC7B,KAAK,CAAC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC,iBAAiB,CAAC;IACzD,KAAK,CAAC,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,mBAAmB,CAAC;IACvD,MAAM,eAAe,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,UAAU,CAAC,OAAO,IAAI,uBAAuB,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACtI,KAAK,CAAC,IAAI,CAAC,oBAAoB,GAAG,eAAe,CAAC;IAClD,2EAA2E;IAC3E,8CAA8C;IAC9C,IAAI,eAAe,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;QAC3C,KAAK,CAAC,cAAc,GAAG,IAAI,CAAC;QAC5B,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CACtB,kBAAkB,UAAU,CAAC,MAAM,CAAC,UAAU,6DAA6D,KAAK,CAAC,iBAAiB,mKAAmK,CACxS,CAAC;IACN,CAAC;IACD,WAAW,CAAC,UAAU,CAAC,CAAC;AAC5B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,UAAsB,EAAE,KAAyB;IACxE,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC;IAC7B,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IACzE,IAAI,KAAK,CAAC,YAAY,KAAK,GAAG;QAAE,OAAO;IACvC,KAAK,CAAC,YAAY,GAAG,GAAG,CAAC;IACzB,IAAI,KAAK,CAAC,QAAQ,KAAK,EAAE,EAAE,CAAC;QACxB,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,UAAU,CAAC,MAAM,CAAC,UAAU,sBAAsB,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;IACrH,CAAC;SAAM,CAAC;QACJ,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,UAAU,CAAC,MAAM,CAAC,UAAU,mCAAmC,CAAC,CAAC;IAClH,CAAC;AACL,CAAC"}

package/lib/host/controller/persist.d.ts

@@ -0,0 +1,16 @@
+import type { ChromeExecutableEntry } from "../types/index.js";
+import type { Controller } from "./state.js";
+/** Persist one seeded/executable selection — the row-config fallback disappears
+ * the moment a path is picked, so a run that seeded one writes it exactly once. */
+export declare function persistChromePath(controller: Controller, path: string): Promise<void>;
+/** Persist the saved-executables rows a run merged into. */
+export declare function persistExecutables(controller: Controller, entries: ChromeExecutableEntry[]): Promise<void>;
+/** Persist the ids of rows the user dropped, so no later merge step folds them
+ * back in (see ../schema.ts `droppedExecutables`). */
+export declare function persistDroppedExecutables(controller: Controller, ids: readonly string[]): Promise<void>;
+/** Remember that this row's standalone-config translation was turned down
+ * (./../migration.ts D4). This is the only Host write the proposal path makes:
+ * the config itself is read, never rewritten, and nothing lands in the manager's
+ * `servers` without a click. */
+export declare function dismissMigration(controller: Controller): void;
+//# sourceMappingURL=persist.d.ts.map

package/lib/host/controller/persist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../../src/host/controller/persist.ts"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAAE,qBAAqB,EAAiB,MAAM,mBAAmB,CAAC;AAG9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAwC7C;mFACmF;AACnF,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAErF;AAED,4DAA4D;AAC5D,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1G;AAED;sDACsD;AACtD,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvG;AAED;;;gCAGgC;AAChC,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAE7D"}

package/lib/host/controller/persist.js

@@ -0,0 +1,98 @@
+/**
+ * Controller — persisting what the Host itself writes.
+ *
+ * Four writes may land back in the profile patch: the seeded executable, the
+ * saved rows a merged scan folded in, the ids of dropped rows, and the dismissed
+ * translation flag (./../migration.ts D4). Since dsh 0.2.0 the store is the
+ * profile's **own patch layer** (there is no `settings.yaml` any more) and the
+ * write goes through the `settings` service keyed by the row's profile **entry
+ * id** — the same key the card addresses by.
+ *
+ * What gets written is only ever a user-authored field — one field per write, so
+ * an unrelated edit the user made in the same layer keeps standing — and it goes
+ * through `settings.mutate(entryId, ops)` with the write's own `set` op first and
+ * then one `unset` op for **every live-mirror field** (see ../values.ts
+ * `liveMirrorKeys`). Why the unset ops belong to the write itself: a persisted
+ * write re-persists the volatile fields it answers, and whatever the live publish
+ * stands in the running references is answered through them, so a live answer can
+ * ride a save back into the patch file (measured live 2026-10-12: booting the
+ * plugin with no user write filled the profile's own `cordis.patch.yml` row with
+ * every live key). An `unset` returns the field to whatever the **row config**
+ * answers — the row's own patch layer is excluded underneath it — so what stands
+ * is the row's answer and a live-only answer drops out: the live boundary holds
+ * from the write channel, not from a check. And it heals: the first write to a
+ * row that already carries leaked live keys clears them.
+ *
+ * Every write still lands on the same follow-up rule (see ./commits.ts for the
+ * card's copy of it): a stored-layer write resets the live-only volatile fields
+ * back to their row-config answers, so the mirror goes straight back out with it.
+ *
+ * All three follow the same rules: the write is answered from the run's neutral
+ * async context (see ./runs.ts — a write still sitting inside the write
+ * transaction its own form commit opened is a *nested* transaction, which the
+ * platform refuses instead of queueing), and it never throws out of the run. The
+ * mirror is what the card reads, and a failed write must not break an otherwise
+ * successful run.
+ */
+import { createPersister } from "@comecaramelos/dsh-ancesters/host";
+import { liveMirrorKeys } from "../values.js";
+import { MIGRATION_DISMISSED_FIELD } from "../constants.js";
+import { publishLive } from "./publish.js";
+/** One persister per controller (ancestros' `createPersister`): the write's own
+ * field first, then one `unset` per live-mirror field, no revision fence (the
+ * Host putting its own answer into the row, not an editor saving a view — a
+ * stale view must not lose the seed / the merged rows / the connect flag the
+ * run just produced), and the mirror re-asserted after the write **and** after
+ * a refused one (measured live 2026-10-13: a refused rows merge on a read-only
+ * row otherwise left the references answering no `lastError` ever again). */
+const persisters = new WeakMap();
+function persisterOf(controller) {
+    let persister = persisters.get(controller);
+    if (persister === void 0) {
+        persister = createPersister(controller.ctx, {
+            form: {
+                current: () => {
+                    const form = controller.state.form;
+                    if (form === void 0)
+                        return void 0;
+                    const settings = form.settings ?? controller.ctx.get("settings");
+                    return { entryId: form.entryId, settings: settings };
+                },
+                liveKeys: () => liveMirrorKeys(),
+                attached: () => controller.state.form !== void 0
+            },
+            liveKeys: liveMirrorKeys(),
+            publishLive: () => publishLive(controller),
+            name: `dsh-chrome-mcp(${controller.config.serverName})`
+        });
+        persisters.set(controller, persister);
+    }
+    return persister;
+}
+/** Write one user-authored field into the row's own patch layer, clearing every
+ * live-mirror field back to its row-config answer (see the module header). */
+function persist(controller, field, value, note) {
+    return persisterOf(controller)({ [field]: value }, `dsh-chrome-mcp(${controller.config.serverName}): ${note}`);
+}
+/** Persist one seeded/executable selection — the row-config fallback disappears
+ * the moment a path is picked, so a run that seeded one writes it exactly once. */
+export function persistChromePath(controller, path) {
+    return persist(controller, "chromePath", path, "failed to persist the seeded chromePath");
+}
+/** Persist the saved-executables rows a run merged into. */
+export function persistExecutables(controller, entries) {
+    return persist(controller, "executables", entries, "failed to persist the executable rows");
+}
+/** Persist the ids of rows the user dropped, so no later merge step folds them
+ * back in (see ../schema.ts `droppedExecutables`). */
+export function persistDroppedExecutables(controller, ids) {
+    return persist(controller, "droppedExecutables", [...ids], "failed to persist the dropped executable ids");
+}
+/** Remember that this row's standalone-config translation was turned down
+ * (./../migration.ts D4). This is the only Host write the proposal path makes:
+ * the config itself is read, never rewritten, and nothing lands in the manager's
+ * `servers` without a click. */
+export function dismissMigration(controller) {
+    void persist(controller, MIGRATION_DISMISSED_FIELD, true, "failed to persist the dismissed translation");
+}
+//# sourceMappingURL=persist.js.map

package/lib/host/controller/persist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.js","sourceRoot":"","sources":["../../../src/host/controller/persist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EAAE,eAAe,EAAoB,MAAM,mCAAmC,CAAC;AAEtF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAG5D,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3C;;;;;;6EAM6E;AAC7E,MAAM,UAAU,GAAG,IAAI,OAAO,EAA2B,CAAC;AAE1D,SAAS,WAAW,CAAC,UAAsB;IACvC,IAAI,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC3C,IAAI,SAAS,KAAK,KAAK,CAAC,EAAE,CAAC;QACvB,SAAS,GAAG,eAAe,CAAC,UAAU,CAAC,GAAY,EAAE;YACjD,IAAI,EAAE;gBACF,OAAO,EAAE,GAAG,EAAE;oBACV,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC;oBACnC,IAAI,IAAI,KAAK,KAAK,CAAC;wBAAE,OAAO,KAAK,CAAC,CAAC;oBACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAK,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAA+B,CAAC;oBAChG,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAiB,EAAE,CAAC;gBAClE,CAAC;gBACD,QAAQ,EAAE,GAAG,EAAE,CAAC,cAAc,EAAE;gBAChC,QAAQ,EAAE,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC;aACnD;YACD,QAAQ,EAAE,cAAc,EAAE;YAC1B,WAAW,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC;YAC1C,IAAI,EAAE,kBAAkB,UAAU,CAAC,MAAM,CAAC,UAAU,GAAG;SAC1D,CAAC,CAAC;QACH,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED;8EAC8E;AAC9E,SAAS,OAAO,CAAC,UAAsB,EAAE,KAAa,EAAE,KAAc,EAAE,IAAY;IAChF,OAAO,WAAW,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,EAAE,kBAAkB,UAAU,CAAC,MAAM,CAAC,UAAU,MAAM,IAAI,EAAE,CAAC,CAAC;AACnH,CAAC;AAED;mFACmF;AACnF,MAAM,UAAU,iBAAiB,CAAC,UAAsB,EAAE,IAAY;IAClE,OAAO,OAAO,CAAC,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,yCAAyC,CAAC,CAAC;AAC9F,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,kBAAkB,CAAC,UAAsB,EAAE,OAAgC;IACvF,OAAO,OAAO,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,uCAAuC,CAAC,CAAC;AAChG,CAAC;AAED;sDACsD;AACtD,MAAM,UAAU,yBAAyB,CAAC,UAAsB,EAAE,GAAsB;IACpF,OAAO,OAAO,CAAC,UAAU,EAAE,oBAAoB,EAAE,CAAC,GAAG,GAAG,CAAC,EAAE,8CAA8C,CAAC,CAAC;AAC/G,CAAC;AAED;;;gCAGgC;AAChC,MAAM,UAAU,gBAAgB,CAAC,UAAsB;IACnD,KAAK,OAAO,CAAC,UAAU,EAAE,yBAAyB,EAAE,IAAI,EAAE,6CAA6C,CAAC,CAAC;AAC7G,CAAC"}

package/lib/host/controller/publish.d.ts

@@ -0,0 +1,4 @@
+import type { Controller } from "./state.js";
+/** Queue one coalesced publish. */
+export declare function publishLive(controller: Controller): void;
+//# sourceMappingURL=publish.d.ts.map

package/lib/host/controller/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../src/host/controller/publish.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,mCAAmC;AACnC,wBAAgB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAiCxD"}

package/lib/host/controller/publish.js

@@ -0,0 +1,56 @@
+/**
+ * Controller — publishing the live mirror.
+ *
+ * Every answer the card reads (`lastError`, the per-path probe list, the resolved
+ * selection, the Windows run state, …) is a `.volatile()` field of the same
+ * `Config` the card edits, so publishing is one **volatile commit** — and that
+ * channel is `createLiveMirror` from `@comecaramelos/dsh-ancesters/host`: the
+ * coalescing, the wait for the fiber to settle, the loader-entry merge that
+ * persists nothing and never remounts, the `describe()` that turns the new
+ * revision into the event the card settles on, and the re-assert when a settings
+ * write anywhere in the profile resets the live keys (dsh 0.2.1).
+ *
+ * What stays here is what the mirror *means* for this row: the connect-mode
+ * answer, derived on every publish, and telling the manager that what a picker
+ * would answer just moved.
+ */
+import { createLiveMirror } from "@comecaramelos/dsh-ancesters/host";
+import { flagsSkipCheck } from "../flags.js";
+/** Queue one coalesced publish. */
+export function publishLive(controller) {
+    const { state } = controller;
+    // The connect-mode answer is re-derived here, off what answers connect
+    // mode right now: a connection whose running flags carry the debug URL, or
+    // a live **Prelaunch Windows Chrome** run that stands connected against its
+    // port. Connect mode is a property of the running argv, not of a flags
+    // *change* — answering only where a flags list was applied left a row that
+    // already runs in connect mode serving the pill as the local selection
+    // (measured live 2026-10-13: a host booted with
+    // `--browserUrl=http://127.0.0.1:9223` in its row config never read Connect
+    // mode; the pill read the executable name and only turned over when the
+    // run applied the flags itself). Deriving on every publish means the answer
+    // can never be quieter than what is running.
+    state.live.carriesConnectionMode = flagsSkipCheck(state.runningFlags) || (state.live.windowsChromeStatus.state === "connected" && state.live.windowsChromeStatus.port > 0);
+    if (state.mirror === void 0) {
+        state.mirror = createLiveMirror(controller.ctx, {
+            name: `dsh-chrome-mcp(${controller.config.serverName})`,
+            read: () => ({ ...state.live }),
+            settings: () => (controller.state.form?.settings ?? controller.ctx.get("settings"))
+        });
+    }
+    state.mirror.publish();
+    // The connection fields' `select` choices are Host-served answers read off
+    // this very state (the catalog, the scan answers, what a live connection
+    // runs with), so every publish says "what a picker would answer just
+    // moved" — once per turn, like the publish itself (see ../manager.ts:
+    // "every publish re-notifies").
+    if (state.kindsNotifyQueued)
+        return;
+    state.kindsNotifyQueued = true;
+    queueMicrotask(() => {
+        state.kindsNotifyQueued = false;
+        if (!state.disposed)
+            state.notifyKindsChanged();
+    });
+}
+//# sourceMappingURL=publish.js.map

package/lib/host/controller/publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.js","sourceRoot":"","sources":["../../../src/host/controller/publish.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAErE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAK7C,mCAAmC;AACnC,MAAM,UAAU,WAAW,CAAC,UAAsB;IAC9C,MAAM,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC;IAC7B,uEAAuE;IACvE,2EAA2E;IAC3E,4EAA4E;IAC5E,uEAAuE;IACvE,2EAA2E;IAC3E,uEAAuE;IACvE,gDAAgD;IAChD,4EAA4E;IAC5E,wEAAwE;IACxE,4EAA4E;IAC5E,6CAA6C;IAC7C,KAAK,CAAC,IAAI,CAAC,qBAAqB,GAAG,cAAc,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,KAAK,WAAW,IAAI,KAAK,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IAC3K,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,CAAC,EAAE,CAAC;QAC1B,KAAK,CAAC,MAAM,GAAG,gBAAgB,CAAC,UAAU,CAAC,GAAY,EAAE;YACrD,IAAI,EAAE,kBAAkB,UAAU,CAAC,MAAM,CAAC,UAAU,GAAG;YACvD,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,CAA4B;YAC1D,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,IAAK,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,UAAU,CAA+B,CAAU;SAC9H,CAAC,CAAC;IACP,CAAC;IACD,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IACvB,2EAA2E;IAC3E,yEAAyE;IACzE,qEAAqE;IACrE,sEAAsE;IACtE,gCAAgC;IAChC,IAAI,KAAK,CAAC,iBAAiB;QAAE,OAAO;IACpC,KAAK,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAC/B,cAAc,CAAC,GAAG,EAAE;QAChB,KAAK,CAAC,iBAAiB,GAAG,KAAK,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,QAAQ;YAAE,KAAK,CAAC,kBAAkB,EAAE,CAAC;IACpD,CAAC,CAAC,CAAC;AACP,CAAC"}

package/lib/host/controller/runs.d.ts

@@ -0,0 +1,80 @@
+import type { ChromeExecutableEntry, ChromeExecutableStatus, EffectiveChromeSource } from "../types/index.js";
+import type { Controller } from "./state.js";
+/** The serialized units one controller may queue. */
+export type RunKind = "refresh" | "probe" | "windows";
+/** Element-wise equality of two saved-row lists (order is the dropdown order). */
+export declare function sameEntries(a: readonly ChromeExecutableEntry[], b: readonly ChromeExecutableEntry[]): boolean;
+/**
+ * Fold the legacy hand-typed MRU into the rows, exactly once. It is the same list
+ * the older card used to write, so reading it never duplicates a row the card
+ * already saved: the merge keeps stored rows and only appends ids that are
+ * missing, and the result lands in the persisted rows instead of staying
+ * readable forever as a second source.
+ */
+export declare function mergeLegacyPaths(controller: Controller, skip?: ReadonlySet<string>): ChromeExecutableEntry[];
+/**
+ * One executable run. Probe every candidate the row config and the saved rows
+ * carry (plus the selection — the same path may appear as a row), publish what
+ * answered as per-path status, and merge what was found into the saved rows,
+ * keeping the names their user gave them. When nothing is configured at all
+ * (neither layer carries a path) the first runnable entry is **seeded**: written
+ * into the persisted `chromePath` once, so what the picker shows is what the
+ * bridge runs. A selection that is already fixed is never re-resolved, however
+ * broken.
+ * @returns the per-path statuses the run answered with.
+ */
+export declare function runExecutableDiscovery(controller: Controller): Promise<ChromeExecutableStatus[]>;
+/**
+ * The probe of the *selection* — the one run that answers the version line the
+ * card shows under the pill. Nothing probed (no selection, or a connect-mode
+ * flag) must not clear anything: upstream starts the browser lazily, so silence
+ * is not health.
+ */
+export declare function probeSelection(controller: Controller): Promise<string>;
+/**
+ * Write one executable selection through the Host write-back channel — the same
+ * persisted `chromePath` field every other surface reads — and re-fire the run
+ * behind it, the way the card's own selection commit does: a changed selection
+ * shifts the default answers (connections follow, the run re-runs), an
+ * unchanged write just re-probes. This is the command-side mirror of the
+ * picker — pill, command and catalog read and write one field — so a headless
+ * selection lands exactly where a GUI pick would.
+ */
+export declare function selectChromePath(controller: Controller, path: string): Promise<void>;
+/**
+ * Carry a different executable into the live answers — the argv tail carries
+ * `--executablePath=<path>`, so unlike a flags edit this one is what the card's
+ * pill claims is running. What lives stands on is not restarted here: a
+ * connection that follows the row's default is handed back to the pool for a
+ * re-resolve, and one that picked its own executable was never following it.
+ * `rerun` schedules the scan+probe that follows a selection change; a caller
+ * that is already inside that run (the seeding branch above) passes `false`.
+ */
+export declare function applyChromePath(controller: Controller, path: string, nextSource: EffectiveChromeSource, rerun?: boolean): void;
+/** Cancel the pending bounded retry — what the instance's dispose calls. */
+export declare function cancelDiscoveryRetry(controller: Controller): void;
+/**
+ * Serialize one unit of work: a rows-only refresh, a run that also re-probes
+ * what is selected, or the Windows Chrome launch. Windows runs share this chain
+ * because the invariant is "one run at a time" — nothing about it interacts with
+ * the local probe. The body answers from a neutral async context (see
+ * `runContext`): a run scheduled from a form commit must not carry that
+ * commit's write transaction, or every write the run answers would be refused
+ * as a nested transaction.
+ */
+export declare function queue(controller: Controller, kind: RunKind): Promise<unknown>;
+/**
+ * One Windows Chrome run on demand: queued on the same chain as the button (one
+ * run at a time), resolved once it settled. The answer is the live mirror read
+ * after the run — the tool surface says what `windowsChromeStatus` says, never
+ * more than the run answered.
+ *
+ * With the manager mounted this is also the surface that keeps the live
+ * `chrome-windows` connections honest: a run that connected while such a
+ * connection stands is a reason to answer that connection again (the run is
+ * idempotent — the live port rides into `currentFlags` — so re-answering is not
+ * a second browser), and a run that connected without one is said to be worth
+ * one.
+ */
+export declare function prelaunchWindowsChrome(controller: Controller): Promise<string>;
+//# sourceMappingURL=runs.d.ts.map

package/lib/host/controller/runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runs.d.ts","sourceRoot":"","sources":["../../../src/host/controller/runs.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAQ9G,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,qDAAqD;AACrD,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAoBtD,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,qBAAqB,EAAE,EAAE,CAAC,EAAE,SAAS,qBAAqB,EAAE,GAAG,OAAO,CAG7G;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,qBAAqB,EAAE,CAe5G;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CA6FtG;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAsC5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,qBAAqB,EAAE,KAAK,UAAO,GAAG,IAAI,CAW3H;AAqDD,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAMjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAkB7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBpF"}