@farmslot/adapter-web 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,18 @@ All notable changes to `@farmslot/adapter-web` are tracked here.
 
 - Active-development baseline; add user-facing changes here before release or package publication.
 
+## 0.4.0 - 2026-10-06
+
+- Add `network-observer` (`createExtensionNetworkObserver({ cdpPort, runtimeDir })`) and `performance-observer` (`createExtensionPerformanceBackend({ cdpPort, extensionId, uiPaths, kind, platform, markerPrefix })`), the Extension network and performance observers moved from mm-harness. The network observer attaches to every target of the loaded extension and feeds their Network events to a `@farmslot/recipe-runner/cdp-broker`; it returns an `@farmslot/adapter-sdk` `NetworkCaptureBackend`. The performance observer traces the extension page found at the first of `uiPaths` with exactly one open renderer, through `@farmslot/recipe-runner/runtime/cdp-trace`. Both run on `connectBrowserCdp`; `connectTimeoutMs` and `commandTimeoutMs` default to 10 s. The package now depends on `@farmslot/recipe-runner` and `@farmslot/adapter-sdk`.
+- `browser-cdp`: `connectBrowserCdp` clients gain `onEvent(handler)` (every CDP event, as `{ method, params, sessionId? }`; events were dropped before) and `onClose(handler)` (once, when the socket closes; at once on a client that has already closed), each returning an unsubscribe function. `onEvent` on a closed client keeps nothing. Add `asBrowserCdpTarget` and `extensionIdFromCdpTargets`.
+- `page-target`: add `selectExtensionTarget(targets, extensionId, { paths })`, the extension UI renderer at the first path with any match, or null when that path has several.
+- Publish with adapter-sdk 0.5.1 and recipe-runner 0.26.0.
+
+## 0.3.1 - 2026-10-06
+
+- Browser probes no longer leave Chrome for Testing running when the resolver is stopped mid-probe (a hook timeout, a signal, or the resolver killed outright): the probe browser and its temporary profile are removed.
+  - A resolver killed outright cannot clean up; the next probe by the same user stops its browser and removes its profile. `browser-resolver` exports that step as `reapOrphanedProbes(tmp?)`.
+
 ## 0.3.0 - 2026-10-05
 
 - Add `dapp`, the web3 layer for a dapp under test, moved from `@deeeed/metamask-harness`'s Web Terminal adapter: the strict EIP-1193 test wallet (`createStrictWallet`), the page script that wraps the app's provider and logs its wallet requests or injects a provider the host answers (`pageScriptSource`, `pageReadyExpression`), the host's side of its bindings (`createWalletRequestBinding`: frame and document attribution, `outside-app-frame` and `unattributed` records, refusals) and the wallet request log (`windowSinceCursor`, `resetWindow`, `evaluateSignatureLog`, `awaitSignatureLog`, `writeLogArtifact`). Product policy is passed in: the typed data to refuse (`refuseTypedData`), the injected wallet's EIP-6963 identity and the log entries and typed-data classes a product forbids. Page bindings are `__farmslotWallet{Log,Request,Resolve}` and the page marker `__farmslotDapp`.

package/README.md

@@ -12,21 +12,23 @@ Docs: https://farmslot.io/docs/reference/adapter-web
 
 ## Source layout
 
-| module                         | owns                                                                                                           |
-| ------------------------------ | -------------------------------------------------------------------------------------------------------------- |
-| `browser-resolver`             | Chrome for Testing vs branded Chrome, probe-launch and its cache, extension loading method; CLI entry          |
-| `browser-cdp`                  | browser-level CDP client with deadlines, CDP-port ownership proof, `Extensions.loadUnpacked`, window placement |
-| `chrome-args`                  | remote-debugging flags, isolated profile flags, runtime identity nonce, launch quarantine markers              |
-| `dapp`                         | web dapps: strict EIP-1193 test wallet, wallet-request page script and its host binding, wallet request log    |
-| `extension-id`                 | Chromium extension id from a manifest key or an unpacked directory                                             |
-| `launch-browser`               | launch (or release) one isolated, detached, owned Chromium with an unpacked extension                          |
-| `macos-focus`                  | capture the frontmost app before a headed launch and restore it if one of our browsers took it                 |
-| `origin`                       | exact app-origin checks, the app top-frame CDP context check, URLs without query strings                       |
-| `page-target`                  | pick the page on an origin, preferring one whose URL carries a hash                                            |
-| `playwright-cdp`               | page evaluation over a raw CDP session (safe under LavaMoat scuttling)                                         |
-| `slot-title`                   | prefix the extension home tab's title with the farm slot id, kept across the page's own title resets           |
-| `validation-process-ownership` | find and stop the processes that own a slot profile                                                            |
-| `validation-launch-supervisor` | supervised child for one validation launch: port lease, quarantine and cleanup                                 |
+| module                         | owns                                                                                                                      |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------- |
+| `browser-resolver`             | Chrome for Testing vs branded Chrome, probe-launch and its cache, extension loading method; CLI entry                     |
+| `browser-cdp`                  | browser-level CDP client with deadlines and events, CDP-port ownership proof, `Extensions.loadUnpacked`, window placement |
+| `chrome-args`                  | remote-debugging flags, isolated profile flags, runtime identity nonce, launch quarantine markers                         |
+| `dapp`                         | web dapps: strict EIP-1193 test wallet, wallet-request page script and its host binding, wallet request log               |
+| `extension-id`                 | Chromium extension id from a manifest key or an unpacked directory                                                        |
+| `launch-browser`               | launch (or release) one isolated, detached, owned Chromium with an unpacked extension                                     |
+| `macos-focus`                  | capture the frontmost app before a headed launch and restore it if one of our browsers took it                            |
+| `network-observer`             | network capture for every target of a loaded extension, through recipe-runner's CDP broker                                |
+| `origin`                       | exact app-origin checks, the app top-frame CDP context check, URLs without query strings                                  |
+| `page-target`                  | pick the page on an origin, or an extension's UI renderer by path                                                         |
+| `performance-observer`         | CDP performance traces of an extension's UI renderer, through recipe-runner's trace collector                             |
+| `playwright-cdp`               | page evaluation over a raw CDP session (safe under LavaMoat scuttling)                                                    |
+| `slot-title`                   | prefix the extension home tab's title with the farm slot id, kept across the page's own title resets                      |
+| `validation-process-ownership` | find and stop the processes that own a slot profile                                                                       |
+| `validation-launch-supervisor` | supervised child for one validation launch: port lease, quarantine and cleanup                                            |
 
 Sources are CommonJS (`src/**/*.cjs`) and ship as is; `yarn build` emits `.d.cts` declarations. Every library subpath can be `require`d or `import`ed with named imports, except `validation-launch-supervisor`: it is a child-process entry (it runs when loaded), so hosts `require.resolve` it and fork it.
 

