npm - @yeaft/webchat-agent - Versions diffs - 1.0.413 → 1.0.415 - Mend

@yeaft/webchat-agent 1.0.413 → 1.0.415

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

package/browser-runtime/browser-install.js +497 -0
package/browser-runtime/cli.js +88 -0
package/browser-runtime/config.js +116 -0
package/browser-runtime/errors.js +8 -0
package/browser-runtime/extension/manifest.json +18 -0
package/browser-runtime/extension/offscreen.html +5 -0
package/browser-runtime/extension/offscreen.js +101 -0
package/browser-runtime/extension/popup.html +5 -0
package/browser-runtime/extension/popup.js +1 -0
package/browser-runtime/extension/service-worker.js +48 -0
package/browser-runtime/extension.js +45 -0
package/browser-runtime/index.js +5 -0
package/browser-runtime/probe.js +427 -0
package/browser-runtime/protocol.js +71 -0
package/browser-runtime/service.js +132 -0
package/browser-runtime/windows-version-job.ps1 +233 -0
package/browser-runtime/windows-version-worker.js +75 -0
package/browser-runtime/windows-version.js +85 -0
package/cli.js +24 -7
package/connection/index.js +12 -0
package/context.js +1 -0
package/index.js +19 -2
package/llm-config-cli.js +24 -21
package/local-runtime/server/client-protocol.js +14 -0
package/local-runtime/server/context.js +3 -2
package/local-runtime/server/handlers/agent-file-terminal.js +185 -115
package/local-runtime/server/handlers/agent-output.js +3 -0
package/local-runtime/server/handlers/client-misc.js +21 -4
package/local-runtime/server/handlers/client-workbench.js +222 -41
package/local-runtime/server/workbench-correlation.js +184 -0
package/local-runtime/server/workbench-route.js +180 -0
package/local-runtime/server/ws-agent.js +4 -0
package/local-runtime/server/ws-client.js +25 -3
package/local-runtime/version.json +1 -1
package/local-runtime/web/app.bundle.js +191 -135
package/local-runtime/web/app.bundle.js.gz +0 -0
package/local-runtime/web/index.html +2 -2
package/local-runtime/web/style.bundle.css +1 -1
package/local-runtime/web/style.bundle.css.gz +0 -0
package/package.json +5 -1
package/service/config.js +23 -2
package/service/index.js +1 -0
package/service/linux.js +3 -2
package/terminal.js +167 -30
package/workbench/file-ops.js +21 -20
package/workbench/file-search.js +4 -3
package/workbench/git-ops.js +23 -22
package/workbench/request-routing.js +16 -0
package/yeaft/cli.js +57 -1
package/yeaft/config-api.js +138 -192
package/yeaft/config-store.js +192 -0
package/yeaft/config.js +3 -0
package/yeaft/init.js +20 -7
package/yeaft/sessions/feature-flag.js +15 -33
package/yeaft/sessions/session-manifest.js +114 -10
package/yeaft/stdio-protocol.js +57 -0
package/yeaft/storage/atomic.js +43 -17
package/yeaft/tools/process-runner.js +86 -13

package/browser-runtime/errors.js ADDED Viewed

@@ -0,0 +1,8 @@
+export class BrowserRuntimeError extends Error {
+  constructor(code, message = code, details = null) {
+    super(message);
+    this.name = 'BrowserRuntimeError';
+    this.code = code;
+    this.details = details;
+  }
+}

package/browser-runtime/extension/manifest.json ADDED Viewed

@@ -0,0 +1,18 @@
+{
+  "manifest_version": 3,
+  "name": "Yeaft Browser Runtime",
+  "version": "1.0.0",
+  "minimum_chrome_version": "151",
+  "background": {
+    "service_worker": "service-worker.js"
+  },
+  "action": {
+    "default_title": "Yeaft Browser Runtime",
+    "default_popup": "popup.html"
+  },
+  "permissions": [
+    "offscreen",
+    "storage",
+    "tabCapture"
+  ]
+}

package/browser-runtime/extension/offscreen.html ADDED Viewed

@@ -0,0 +1,5 @@
+<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>Yeaft Browser Runtime Peer</title></head>
+<body><video id="probe-video" muted autoplay playsinline></video><script src="offscreen.js"></script></body>
+</html>

package/browser-runtime/extension/offscreen.js ADDED Viewed