package/dist/browser-cdp.d.cts

@@ -1,3 +1,13 @@
+export type BrowserCdpEvent = {
+    method: string;
+    params: Record<string, any>;
+    sessionId?: string;
+};
+export type BrowserCdpTarget = {
+    targetId: string;
+    type: string;
+    url: string;
+};
 export const DEFAULT_COMMAND_TIMEOUT_MS: 15000;
 export const START_TIME_SLACK_MS: 2000;
 /**
@@ -14,6 +24,11 @@ export function assertCdpOwnedByProfile(port: number, profile: string, options?:
     profile: string;
     cdpPort: number;
 };
+/**
+ * @param {unknown} value
+ * @returns {BrowserCdpTarget | null}
+ */
+export function asBrowserCdpTarget(value: unknown): BrowserCdpTarget | null;
 /**
  * @param {{ pid: number, startedAt: string, profile: string, cdpPort: number }} owner
  * @param {{ exec?: typeof defaultExec, timeoutMs?: number }} [options]
@@ -57,14 +72,33 @@ export function waitForCdpOwner(port: any, profile: any, { timeoutMs, exec }?: {
     profile: string;
     cdpPort: number;
 };
+/**
+ * @typedef {{ method: string, params: Record<string, any>, sessionId?: string }} BrowserCdpEvent
+ * @typedef {{ targetId: string, type: string, url: string }} BrowserCdpTarget
+ */
 export function connectBrowserCdp(port: any, { timeoutMs, commandTimeoutMs }?: {
     timeoutMs?: number | undefined;
     commandTimeoutMs?: number | undefined;
 }): Promise<{
-    send: (method: any, params: {} | undefined, sessionId: any, timeout?: number) => Promise<any>;
+    send: (method: string, params?: Record<string, any>, sessionId?: string, timeout?: number) => Promise<any>;
+    /**
+     * @param {(event: BrowserCdpEvent) => void} handler
+     * @returns {() => void}
+     */
+    onEvent: (handler: (event: BrowserCdpEvent) => void) => () => void;
+    /**
+     * @param {() => void} handler
+     * @returns {() => void}
+     */
+    onClose: (handler: () => void) => () => void;
     close: () => void;
 }>;
 export function expectedExtensionId(extensionDir: any): string | null;