@@ -0,0 +1,101 @@
+const PROBE_TIMEOUT_MS = 5_000;
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function inboundVideoStats(peer) {
+  const stats = await peer.getStats();
+  for (const report of stats.values()) {
+    if (report.type === 'inbound-rtp' && (report.kind === 'video' || report.mediaType === 'video')) {
+      const codec = stats.get(report.codecId);
+      return {
+        bytesReceived: Number(report.bytesReceived) || 0,
+        framesDecoded: Number(report.framesDecoded) || 0,
+        framesReceived: Number(report.framesReceived) || 0,
+        frameWidth: Number(report.frameWidth) || 0,
+        frameHeight: Number(report.frameHeight) || 0,
+        codec: typeof codec?.mimeType === 'string' ? codec.mimeType : null,
+      };
+    }
+  }
+  return null;
+}
+async function runMediaProbe(streamId) {
+  let stream = null;
+  let offerer = null;
+  let answerer = null;
+  try {
+    stream = await navigator.mediaDevices.getUserMedia({
+      audio: false,
+      video: {
+        mandatory: {
+          chromeMediaSource: 'tab',
+          chromeMediaSourceId: streamId,
+        },
+      },
+    });
+    const track = stream.getVideoTracks()[0];
+    if (!track) throw new Error('tab capture returned no video track');
+    offerer = new RTCPeerConnection();
+    answerer = new RTCPeerConnection();
+    offerer.onicecandidate = event => event.candidate && answerer.addIceCandidate(event.candidate);
+    answerer.onicecandidate = event => event.candidate && offerer.addIceCandidate(event.candidate);
+    const video = document.querySelector('#probe-video');
+    answerer.ontrack = event => {
+      video.srcObject = event.streams[0] || new MediaStream([event.track]);
+    };
+    const sender = offerer.addTrack(track, stream);
+    const vp8 = RTCRtpSender.getCapabilities('video')?.codecs
+      ?.filter(codec => codec.mimeType?.toLowerCase() === 'video/vp8') || [];
+    if (vp8.length === 0) throw new Error('VP8 encoder capability unavailable');
+    const transceiver = offerer.getTransceivers().find(item => item.sender === sender);
+    transceiver?.setCodecPreferences(vp8);
+    await offerer.setLocalDescription(await offerer.createOffer());
+    await answerer.setRemoteDescription(offerer.localDescription);
+    await answerer.setLocalDescription(await answerer.createAnswer());
+    await offerer.setRemoteDescription(answerer.localDescription);
+    await video.play().catch(() => {});
+    const deadline = Date.now() + PROBE_TIMEOUT_MS;
+    let media = null;
+    while (Date.now() < deadline) {
+      media = await inboundVideoStats(answerer);
+      if (media?.framesDecoded > 0) break;
+      await sleep(100);
+    }
+    if (!media || media.framesDecoded < 1) throw new Error('WebRTC decoded no tab-capture frame');
+    if (media.codec?.toLowerCase() !== 'video/vp8') throw new Error(`unexpected negotiated codec: ${media.codec || 'unknown'}`);
+    const settings = track.getSettings?.() || {};
+    return {
+      ok: true,
+      captureMode: 'tab',
+      codecBaseline: media.codec,
+      width: Number(settings.width) || media.frameWidth || 0,
+      height: Number(settings.height) || media.frameHeight || 0,
+      frameRate: Number(settings.frameRate) || 0,
+      framesDecoded: media.framesDecoded,
+      bytesReceived: media.bytesReceived,
+    };
+  } finally {
+    stream?.getTracks().forEach(track => track.stop());
+    offerer?.close();
+    answerer?.close();
+    const video = document.querySelector('#probe-video');
+    if (video) video.srcObject = null;
+  }
+}
+chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+  if (message?.target !== 'browser_runtime_offscreen'
+      || message?.type !== 'browser_runtime_probe_media') return undefined;
+  runMediaProbe(message.streamId).then(sendResponse, error => sendResponse({
+    ok: false,
+    code: 'media_probe_failed',
+    safeError: String(error?.message || error).slice(0, 500),
+  }));
+  return true;
+});

package/browser-runtime/extension/popup.html ADDED Viewed

@@ -0,0 +1,5 @@
+<!doctype html>
+<html lang="en">
+<head><meta charset="utf-8"><title>Yeaft Browser Runtime</title></head>
+<body><script src="popup.js"></script></body>
+</html>

package/browser-runtime/extension/popup.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ chrome.runtime.sendMessage({ type: 'browser_runtime_probe_start' }).catch(() => {});

package/browser-runtime/extension/service-worker.js ADDED Viewed

@@ -0,0 +1,48 @@
+const OFFSCREEN_PATH = 'offscreen.html';
+let offscreenCreation = null;
+async function ensureOffscreenDocument() {
+  const documentUrl = chrome.runtime.getURL(OFFSCREEN_PATH);
+  const contexts = await chrome.runtime.getContexts({
+    contextTypes: ['OFFSCREEN_DOCUMENT'],
+    documentUrls: [documentUrl],
+  });
+  if (contexts.length > 0) return;
+  if (!offscreenCreation) {
+    offscreenCreation = chrome.offscreen.createDocument({
+      url: OFFSCREEN_PATH,
+      reasons: ['USER_MEDIA', 'WEB_RTC'],
+      justification: 'Capture the controlled tab and validate the Browser Runtime WebRTC media path',
+    }).finally(() => { offscreenCreation = null; });
+  }
+  await offscreenCreation;
+}
+async function runStartupProbe() {
+  const [tab] = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+  if (!tab?.id) throw new Error('active tab unavailable');
+  const streamId = await chrome.tabCapture.getMediaStreamId({ targetTabId: tab.id });
+  await ensureOffscreenDocument();
+  return chrome.runtime.sendMessage({
+    target: 'browser_runtime_offscreen',
+    type: 'browser_runtime_probe_media',
+    streamId,
+  });
+}
+chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+  if (message?.type !== 'browser_runtime_probe_start') return undefined;
+  runStartupProbe().then(async result => {
+    await chrome.storage.session.set({ browserRuntimeProbe: result });
+    sendResponse(result);
+  }, async error => {
+    const result = {
+      ok: false,
+      code: 'capture_probe_failed',
+      safeError: String(error?.message || error).slice(0, 500),
+    };
+    await chrome.storage.session.set({ browserRuntimeProbe: result });
+    sendResponse(result);
+  });
+  return true;
+});

package/browser-runtime/extension.js ADDED Viewed

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+export const BROWSER_EXTENSION_DIR = join(moduleDir, 'extension');
+export const BROWSER_EXTENSION_NAME = 'Yeaft Browser Runtime';
+export const BROWSER_EXTENSION_SHA256 = '51cc6519ec9f72f86af7a0a98c3511c32e0e8fde6e8e3406886e7048f0c5972e';
+async function walkFiles(root, current = root) {
+  const entries = await readdir(current, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const path = join(current, entry.name);
+    if (entry.isDirectory()) files.push(...await walkFiles(root, path));
+    else if (entry.isFile()) files.push(path);
+  }
+  return files;
+}
+/**
+ * Hash the exact extension package before loading it. The digest is diagnostic
+ * evidence and a tamper fence, not a substitute for package signing.
+ */
+export async function hashBrowserExtension(root = BROWSER_EXTENSION_DIR, { expectedDigest = null } = {}) {
+  const directory = await stat(root);
+  if (!directory.isDirectory()) throw new Error('Browser Runtime extension path is not a directory');
+  const hash = createHash('sha256');
+  const files = (await walkFiles(root)).sort();
+  if (files.length === 0) throw new Error('Browser Runtime extension is empty');
+  for (const path of files) {
+    const name = relative(root, path).replaceAll('\\', '/');
+    const data = await readFile(path);
+    hash.update(`${name}\0${data.byteLength}\0`);
+    hash.update(data);
+  }
+  const digest = hash.digest('hex');
+  if (expectedDigest && digest !== expectedDigest) {
+    const error = new Error('Browser Runtime extension digest mismatch');
+    error.code = 'extension_digest_mismatch';
+    throw error;
+  }
+  return { digest, fileCount: files.length, root };
+}

package/browser-runtime/index.js ADDED Viewed