+/**
+ * @param {unknown} targets
+ * @returns {string | null}
+ */
+export function extensionIdFromCdpTargets(targets: unknown): string | null;
 export function loadUnpackedExtension(send: any, extensionDir: any, { expectedId, timeoutMs }?: {
     expectedId?: null | undefined;
     timeoutMs?: number | undefined;

package/dist/browser-resolver.d.cts

@@ -64,6 +64,7 @@ export function probeLaunch(executable: any, { launchMethod, display, settleMs,
     durationMs: number;
 }>;
 export function readProbeCache(cachePath: any): any;
+export function reapOrphanedProbes(tmp?: string): void;
 export function renderCheck(port: any): Promise<{
     ok: boolean;
     reason?: undefined;

package/dist/network-observer.d.cts

@@ -0,0 +1,12 @@
+/**
+ * @param {{ cdpPort: number, runtimeDir: string, connectTimeoutMs?: number, commandTimeoutMs?: number }} options
+ *   `runtimeDir` keys the broker socket; the timeouts bound the CDP connection
+ *   and every command, broker call and capture control.
+ * @returns {Promise<import('@farmslot/adapter-sdk').NetworkCaptureBackend>}
+ */
+export function createExtensionNetworkObserver({ cdpPort, runtimeDir, connectTimeoutMs, commandTimeoutMs, }: {
+    cdpPort: number;
+    runtimeDir: string;
+    connectTimeoutMs?: number;
+    commandTimeoutMs?: number;
+}): Promise<import("@farmslot/adapter-sdk").NetworkCaptureBackend>;

package/dist/page-target.d.cts

@@ -1,3 +1,12 @@
+/**
+ * @param {unknown} targets
+ * @param {string} extensionId
+ * @param {{ paths: readonly string[] }} options
+ * @returns {import('./browser-cdp.cjs').BrowserCdpTarget | null}
+ */
+export function selectExtensionTarget(targets: unknown, extensionId: string, { paths }: {
+    paths: readonly string[];
+}): import("./browser-cdp.cjs").BrowserCdpTarget | null;
 export function selectPageTarget(targets: any, { origin, hash }: {
     origin: any;
     hash?: string | undefined;

package/dist/performance-observer.d.cts

@@ -0,0 +1,26 @@
+/**
+ * @template {string} [P=string]
+ * @param {{
+ *   cdpPort: number,
+ *   extensionId: string,
+ *   uiPaths: readonly string[],
+ *   kind: import('@farmslot/recipe-runner/runtime/cdp-trace').TraceKind,
+ *   platform: P,
+ *   markerPrefix?: string,
+ *   connectTimeoutMs?: number,
+ *   commandTimeoutMs?: number,
+ * }} options
+ *   `uiPaths` are the extension pages to trace, in order of preference (see
+ *   `selectExtensionTarget`); `kind`, `platform` and `markerPrefix` go to the collector.
+ * @returns {Promise<import('@farmslot/recipe-runner/runtime/cdp-trace').PerformanceBackend<P>>}
+ */
+export function createExtensionPerformanceBackend<P extends string = string>({ cdpPort, extensionId, uiPaths, kind, platform, markerPrefix, connectTimeoutMs, commandTimeoutMs, }: {
+    cdpPort: number;
+    extensionId: string;
+    uiPaths: readonly string[];
+    kind: import("@farmslot/recipe-runner/runtime/cdp-trace").TraceKind;
+    platform: P;
+    markerPrefix?: string;
+    connectTimeoutMs?: number;
+    commandTimeoutMs?: number;
+}): Promise<import("@farmslot/recipe-runner/runtime/cdp-trace").PerformanceBackend<P>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@farmslot/adapter-web",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Web platform adapter for Farmslot recipes: resolve and launch an isolated Chromium, own its CDP port, load unpacked extensions, and keep macOS focus.",
   "type": "commonjs",
   "exports": {
@@ -32,6 +32,10 @@
       "types": "./dist/macos-focus.d.cts",
       "default": "./src/macos-focus.cjs"
     },
+    "./network-observer": {
+      "types": "./dist/network-observer.d.cts",
+      "default": "./src/network-observer.cjs"
+    },
     "./origin": {
       "types": "./dist/origin.d.cts",
       "default": "./src/origin.cjs"
@@ -41,6 +45,10 @@
       "types": "./dist/page-target.d.cts",
       "default": "./src/page-target.cjs"
     },
+    "./performance-observer": {
+      "types": "./dist/performance-observer.d.cts",
+      "default": "./src/performance-observer.cjs"
+    },
     "./playwright-cdp": {
       "types": "./dist/playwright-cdp.d.cts",
       "default": "./src/playwright-cdp.cjs"
@@ -66,11 +74,13 @@
     "lint": "eslint \"src/**/*.cjs\" \"test/**/*.cjs\" \"test/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.cjs\" \"test/**/*.cjs\" \"test/**/*.ts\" --fix",
     "quality": "prettier --check --ignore-path ../../.prettierignore . && eslint \"src/**/*.cjs\" \"test/**/*.cjs\" \"test/**/*.ts\" && yarn typecheck && yarn test",
-    "build": "rm -rf dist && tsc --project tsconfig.build.json",
+    "build": "yarn workspace @farmslot/adapter-sdk build && rm -rf dist && tsc --project tsconfig.build.json",
     "prepack": "cd ../.. && node scripts/quality/check-farmslot-package-readiness.mjs --require-changelog --packages @farmslot/adapter-web && yarn workspace @farmslot/adapter-web build",
     "prepublishOnly": "node ../../scripts/quality/check-farmslot-package-readiness.mjs --publish --packages @farmslot/adapter-web"
   },
   "dependencies": {
+    "@farmslot/adapter-sdk": "0.5.1",
+    "@farmslot/recipe-runner": "0.26.0",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/src/browser-cdp.cjs

@@ -5,6 +5,8 @@
 //
 // Every command has a deadline and every pending command fails when the
 // socket closes, so a browser that dies or stalls never hangs a launcher.
+// Observers subscribe to CDP events (`onEvent`) and to the socket closing
+// (`onClose`) on the same client.
 'use strict';
 
 const { execFileSync } = require('node:child_process');
@@ -21,6 +23,11 @@ function deadlineError(what, ms) {
   return Object.assign(new Error(`${what} did not answer within ${ms}ms`), { code: 'CDP_TIMEOUT' });
 }
 
+/**
+ * @typedef {{ method: string, params: Record<string, any>, sessionId?: string }} BrowserCdpEvent
+ * @typedef {{ targetId: string, type: string, url: string }} BrowserCdpTarget
+ */
+
 async function connectBrowserCdp(
   port,
   { timeoutMs = 30000, commandTimeoutMs = DEFAULT_COMMAND_TIMEOUT_MS } = {},
@@ -45,6 +52,10 @@ async function connectBrowserCdp(
   const WebSocketImpl = globalThis.WebSocket ?? require('ws');
   const socket = new WebSocketImpl(url);
   const pending = new Map();
+  /** @type {Set<(event: BrowserCdpEvent) => void>} */
+  const eventHandlers = new Set();
+  /** @type {Set<() => void>} */
+  const closeHandlers = new Set();
   let closedError = null;
   const failAll = (error) => {
     closedError ??= error;
@@ -78,10 +89,24 @@ async function connectBrowserCdp(
   const lost = () =>
     failAll(new Error('Browser CDP socket closed (the browser exited or disconnected).'));
   socket.onerror = lost;
-  socket.onclose = lost;
+  socket.onclose = () => {
+    lost();
+    for (const handler of [...closeHandlers]) handler();
+    closeHandlers.clear();
+    eventHandlers.clear();
+  };
   let nextId = 0;
   socket.onmessage = (event) => {
     const message = JSON.parse(typeof event.data === 'string' ? event.data : String(event.data));
+    if (message.id === undefined && message.method) {
+      const cdpEvent = {
+        method: message.method,
+        params: message.params ?? {},
+        ...(message.sessionId ? { sessionId: message.sessionId } : {}),
+      };
+      for (const handler of [...eventHandlers]) handler(cdpEvent);
+      return;
+    }
     const entry = message.id === undefined ? null : pending.get(message.id);
     if (!entry) return;
     pending.delete(message.id);
@@ -89,6 +114,13 @@ async function connectBrowserCdp(
     if (message.error) entry.reject(new Error(`${entry.method}: ${message.error.message}`));
     else entry.resolve(message.result);
   };
+  /**
+   * @param {string} method
+   * @param {Record<string, any>} [params]
+   * @param {string} [sessionId]
+   * @param {number} [timeout]
+   * @returns {Promise<any>}
+   */
   const send = (method, params = {}, sessionId, timeout = commandTimeoutMs) =>
     new Promise((resolve, reject) => {
       if (closedError) {
@@ -109,6 +141,36 @@ async function connectBrowserCdp(
     });
   return {
     send,
+    // Every CDP event (a message without an id), from the browser or an
+    // attached session. Returns the unsubscribe function; a closed client
+    // has no more events and keeps no handler.
+    /**
+     * @param {(event: BrowserCdpEvent) => void} handler
+     * @returns {() => void}
+     */
+    onEvent: (handler) => {
+      if (closedError) return () => {};
+      eventHandlers.add(handler);
+      return () => {
+        eventHandlers.delete(handler);
+      };
+    },
+    // Once, when the socket closes: the browser exited or `close()` was called.
+    // On a client that is already closed, the handler runs at once.
+    /**
+     * @param {() => void} handler
+     * @returns {() => void}
+     */
+    onClose: (handler) => {
+      if (closedError) {
+        handler();
+        return () => {};
+      }
+      closeHandlers.add(handler);
+      return () => {
+        closeHandlers.delete(handler);
+      };
+    },
     close: () => {
       failAll(new Error('Browser CDP client closed.'));
       try {
@@ -712,10 +774,48 @@ function expectedExtensionId(extensionDir) {
   return extensionIdFromExtensionDir(extensionDir) || null;
 }
 
+// ---- target lists ---------------------------------------------------------
+
+// One entry of `Target.getTargets` (`targetId`) or of the `/json` list (`id`),
+// or null when it lacks an id, type or URL.
+/**
+ * @param {unknown} value
+ * @returns {BrowserCdpTarget | null}
+ */
+function asBrowserCdpTarget(value) {
+  const target = /** @type {Record<string, unknown>} */ (
+    value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+  );
+  const targetId = String(target.targetId ?? target.id ?? '');
+  const type = String(target.type ?? '');
+  const url = String(target.url ?? '');
+  return targetId && type && url ? { targetId, type, url } : null;
+}
+
+// The id of the first extension that has a target in the list.
+/**
+ * @param {unknown} targets
+ * @returns {string | null}
+ */
+function extensionIdFromCdpTargets(targets) {
+  for (const candidate of Array.isArray(targets) ? targets : []) {
+    const target = asBrowserCdpTarget(candidate);
+    if (!target) continue;
+    try {
+      const url = new URL(target.url);
+      if (url.protocol === 'chrome-extension:' && url.hostname) return url.hostname;
+    } catch {
+      // Not a URL: not an extension target.
+    }
+  }
+  return null;
+}
+
 module.exports = {
   DEFAULT_COMMAND_TIMEOUT_MS,
   START_TIME_SLACK_MS,
   assertCdpOwnedByProfile,
+  asBrowserCdpTarget,
   assertSameOwner,
   canonicalProfile,
   cdpListenerPids,
@@ -724,6 +824,7 @@ module.exports = {
   waitForCdpOwner,
   connectBrowserCdp,
   expectedExtensionId,
+  extensionIdFromCdpTargets,
   loadUnpackedExtension,
   loadUnpackedOverPort,
   ensureBackgroundWindow,

package/src/browser-resolver.cjs

@@ -529,8 +529,12 @@ async function withProbeLock(
   }
 }
 
-// Probes in flight, so a CLI watchdog can stop their browsers before exiting.
-const activeProbeProfiles = new Set();
+// Probes in flight (profile -> spawned browser pid, or null for LaunchServices),
+// so a watchdog, a signal or process exit can stop their browsers first.
+const activeProbes = new Map();
+const PROBE_PROFILE_PREFIX = 'farmslot-browser-probe-';
+const PROBE_PROFILE_OWNER = new RegExp(`^${PROBE_PROFILE_PREFIX}(\\d+)-`, 'u');
+const PROBE_SIGNALS = ['SIGTERM', 'SIGINT', 'SIGHUP', 'SIGQUIT'];
 
 function profilePids(profile) {
   try {
@@ -556,6 +560,72 @@ function killProfile(profile) {
   }
 }
 
+// Synchronous, so it also runs from 'exit' and signal handlers. The browser is
+// outside the caller's process group (LaunchServices parents it; a spawned
+// probe is detached), so a group kill of the caller never reaches it.
+function stopProbe(profile) {
+  const pid = activeProbes.get(profile);
+  try {
+    if (pid) process.kill(-pid, 'SIGKILL');
+  } catch {
+    // Already exited.
+  }
+  killProfile(profile);
+  fs.rmSync(profile, { recursive: true, force: true });
+  activeProbes.delete(profile);
+}
+
+function stopActiveProbes() {
+  for (const profile of [...activeProbes.keys()]) stopProbe(profile);
+}
+
+// A hook timeout sends SIGTERM to the caller's process group. Stop the probe
+// browsers, then let the signal end the process as it would have; a host with
+// its own handler for that signal (a `once` handler is already gone by now, so
+// it is noted at install) keeps control of the exit.
+function onProbeSignal(signal) {
+  stopActiveProbes();
+  const hostHandles = hostSignals.has(signal) || process.listenerCount(signal) > 1;
+  setProbeExitHandlers(false);
+  if (!hostHandles) process.kill(process.pid, signal);
+}
+
+let probeExitHandlers = false;
+let hostSignals = new Set();
+
+function setProbeExitHandlers(on) {
+  if (probeExitHandlers === on) return;
+  probeExitHandlers = on;
+  if (on) hostSignals = new Set(PROBE_SIGNALS.filter((signal) => process.listenerCount(signal)));
+  for (const signal of PROBE_SIGNALS) {
+    if (on) process.on(signal, onProbeSignal);
+    else process.off(signal, onProbeSignal);
+  }
+  if (on) process.on('exit', stopActiveProbes);
+  else process.off('exit', stopActiveProbes);
+}
+
+function trackProbe(profile, pid = null) {
+  activeProbes.set(profile, pid);
+  setProbeExitHandlers(true);
+}
+
+// A resolver killed outright (SIGKILL) cannot clean up. Its profile name
+// carries its pid, so the next probe by the same user stops that browser and
+// removes the profile. Another user's profiles (a shared /tmp) are left alone.
+function reapOrphanedProbes(tmp = os.tmpdir()) {
+  for (const name of fs.readdirSync(tmp)) {
+    const owner = PROBE_PROFILE_OWNER.exec(name);
+    if (!owner || Number(owner[1]) === process.pid || pidAlive(Number(owner[1]))) continue;
+    const profile = path.join(tmp, name);
+    // Another resolver's reaper may have removed it already.
+    const stat = fs.lstatSync(profile, { throwIfNoEntry: false });
+    if (!stat || stat.uid !== process.getuid()) continue;
+    killProfile(profile);
+    fs.rmSync(profile, { recursive: true, force: true });
+  }
+}
+
 // `--version` succeeds even for a build that crashes at startup, so a browser
 // is accepted only when a start answers on DevTools, paints a frame, and
 // survives a settle without dying. The Chrome for Testing crash on macOS 26+
@@ -574,8 +644,9 @@ async function probeLaunch(
   } = {},
 ) {
   const method = effectiveLaunchMethod(executable, launchMethod);
-  const profile = fs.mkdtempSync(path.join(os.tmpdir(), 'farmslot-browser-probe-'));
-  activeProbeProfiles.add(profile);
+  reapOrphanedProbes();
+  const profile = fs.mkdtempSync(path.join(os.tmpdir(), `${PROBE_PROFILE_PREFIX}${process.pid}-`));
+  trackProbe(profile);
   const startedAt = Date.now();
   const verdict = (ok, reason, transient = false) => ({
     ok,
@@ -589,6 +660,8 @@ async function probeLaunch(
   let exited = null;
   try {
     const port = await freePort();
+    // A host that survives a signal resumes here after stopProbe ran.
+    if (!activeProbes.has(profile)) return verdict(false, 'probe stopped by its caller', true);
     // A headful probe starts like the slot browsers (the launchers and the
     // library autolaunch): in the background with no startup window (Chrome
     // activates itself when it opens one); renderCheck opens a background
@@ -615,6 +688,7 @@ async function probeLaunch(
       });
     } else {
       child = spawn(executable, args, { detached: true, stdio: 'ignore' });
+      if (child.pid) trackProbe(profile, child.pid);
       child.on('exit', (code, signal) => {
         exited = signal ?? `code ${code}`;
       });
@@ -624,12 +698,16 @@ async function probeLaunch(
     }
     const alive = () =>
       method === LAUNCH_SERVICES ? profilePids(profile).length > 0 : exited === null;
+    // stopProbe removes the profile: the caller stopped the browser, so its
+    // exit says nothing about the binary.
     const died = (when) =>
-      verdict(
-        false,
-        `exited ${when}${exited ? ` (${exited})` : ''}`,
-        String(exited).startsWith('spawn failed'),
-      );
+      activeProbes.has(profile)
+        ? verdict(
+            false,
+            `exited ${when}${exited ? ` (${exited})` : ''}`,
+            String(exited).startsWith('spawn failed'),
+          )
+        : verdict(false, 'probe stopped by its caller', true);
     let up = false;
     while (!up && Date.now() - startedAt < startupMs) {
       if (exited) return died('during startup');
@@ -655,7 +733,9 @@ async function probeLaunch(
       if (!alive()) return died('after DevTools started');
       await sleep(250);
     }
-    if (await devtoolsAnswers(port)) return verdict(true, 'started and rendered');
+    const answers = await devtoolsAnswers(port);
+    if (!activeProbes.has(profile)) return verdict(false, 'probe stopped by its caller', true);
+    if (answers) return verdict(true, 'started and rendered');
     // Only a proven exit is a property of the binary.
     return alive()
       ? verdict(false, 'DevTools stopped answering after the settle', true)
@@ -663,15 +743,11 @@ async function probeLaunch(
   } catch (error) {
     return verdict(false, `launch failed: ${error.message}`, true);
   } finally {
-    try {
-      if (child?.pid) process.kill(-child.pid, 'SIGKILL');
-    } catch {
-      // Already exited.
-    }
-    killProfile(profile);
+    stopProbe(profile);
+    if (activeProbes.size === 0) setProbeExitHandlers(false);
+    // A dying browser can still write into its profile; remove it once more.
     await sleep(300);
     fs.rmSync(profile, { recursive: true, force: true });
-    activeProbeProfiles.delete(profile);
   }
 }
 
@@ -1093,10 +1169,7 @@ async function main(argv) {
   }
   const args = parseCliArgs(rest);
   const watchdog = setTimeout(() => {
-    for (const profile of activeProbeProfiles) {
-      killProfile(profile);
-      fs.rmSync(profile, { recursive: true, force: true });
-    }
+    stopActiveProbes();
     process.stderr.write(
       `browser-resolver ${command} did not finish within ${CLI_DEADLINE_MS}ms.\n`,
     );
@@ -1200,6 +1273,7 @@ module.exports = {
   probeCacheKey,
   probeLaunch,
   readProbeCache,
+  reapOrphanedProbes,
   renderCheck,
   resolveBrowser,
   withProbeLock,

package/src/network-observer.cjs

@@ -0,0 +1,221 @@
+// network-observer.cjs — network capture for a browser extension: attach to
+// every target of the loaded extension (page, background, service worker) on
+// one browser CDP connection, follow targets as they come and go, and feed
+// their Network events to a recipe-runner CDP broker that owns the captures.
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+  brokerSocketPath,
+  createBrokerClient,
+  createCdpBroker,
+} = require('@farmslot/recipe-runner/cdp-broker');
+
+const {
+  asBrowserCdpTarget,
+  connectBrowserCdp,
+  extensionIdFromCdpTargets,
+} = require('./browser-cdp.cjs');
+
+const DEVICE_ID = 'extension';
+const DEFAULT_TIMEOUT_MS = 10000;
+const EXTENSION_TARGET_TYPES = new Set(['background_page', 'other', 'page', 'service_worker']);
+
+const asRecord = (value) =>
+  value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+
+/**
+ * @param {{ cdpPort: number, runtimeDir: string, connectTimeoutMs?: number, commandTimeoutMs?: number }} options
+ *   `runtimeDir` keys the broker socket; the timeouts bound the CDP connection
+ *   and every command, broker call and capture control.
+ * @returns {Promise<import('@farmslot/adapter-sdk').NetworkCaptureBackend>}
+ */
+async function createExtensionNetworkObserver({
+  cdpPort,
+  runtimeDir,
+  connectTimeoutMs = DEFAULT_TIMEOUT_MS,
+  commandTimeoutMs = DEFAULT_TIMEOUT_MS,
+}) {
+  if (!Number.isInteger(cdpPort) || cdpPort <= 0) {
+    throw new Error('Extension network observation requires a valid CDP port.');
+  }
+
+  const connection = await connectBrowserCdp(cdpPort, {
+    timeoutMs: connectTimeoutMs,
+    commandTimeoutMs,
+  });
+
+  let closed = false;
+  let extensionId = null;
+  let broker = null;
+  const targetSessions = new Map();
+  const attaching = new Set();
+
+  const send = (method, params = {}, sessionId, timeoutMs = commandTimeoutMs) =>
+    connection.send(method, params, sessionId, timeoutMs);
+
+  const relevantTarget = (target) => {
+    if (!extensionId || !EXTENSION_TARGET_TYPES.has(target.type)) return false;
+    try {
+      return new URL(target.url).hostname === extensionId;
+    } catch {
+      return false;
+    }
+  };
+
+  const refreshBrokerSession = () => {
+    if (!broker) return;
+    broker.onSessionClose(DEVICE_ID);
+    broker.onSessionOpen(DEVICE_ID);
+  };
+
+  const attachTarget = async (target) => {
+    if (
+      closed ||
+      !relevantTarget(target) ||
+      targetSessions.has(target.targetId) ||
+      attaching.has(target.targetId)
+    ) {
+      return;
+    }
+    attaching.add(target.targetId);
+    try {
+      const result = asRecord(
+        await send('Target.attachToTarget', { targetId: target.targetId, flatten: true }),
+      );
+      const sessionId = String(result.sessionId ?? '');
+      if (sessionId) {
+        targetSessions.set(target.targetId, sessionId);
+        refreshBrokerSession();
+      }
+    } catch (error) {
+      if (!/already attached/iu.test(String(error))) broker?.onSessionClose(DEVICE_ID);
+    } finally {
+      attaching.delete(target.targetId);
+    }
+  };
+
+  connection.onEvent(({ method, params, sessionId }) => {
+    if (method === 'Target.targetCreated') {
+      const target = asBrowserCdpTarget(params.targetInfo);
+      if (target) void attachTarget(target);
+      return;
+    }
+    if (method === 'Target.attachedToTarget') {
+      const target = asBrowserCdpTarget(params.targetInfo);
+      const attachedSessionId = String(params.sessionId ?? '');
+      if (target && attachedSessionId && relevantTarget(target)) {
+        targetSessions.set(target.targetId, attachedSessionId);
+        refreshBrokerSession();
+      }
+      return;
+    }
+    if (method === 'Target.detachedFromTarget') {
+      const detachedSessionId = String(params.sessionId ?? '');
+      for (const [targetId, activeSessionId] of targetSessions) {
+        if (activeSessionId !== detachedSessionId) continue;
+        targetSessions.delete(targetId);
+        refreshBrokerSession();
+      }
+      return;
+    }
+    if (sessionId && method.startsWith('Network.')) {
+      broker?.onCdpEvent(DEVICE_ID, method, params);
+    }
+  });
+
+  connection.onClose(() => {
+    if (!closed) broker?.onSessionClose(DEVICE_ID);
+  });
+
+  await send('Target.setDiscoverTargets', { discover: true });
+  const targetInfos = asRecord(await send('Target.getTargets')).targetInfos;
+  const targets = Array.isArray(targetInfos) ? targetInfos : [];
+  extensionId = extensionIdFromCdpTargets(targets);
+  if (!extensionId) {
+    connection.close();
+    throw new Error('Extension CDP browser or loaded extension target is unavailable.');
+  }
+  await Promise.all(targets.map(asBrowserCdpTarget).filter(Boolean).map(attachTarget));
+  if (targetSessions.size === 0) {
+    connection.close();
+    throw new Error('Extension CDP exposes no attachable extension targets.');
+  }
+
+  const sessions = new Map([[DEVICE_ID, { brokerReady: true }]]);
+  const socketPath = brokerSocketPath(path.join(runtimeDir, 'extension-network'));
+  broker = createCdpBroker({
+    socketPath,
+    sessions,
+    async sendCommand(_session, method, params, timeoutMs) {
+      const sessionIds = [...new Set(targetSessions.values())];
+      if (sessionIds.length === 0) {
+        throw new Error('Extension CDP has no active extension target sessions.');
+      }
+      const results = await Promise.allSettled(
+        sessionIds.map((sessionId) => send(method, params, sessionId, timeoutMs)),
+      );
+      const successes = results.filter((result) => result.status === 'fulfilled');
+      if (successes.length === 0) {
+        const firstFailure = results.find((result) => result.status === 'rejected');
+        throw new Error(
+          `Extension CDP command failed on every target: ${String(firstFailure?.reason ?? method)}`,
+        );
+      }
+      if (successes.length !== results.length) {
+        results.forEach((result, index) => {
+          if (result.status === 'fulfilled') return;
+          const failedSession = sessionIds[index];
+          for (const [targetId, sessionId] of targetSessions) {
+            if (sessionId === failedSession) targetSessions.delete(targetId);
+          }
+        });
+        broker?.onSessionClose(DEVICE_ID);
+      }
+      return successes[0].value;
+    },
+    requestDiscovery() {
+      void send('Target.getTargets')
+        .then((result) => {
+          const infos = asRecord(result).targetInfos;
+          if (!Array.isArray(infos)) return;
+          for (const value of infos) {
+            const target = asBrowserCdpTarget(value);
+            if (target) void attachTarget(target);
+          }
+        })
+        .catch(() => broker?.onSessionClose(DEVICE_ID));
+    },
+  });
+  broker.onSessionOpen(DEVICE_ID);
+  await waitForSocket(socketPath, commandTimeoutMs);
+  const client = await createBrokerClient(socketPath, DEVICE_ID, commandTimeoutMs);
+
+  return {
+    start(params) {
+      return client.control('capture-start', params, commandTimeoutMs);
+    },
+    async end(id) {
+      return asRecord(await client.control('capture-end', { id }, commandTimeoutMs));
+    },
+    async close() {
+      closed = true;
+      client.close();
+      broker?.close();
+      connection.close();
+    },
+  };
+}
+
+async function waitForSocket(socketPath, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (fs.existsSync(socketPath)) return;
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  throw new Error('Extension network observer broker did not start.');
+}
+
+module.exports = { createExtensionNetworkObserver };

package/src/page-target.cjs

@@ -1,5 +1,7 @@
 'use strict';
 
+const { asBrowserCdpTarget } = require('./browser-cdp.cjs');
+
 // Choose the page a recipe drives from a CDP target list: a page on `origin`,
 // preferring one whose URL carries `hash`. Returns null when no page matches;
 // the caller owns the error it reports.
@@ -22,4 +24,35 @@ function selectPageTarget(targets, { origin, hash = '' }) {
   return pages[0];
 }
 
-module.exports = { selectPageTarget };
+// Choose an extension's UI renderer from a CDP target list (`Target.getTargets`
+// or `/json`): a page or `other` target of `extensionId` whose path is one of
+// `paths`, tried in order. The first path with any match decides: exactly one
+// match is returned, several are ambiguous and return null.
+/**
+ * @param {unknown} targets
+ * @param {string} extensionId
+ * @param {{ paths: readonly string[] }} options
+ * @returns {import('./browser-cdp.cjs').BrowserCdpTarget | null}
+ */
+function selectExtensionTarget(targets, extensionId, { paths }) {
+  const candidates = [];
+  for (const value of Array.isArray(targets) ? targets : []) {
+    const target = asBrowserCdpTarget(value);
+    if (!target || !['page', 'other'].includes(target.type)) continue;
+    try {
+      const url = new URL(target.url);
+      if (url.protocol === 'chrome-extension:' && url.hostname === extensionId) {
+        candidates.push({ target, pathname: url.pathname });
+      }
+    } catch {
+      // Not a URL: not an extension target.
+    }
+  }
+  for (const pathname of paths) {
+    const matches = candidates.filter((candidate) => candidate.pathname === pathname);
+    if (matches.length > 0) return matches.length === 1 ? matches[0].target : null;
+  }
+  return null;
+}
+
+module.exports = { selectExtensionTarget, selectPageTarget };

package/src/performance-observer.cjs

@@ -0,0 +1,94 @@
+// performance-observer.cjs — CDP performance traces of a browser extension's
+// UI renderer: attach to the extension page the host names, write the clock
+// marker there with `performance.mark`, and trace through recipe-runner's
+// CDP trace collector.
+'use strict';
+
+const { connectBrowserCdp } = require('./browser-cdp.cjs');
+const { selectExtensionTarget } = require('./page-target.cjs');
+
+const DEFAULT_TIMEOUT_MS = 10000;
+
+/**
+ * @template {string} [P=string]
+ * @param {{
+ *   cdpPort: number,
+ *   extensionId: string,
+ *   uiPaths: readonly string[],
+ *   kind: import('@farmslot/recipe-runner/runtime/cdp-trace').TraceKind,
+ *   platform: P,
+ *   markerPrefix?: string,
+ *   connectTimeoutMs?: number,
+ *   commandTimeoutMs?: number,
+ * }} options
+ *   `uiPaths` are the extension pages to trace, in order of preference (see
+ *   `selectExtensionTarget`); `kind`, `platform` and `markerPrefix` go to the collector.
+ * @returns {Promise<import('@farmslot/recipe-runner/runtime/cdp-trace').PerformanceBackend<P>>}
+ */
+async function createExtensionPerformanceBackend({
+  cdpPort,
+  extensionId,
+  uiPaths,
+  kind,
+  platform,
+  markerPrefix,
+  connectTimeoutMs = DEFAULT_TIMEOUT_MS,
+  commandTimeoutMs = DEFAULT_TIMEOUT_MS,
+}) {
+  if (!extensionId) {
+    throw new Error('Extension performance observation requires the extension id.');
+  }
+  // Loaded on use: recipe-runner's trace engine is an ES module built to dist,
+  // and the other adapter-web modules must load without it.
+  const { createCdpTraceCollector } = require('@farmslot/recipe-runner/runtime/cdp-trace');
+  const browser = await connectBrowserCdp(cdpPort, {
+    timeoutMs: connectTimeoutMs,
+    commandTimeoutMs,
+  });
+  let sessionId = '';
+  try {
+    const { targetInfos } = await browser.send('Target.getTargets', {});
+    const uiTarget = selectExtensionTarget(targetInfos, extensionId, { paths: uiPaths });
+    if (!uiTarget) {
+      throw new Error('Extension performance observation requires an open extension UI target.');
+    }
+    const attached = await browser.send('Target.attachToTarget', {
+      targetId: uiTarget.targetId,
+      flatten: true,
+    });
+    sessionId = String(attached?.sessionId ?? '');
+    if (!sessionId) {
+      throw new Error(
+        'Extension performance observation could not attach to the extension UI target.',
+      );
+    }
+  } catch (error) {
+    browser.close();
+    throw error;
+  }
+  const client = {
+    send: (method, params = {}, timeoutMs) => browser.send(method, params, undefined, timeoutMs),
+    on: (method, handler) =>
+      browser.onEvent((event) => {
+        if (event.method === method) handler(event.params);
+      }),
+    close: () => browser.close(),
+  };
+  return createCdpTraceCollector(client, {
+    kind,
+    platform,
+    markerPrefix,
+    marker: async (name) => {
+      const before = Date.now();
+      await browser.send(
+        'Runtime.evaluate',
+        { expression: `performance.mark(${JSON.stringify(name)})`, returnByValue: true },
+        sessionId,
+      );
+      const after = Date.now();
+      return { hostEpochMs: (before + after) / 2, uncertaintyMs: (after - before) / 2 };
+    },
+  });
+}
+
+module.exports = { createExtensionPerformanceBackend };