@@ -0,0 +1,5 @@
+export { BrowserRuntimeService, bootBrowserRuntime, getBrowserRuntime, shutdownBrowserRuntime } from './service.js';
+export { probeBrowserRuntime } from './probe.js';
+export { installManagedBrowser, findManagedBrowser, defaultBrowserCacheDir, BROWSER_RUNTIME_CHROME_BUILD } from './browser-install.js';
+export { normaliseBrowserRuntimeSection, validateBrowserRuntimeUpdate } from './config.js';
+export { ProducerSequenceState } from './protocol.js';

package/browser-runtime/probe.js ADDED Viewed

@@ -0,0 +1,427 @@
+import { mkdir, mkdtemp, readdir, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  BROWSER_RUNTIME_CHROME_BUILD,
+  readBrowserExecutableVersion,
+  resolveBrowserExecutable,
+} from './browser-install.js';
+import {
+  hashBrowserExtension,
+  BROWSER_EXTENSION_DIR,
+  BROWSER_EXTENSION_NAME,
+  BROWSER_EXTENSION_SHA256,
+} from './extension.js';
+import { BrowserRuntimeError } from './errors.js';
+const PROBE_PAGE = 'data:text/html,<style>body{margin:0;background:%2309637d;color:white;font:48px sans-serif}</style><main>Yeaft Browser Runtime</main>';
+const PROFILE_STALE_MS = 30 * 60_000;
+const CLEANUP_GRACE_MS = 250;
+const VERSION_PROCESS_FORCE_MS = 500;
+function abortError(signal) {
+  const reason = signal?.reason;
+  if (reason instanceof BrowserRuntimeError) return reason;
+  return new BrowserRuntimeError(
+    'browser_probe_aborted',
+    reason instanceof Error ? reason.message : 'Browser Runtime probe aborted',
+  );
+}
+function deadlineError() {
+  return new BrowserRuntimeError('browser_probe_timeout', 'Browser Runtime probe exceeded its total deadline');
+}
+function remaining(deadline) {
+  const value = deadline - Date.now();
+  if (value <= 0) throw deadlineError();
+  return value;
+}
+function raceBoundary(promise, { deadline, signal, code = 'browser_probe_timeout' }) {
+  if (signal?.aborted) return Promise.reject(abortError(signal));
+  const timeoutMs = remaining(deadline);
+  let timer;
+  let abortHandler;
+  const boundary = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new BrowserRuntimeError(
+      code,
+      `Browser Runtime probe exceeded its total deadline after ${timeoutMs}ms`,
+    )), timeoutMs);
+    abortHandler = () => reject(abortError(signal));
+    signal?.addEventListener('abort', abortHandler, { once: true });
+  });
+  return Promise.race([Promise.resolve(promise), boundary]).finally(() => {
+    clearTimeout(timer);
+    if (abortHandler) signal?.removeEventListener('abort', abortHandler);
+  });
+}
+function delay(ms, boundary) {
+  return raceBoundary(new Promise(resolve => setTimeout(resolve, ms)), boundary);
+}
+function actualChromeBuild(version) {
+  const match = String(version || '').match(/(?:Chrome(?:\s+for\s+Testing)?|Chromium)(?:\/|\s+)(\d+(?:\.\d+){0,3})/i);
+  return match?.[1] || null;
+}
+async function readProbeResult(worker, boundary) {
+  for (;;) {
+    const result = await raceBoundary(worker.evaluate(() => {
+      const storage = globalThis.chrome?.storage?.session;
+      return storage ? storage.get('browserRuntimeProbe') : null;
+    }), { ...boundary, code: 'probe_result_timeout' });
+    if (result?.browserRuntimeProbe) return result.browserRuntimeProbe;
+    await delay(100, boundary);
+  }
+}
+function browserProcess(browser) {
+  try { return browser?.process?.() || null; } catch { return null; }
+}
+function forceKillBrowser(browser) {
+  const child = browserProcess(browser);
+  if (!child || child.exitCode !== null) return child;
+  try {
+    if (process.platform !== 'win32' && Number.isInteger(child.pid)) process.kill(-child.pid, 'SIGKILL');
+    else child.kill('SIGKILL');
+  } catch {
+    try { child.kill('SIGKILL'); } catch {}
+  }
+  return child;
+}
+async function settleWithin(promise, { deadline, signal, maxWaitMs = CLEANUP_GRACE_MS }) {
+  if (signal?.aborted) return false;
+  const budget = Math.min(maxWaitMs, Math.max(0, deadline - Date.now()));
+  if (budget <= 0) return false;
+  let timer;
+  let abortHandler;
+  try {
+    return await Promise.race([
+      Promise.resolve(promise).catch(() => false),
+      new Promise(resolve => { timer = setTimeout(() => resolve(false), budget); }),
+      new Promise(resolve => {
+        abortHandler = () => resolve(false);
+        signal?.addEventListener('abort', abortHandler, { once: true });
+      }),
+    ]);
+  } finally {
+    clearTimeout(timer);
+    if (abortHandler) signal?.removeEventListener('abort', abortHandler);
+  }
+}
+async function waitForProcessExit(child, boundary) {
+  if (!child || child.exitCode !== null) return true;
+  if (typeof child.once !== 'function') return false;
+  const exited = new Promise(resolve => {
+    const onExit = () => {
+      child.off?.('exit', onExit);
+      child.off?.('close', onExit);
+      resolve(true);
+    };
+    child.once('exit', onExit);
+    child.once('close', onExit);
+    if (child.exitCode !== null) onExit();
+  });
+  return settleWithin(exited, boundary);
+}
+async function cleanupBrowser(browser, profileDir, boundary, removeProfile = rm) {
+  if (browser) {
+    let closeCompletion;
+    try {
+      closeCompletion = Promise.resolve(browser.close()).then(() => true, () => false);
+    } catch {
+      closeCompletion = Promise.resolve(false);
+    }
+    const closed = await settleWithin(closeCompletion, boundary);
+    if (!closed) {
+      const child = forceKillBrowser(browser);
+      if (Math.max(0, boundary.deadline - Date.now()) > 0) {
+        await waitForProcessExit(child, boundary);
+      }
+    }
+  }
+  if (profileDir) {
+    let removal;
+    try {
+      removal = Promise.resolve(removeProfile(profileDir, { recursive: true, force: true }))
+        .then(() => true, () => false);
+    } catch {
+      removal = Promise.resolve(false);
+    }
+    if (!await settleWithin(removal, boundary)) removal.catch(() => {});
+  }
+}
+function baseResult(startedAt, extension, actualBuildId = null) {
+  return {
+    expectedBuildId: BROWSER_RUNTIME_CHROME_BUILD,
+    actualBuildId,
+    ...(extension ? {
+      extensionDigest: extension.digest,
+      extensionFileCount: extension.fileCount,
+    } : {}),
+    durationMs: Date.now() - startedAt,
+  };
+}
+/**
+ * Launch an isolated Chrome for Testing process and prove the complete primary
+ * media path under one total deadline. The profile and process are owned until
+ * cleanup finishes, including late launch completion after timeout/abort.
+ */
+export async function probeBrowserRuntime({
+  executablePath = null,
+  cacheDir,
+  headless = true,
+  timeoutMs = 20_000,
+  extensionDir = BROWSER_EXTENSION_DIR,
+  expectedExtensionDigest = extensionDir === BROWSER_EXTENSION_DIR ? BROWSER_EXTENSION_SHA256 : null,
+  launch = null,
+  signal = null,
+  resolveExecutable = resolveBrowserExecutable,
+  versionCheck = readBrowserExecutableVersion,
+  hashExtension = hashBrowserExtension,
+  createProfile = mkdtemp,
+  removeProfile = rm,
+  profileParent = tmpdir(),
+} = {}) {
+  const startedAt = Date.now();
+  const deadline = startedAt + Math.max(1, Number(timeoutMs) || 1);
+  const deadlineController = new AbortController();
+  const deadlineTimer = setTimeout(() => deadlineController.abort(deadlineError()), Math.max(1, deadline - Date.now()));
+  const probeController = new AbortController();
+  const abortProbe = reason => {
+    if (!probeController.signal.aborted) probeController.abort(reason);
+  };
+  const abortFromCaller = () => abortProbe(signal?.reason || abortError(signal));
+  const abortFromDeadline = () => abortProbe(deadlineController.signal.reason || deadlineError());
+  signal?.addEventListener('abort', abortFromCaller, { once: true });
+  deadlineController.signal.addEventListener('abort', abortFromDeadline, { once: true });
+  if (signal?.aborted) abortFromCaller();
+  const boundarySignal = probeController.signal;
+  let extension = null;
+  let actualBuildId = null;
+  let profileDir = null;
+  let browser = null;
+  let launchPromise = null;
+  let launchBoundaryFailed = false;
+  try {
+    boundarySignal.throwIfAborted();
+    const resolvedExecutable = await raceBoundary(
+      resolveExecutable({ executablePath, cacheDir }),
+      { deadline, signal: boundarySignal, code: 'browser_executable_timeout' },
+    );
+    if (!resolvedExecutable) {
+      return {
+        ok: false,
+        code: 'browser_executable_missing',
+        ...baseResult(startedAt, null),
+      };
+    }
+    let version;
+    const versionTerminationDeadline = deadline + VERSION_PROCESS_FORCE_MS;
+    const versionPromise = Promise.resolve().then(() => versionCheck(resolvedExecutable, {
+      signal: boundarySignal,
+      gracefulTerminationDeadline: deadline,
+      terminationDeadline: versionTerminationDeadline,
+    }));
+    try {
+      version = await raceBoundary(
+        versionPromise,
+        { deadline, signal: boundarySignal, code: 'browser_version_timeout' },
+      );
+    } catch (error) {
+      if (!boundarySignal.aborted) abortProbe(error);
+      await Promise.race([
+        versionPromise.catch(() => {}),
+        new Promise(resolve => setTimeout(
+          resolve,
+          Math.max(0, versionTerminationDeadline - Date.now()),
+        )),
+      ]);
+      throw error;
+    } finally {
+      if (Date.now() >= deadline && !boundarySignal.aborted) abortProbe(deadlineError());
+    }
+    actualBuildId = actualChromeBuild(version);
+    if (actualBuildId !== BROWSER_RUNTIME_CHROME_BUILD) {
+      throw new BrowserRuntimeError(
+        'browser_version_mismatch',
+        `Browser Runtime requires Chrome ${BROWSER_RUNTIME_CHROME_BUILD}, got ${version || 'unknown'}`,
+      );
+    }
+    extension = await raceBoundary(
+      hashExtension(extensionDir, { expectedDigest: expectedExtensionDigest }),
+      { deadline, signal: boundarySignal, code: 'extension_probe_timeout' },
+    );
+    await raceBoundary(mkdir(profileParent, { recursive: true, mode: 0o700 }), {
+      deadline,
+      signal: boundarySignal,
+      code: 'probe_profile_timeout',
+    });
+    if (timeoutMs >= 1_000) {
+      const profiles = await raceBoundary(readdir(profileParent, { withFileTypes: true }), {
+        deadline,
+        signal: boundarySignal,
+        code: 'probe_profile_timeout',
+      });
+      await raceBoundary(Promise.all(profiles
+        .filter(entry => entry.isDirectory() && entry.name.startsWith('probe-'))
+        .map(async entry => {
+          const profilePath = join(profileParent, entry.name);
+          const details = await stat(profilePath);
+          if (Date.now() - details.mtimeMs > PROFILE_STALE_MS) {
+            await rm(profilePath, { recursive: true, force: true });
+          }
+        })), { deadline, signal: boundarySignal, code: 'probe_profile_timeout' });
+    }
+    profileDir = await raceBoundary(
+      createProfile(join(profileParent, 'probe-')),
+      { deadline, signal: boundarySignal, code: 'probe_profile_timeout' },
+    );
+    const launchBrowser = launch || (await raceBoundary(
+      import('puppeteer-core').then(module => module.default.launch),
+      { deadline, signal: boundarySignal, code: 'browser_launch_import_timeout' },
+    ));
+    const launchTimeout = remaining(deadline);
+    launchPromise = Promise.resolve(launchBrowser({
+      executablePath: resolvedExecutable,
+      headless,
+      userDataDir: profileDir,
+      acceptInsecureCerts: false,
+      timeout: launchTimeout,
+      protocolTimeout: launchTimeout,
+      signal: boundarySignal,
+      args: [
+        `--disable-extensions-except=${extensionDir}`,
+        `--load-extension=${extensionDir}`,
+        '--disable-background-networking',
+        '--disable-component-update',
+        '--disable-default-apps',
+        '--disable-features=MediaRouter,Translate',
+        '--disable-sync',
+        '--no-first-run',
+      ],
+    }));
+    try {
+      browser = await raceBoundary(launchPromise, { deadline, signal: boundarySignal, code: 'browser_launch_timeout' });
+    } catch (error) {
+      launchBoundaryFailed = true;
+      throw error;
+    }
+    const launchedVersion = await raceBoundary(browser.version(), {
+      deadline,
+      signal: boundarySignal,
+      code: 'browser_version_timeout',
+    });
+    const launchedBuildId = actualChromeBuild(launchedVersion);
+    if (launchedBuildId !== actualBuildId) {
+      throw new BrowserRuntimeError(
+        'browser_version_mismatch',
+        `Browser Runtime executable changed after preflight: expected ${actualBuildId}, got ${launchedVersion || 'unknown'}`,
+      );
+    }
+    const page = await raceBoundary(browser.newPage(), {
+      deadline,
+      signal: boundarySignal,
+      code: 'probe_page_create_timeout',
+    });
+    await raceBoundary(page.goto(PROBE_PAGE, {
+      waitUntil: 'domcontentloaded',
+      timeout: remaining(deadline),
+    }), { deadline, signal: boundarySignal, code: 'probe_page_timeout' });
+    let installed = null;
+    while (!installed) {
+      const extensions = await raceBoundary(browser.extensions(), {
+        deadline,
+        signal: boundarySignal,
+        code: 'extension_list_timeout',
+      });
+      installed = [...extensions.values()].find(candidate => candidate.name === BROWSER_EXTENSION_NAME) || null;
+      if (!installed) await delay(100, { deadline, signal: boundarySignal });
+    }
+    await raceBoundary(page.triggerExtensionAction(installed), {
+      deadline,
+      signal: boundarySignal,
+      code: 'extension_action_timeout',
+    });
+    const workerTarget = await raceBoundary(browser.waitForTarget(target => (
+      target.type() === 'service_worker' && target.url().startsWith(`chrome-extension://${installed.id}/`)
+    ), { timeout: remaining(deadline), signal: boundarySignal }), {
+      deadline,
+      signal: boundarySignal,
+      code: 'extension_worker_timeout',
+    });
+    const worker = await raceBoundary(workerTarget.worker(), {
+      deadline,
+      signal: boundarySignal,
+      code: 'extension_worker_timeout',
+    });
+    if (!worker) throw new BrowserRuntimeError('extension_worker_missing', 'Browser Runtime extension worker unavailable');
+    const media = await readProbeResult(worker, { deadline, signal: boundarySignal });
+    if (media.ok !== true || media.framesDecoded < 1) {
+      throw new BrowserRuntimeError(media.code || 'media_probe_failed', media.safeError || 'Browser Runtime media probe failed');
+    }
+    return {
+      ok: true,
+      executablePath: resolvedExecutable,
+      captureMode: media.captureMode,
+      codecBaseline: media.codecBaseline,
+      width: media.width,
+      height: media.height,
+      frameRate: media.frameRate,
+      framesDecoded: media.framesDecoded,
+      ...baseResult(startedAt, extension, actualBuildId),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      code: error?.code || (signal?.aborted ? 'browser_probe_aborted' : 'browser_probe_failed'),
+      safeError: String(error?.message || error).slice(0, 500),
+      ...baseResult(startedAt, extension, actualBuildId),
+    };
+  } finally {
+    clearTimeout(deadlineTimer);
+    signal?.removeEventListener('abort', abortFromCaller);
+    deadlineController.signal.removeEventListener('abort', abortFromDeadline);
+    if (!browser && launchBoundaryFailed && launchPromise) {
+      const lateBudget = Math.min(CLEANUP_GRACE_MS, Math.max(0, deadline - Date.now()));
+      if (lateBudget > 0) {
+        try {
+          browser = await Promise.race([
+            launchPromise,
+            new Promise(resolve => setTimeout(() => resolve(null), lateBudget)),
+          ]);
+        } catch {}
+      }
+    }
+    await cleanupBrowser(browser, profileDir, {
+      deadline,
+      signal: (signal?.aborted || Date.now() >= deadline) ? boundarySignal : null,
+    }, removeProfile);
+    if (!browser && launchBoundaryFailed && launchPromise) {
+      launchPromise.then(lateBrowser => {
+        forceKillBrowser(lateBrowser);
+        void cleanupBrowser(lateBrowser, profileDir, {
+          deadline: Date.now(),
+          signal: boundarySignal,
+        }, removeProfile);
+      }, () => {});
+    }
+  }
+}