@browserbridge/bbx 1.12.5 → 1.14.0

package/packages/protocol/src/emulation.js

@@ -0,0 +1,155 @@
+// @ts-check
+
+import { BridgeError, ERROR_CODES } from './errors.js';
+
+/** @typedef {import('./workflows.js').EmulationConfig} EmulationConfig */
+
+/** Metrics presets deliberately do not impersonate a different browser engine. */
+export const DEVICE_PRESETS = Object.freeze({
+  phone: { width: 390, height: 844, deviceScaleFactor: 3, mobile: true, touch: true },
+  tablet: { width: 820, height: 1180, deviceScaleFactor: 2, mobile: true, touch: true },
+  desktop: { width: 1280, height: 800, deviceScaleFactor: 1, mobile: false, touch: false },
+});
+
+export const NETWORK_PRESETS = Object.freeze({
+  offline: { offline: true, latencyMs: 0, downloadKbps: 0, uploadKbps: 0 },
+  'slow-3g': { offline: false, latencyMs: 2000, downloadKbps: 400, uploadKbps: 400 },
+  'fast-3g': { offline: false, latencyMs: 563, downloadKbps: 1440, uploadKbps: 675 },
+  wifi: { offline: false, latencyMs: 2, downloadKbps: 30000, uploadKbps: 15000 },
+  unthrottled: { offline: false, latencyMs: 0, downloadKbps: -1, uploadKbps: -1 },
+});
+
+/** @param {string} message @returns {never} */
+export function invalidWorkflow(message) {
+  throw new BridgeError(ERROR_CODES.INVALID_REQUEST, message);
+}
+
+/** @param {unknown} value @param {string} name @returns {Record<string, unknown>} */
+export function objectParam(value, name) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    invalidWorkflow(`${name} must be an object.`);
+  }
+  return /** @type {Record<string, unknown>} */ (value);
+}
+
+/** @param {unknown} value @param {string} name @param {number} min @param {number} max @returns {number} */
+export function numberParam(value, name, min, max) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < min || value > max) {
+    invalidWorkflow(`${name} must be between ${min} and ${max}.`);
+  }
+  return value;
+}
+
+/** @param {unknown} value @param {string} name @param {number} [max] @returns {string} */
+export function stringParam(value, name, max = 256) {
+  if (
+    typeof value !== 'string' ||
+    !value.length ||
+    value.length > max ||
+    [...value].some((character) => character.charCodeAt(0) < 32)
+  ) {
+    invalidWorkflow(
+      `${name} must be a nonempty string of at most ${max} characters without control characters.`
+    );
+  }
+  return value;
+}
+
+/** @param {unknown} value @param {string} name @returns {boolean} */
+export function booleanParam(value, name) {
+  if (typeof value !== 'boolean') invalidWorkflow(`${name} must be boolean.`);
+  return value;
+}
+
+/** @param {Record<string, unknown>} value @param {string[]} keys */
+export function onlyKeys(value, keys) {
+  const unknown = Object.keys(value).find((key) => !keys.includes(key));
+  if (unknown) invalidWorkflow(`Unknown parameter: ${unknown}.`);
+}
+
+/** Validate once at the shared boundary; repeated normalization is idempotent.
+ * @param {Record<string, unknown>} params @returns {EmulationConfig} */
+export function normalizeEmulation(params) {
+  onlyKeys(params, ['device', 'network', 'cpuRate', 'locale', 'timezoneId', 'geolocation']);
+  /** @type {EmulationConfig} */
+  const config = {};
+  if (params.device !== undefined) {
+    const input =
+      typeof params.device === 'string'
+        ? { preset: params.device }
+        : objectParam(params.device, 'device');
+    onlyKeys(input, ['preset', 'width', 'height', 'deviceScaleFactor', 'mobile', 'touch']);
+    const preset =
+      input.preset === undefined
+        ? {}
+        : Object.hasOwn(DEVICE_PRESETS, String(input.preset))
+          ? DEVICE_PRESETS[/** @type {keyof typeof DEVICE_PRESETS} */ (input.preset)]
+          : null;
+    if (!preset) invalidWorkflow('device.preset must be phone, tablet, or desktop.');
+    /** @type {Record<string, unknown>} */
+    const device = { ...preset, ...input };
+    config.device = {
+      width: Math.round(numberParam(device.width, 'width', 1, 8192)),
+      height: Math.round(numberParam(device.height, 'height', 1, 8192)),
+      deviceScaleFactor: numberParam(device.deviceScaleFactor ?? 1, 'deviceScaleFactor', 0.1, 4),
+      mobile: booleanParam(device.mobile ?? false, 'mobile'),
+      touch: booleanParam(device.touch ?? device.mobile ?? false, 'touch'),
+    };
+  }
+  if (params.network !== undefined) {
+    const input =
+      typeof params.network === 'string'
+        ? { preset: params.network }
+        : objectParam(params.network, 'network');
+    onlyKeys(input, ['preset', 'offline', 'latencyMs', 'downloadKbps', 'uploadKbps']);
+    const preset =
+      input.preset === undefined
+        ? NETWORK_PRESETS.unthrottled
+        : Object.hasOwn(NETWORK_PRESETS, String(input.preset))
+          ? NETWORK_PRESETS[/** @type {keyof typeof NETWORK_PRESETS} */ (input.preset)]
+          : null;
+    if (!preset)
+      invalidWorkflow(
+        'Unknown network preset. Use offline, slow-3g, fast-3g, wifi, or unthrottled.'
+      );
+    const network = { ...preset, ...input };
+    config.network = {
+      offline: booleanParam(network.offline, 'offline'),
+      latencyMs: numberParam(network.latencyMs, 'latencyMs', 0, 60000),
+      downloadKbps: numberParam(network.downloadKbps, 'downloadKbps', -1, 10000000),
+      uploadKbps: numberParam(network.uploadKbps, 'uploadKbps', -1, 10000000),
+    };
+    for (const speed of [config.network.downloadKbps, config.network.uploadKbps]) {
+      if (speed < 0 && speed !== -1)
+        invalidWorkflow('Throughput must be nonnegative or -1 for unthrottled.');
+    }
+  }
+  if (params.cpuRate !== undefined) config.cpuRate = numberParam(params.cpuRate, 'cpuRate', 1, 100);
+  if (params.locale !== undefined) {
+    config.locale = stringParam(params.locale, 'locale', 80);
+    try {
+      Intl.getCanonicalLocales(config.locale);
+    } catch {
+      invalidWorkflow('Invalid locale.');
+    }
+  }
+  if (params.timezoneId !== undefined) {
+    config.timezoneId = stringParam(params.timezoneId, 'timezoneId', 100);
+    try {
+      new Intl.DateTimeFormat('en', { timeZone: config.timezoneId });
+    } catch {
+      invalidWorkflow('Invalid timezoneId.');
+    }
+  }
+  if (params.geolocation !== undefined) {
+    const geo = objectParam(params.geolocation, 'geolocation');
+    onlyKeys(geo, ['latitude', 'longitude', 'accuracy']);
+    config.geolocation = {
+      latitude: numberParam(geo.latitude, 'latitude', -90, 90),
+      longitude: numberParam(geo.longitude, 'longitude', -180, 180),
+      accuracy: numberParam(geo.accuracy ?? 100, 'accuracy', 0, 1000000),
+    };
+  }
+  if (!Object.keys(config).length) invalidWorkflow('Provide at least one emulation setting.');
+  return config;
+}

package/packages/protocol/src/files.js

@@ -0,0 +1,94 @@
+// @ts-check
+
+import { invalidWorkflow, numberParam, objectParam, onlyKeys, stringParam } from './emulation.js';
+
+export const FILE_MAX_BYTES = 16 * 1024 * 1024;
+export const FILE_CHUNK_BYTES = 192 * 1024;
+export const FILE_TOTAL_BYTES = 32 * 1024 * 1024;
+export const FILE_TTL_MS = 5 * 60 * 1000;
+
+/** @param {string} method @param {Record<string, unknown>} params @returns {Record<string, unknown>} */
+export function normalizeFileParams(method, params) {
+  if (method === 'files.stage') {
+    onlyKeys(params, ['transferId', 'name', 'mimeType', 'size', 'offset', 'data']);
+    /** @type {Record<string, unknown>} */
+    const result = {};
+    if (params.transferId !== undefined)
+      result.transferId = stringParam(params.transferId, 'transferId', 80);
+    else {
+      result.name = stringParam(params.name, 'name');
+      if (/[\\/]/u.test(String(result.name)))
+        invalidWorkflow('name must be a filename, not a path.');
+      result.mimeType = stringParam(params.mimeType ?? 'application/octet-stream', 'mimeType', 120);
+      result.size = numberParam(params.size, 'size', 0, FILE_MAX_BYTES);
+      if (!Number.isInteger(result.size)) invalidWorkflow('size must be an integer.');
+    }
+    result.offset = numberParam(params.offset ?? 0, 'offset', 0, FILE_MAX_BYTES);
+    if (!Number.isInteger(result.offset)) invalidWorkflow('offset must be an integer.');
+    const data = params.data ?? '';
+    if (
+      typeof data !== 'string' ||
+      data.length > (FILE_CHUNK_BYTES * 4) / 3 ||
+      !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(data)
+    )
+      invalidWorkflow('data must be base64, at most 192 KiB decoded per chunk.');
+    result.data = data;
+    return result;
+  }
+  if (method === 'files.release') {
+    onlyKeys(params, ['transferId']);
+    return { transferId: stringParam(params.transferId, 'transferId', 80) };
+  }
+  if (method === 'input.set_files') {
+    onlyKeys(params, ['target', 'files', 'paths']);
+    const target = objectParam(params.target, 'target');
+    const files = params.files;
+    const paths = params.paths;
+    if (paths !== undefined) onlyKeys(target, ['selector']);
+    if ((files === undefined) === (paths === undefined))
+      invalidWorkflow('Provide files or paths, not both. Empty files clears the input.');
+    const values = files ?? paths;
+    if (!Array.isArray(values) || values.length > 10)
+      invalidWorkflow('files/paths must be an array of at most 10 strings.');
+    const normalized = values.map((value) =>
+      stringParam(
+        value,
+        files !== undefined ? 'file handle' : 'browser path',
+        files !== undefined ? 80 : 4096
+      )
+    );
+    if (
+      paths !== undefined &&
+      normalized.some((value) => !/^(?:\/|[A-Za-z]:[\\/]|\\\\)/u.test(value))
+    )
+      invalidWorkflow('paths must be absolute paths on the browser machine.');
+    if (paths !== undefined && (typeof target.selector !== 'string' || !target.selector))
+      invalidWorkflow('Browser-local paths require target.selector in the top document.');
+    return { target, ...(files !== undefined ? { files: normalized } : { paths: normalized }) };
+  }
+  if (method === 'input.paste_image') {
+    onlyKeys(params, ['target', 'transferId']);
+    return {
+      target: objectParam(params.target, 'target'),
+      transferId: stringParam(params.transferId, 'transferId', 80),
+    };
+  }
+  if (method === 'download.resource') {
+    onlyKeys(params, ['url', 'maxBytes', 'timeoutMs']);
+    const url = stringParam(params.url, 'url', 8192);
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      invalidWorkflow('Invalid download URL.');
+    }
+    if (!['https:', 'http:'].includes(parsed.protocol) || parsed.username || parsed.password)
+      invalidWorkflow('Downloads require HTTP(S) without URL credentials.');
+    return {
+      url,
+      maxBytes: numberParam(params.maxBytes ?? 8 * 1024 * 1024, 'maxBytes', 1, FILE_MAX_BYTES),
+      timeoutMs: numberParam(params.timeoutMs ?? 30000, 'timeoutMs', 100, 60000),
+    };
+  }
+  return invalidWorkflow('Unknown file method.');
+}

package/packages/protocol/src/index.js

@@ -9,6 +9,7 @@ export * from './budget.js';
 export * from './capabilities.js';
 export * from './defaults.js';
 export * from './errors.js';
+export { normalizeEmulation, DEVICE_PRESETS, NETWORK_PRESETS } from './emulation.js';
 export * from './har.js';
 export * from './incidental-sanitizer.js';
 export * from './json-lines.js';

package/packages/protocol/src/protocol.js

@@ -2,6 +2,10 @@
 
 import { applyBudget } from './budget.js';
 import { normalizeWebMcpParams } from './webmcp.js';
+import { normalizeEmulation, onlyKeys } from './emulation.js';
+import { normalizeFileParams } from './files.js';
+import { normalizeDownload } from './downloads.js';
+import { normalizeRecording } from './recording.js';
 import {
   ARTIFACT_CHUNK_BYTES,
   BUDGET_PRESETS,
@@ -539,6 +543,38 @@ function normalizeAutomaticRetryMeta(source, value) {
  */
 export function normalizeRequestParams(method, params) {
   switch (method) {
+    case 'download.start':
+    case 'download.status':
+    case 'download.pause':
+    case 'download.resume':
+    case 'download.cancel':
+    case 'download.release':
+      return normalizeDownload(method, params);
+    case 'session.start':
+    case 'session.journal_read':
+    case 'session.journal_delete':
+    case 'session.status':
+    case 'session.read':
+    case 'session.stop':
+    case 'session.export':
+    case 'session.release':
+      return normalizeRecording(method, params);
+    case 'files.stage':
+    case 'files.release':
+    case 'download.resource':
+      return normalizeFileParams(method, params);
+    case 'input.set_files':
+    case 'input.paste_image':
+      return {
+        ...normalizeFileParams(method, params),
+        target: normalizeInputAction(params).target,
+      };
+    case 'emulation.apply':
+      return normalizeEmulation(params);
+    case 'emulation.status':
+    case 'emulation.reset':
+      onlyKeys(params, []);
+      return {};
     case 'webmcp.list_tools':
     case 'webmcp.get_tool':
     case 'webmcp.execute_tool': {
@@ -691,6 +727,14 @@ export function normalizeAccessRequestParams(params = {}) {
  */
 export function getBridgeOperationTimeoutMs(method, params = {}) {
   switch (method) {
+    case 'session.read':
+      return Number(normalizeRecording(method, params).waitMs) + 5000;
+    case 'session.stop':
+    case 'session.export':
+    case 'session.release':
+      return 100000;
+    case 'download.resource':
+      return Number(normalizeFileParams(method, params).timeoutMs) + 5000;
     case 'webmcp.execute_tool': {
       const normalized = normalizeWebMcpParams(params);
       return normalized.approvalTimeoutMs + normalized.timeoutMs + 10_000;

package/packages/protocol/src/recording.js

@@ -0,0 +1,70 @@
+// @ts-check
+
+import { booleanParam, invalidWorkflow, numberParam, onlyKeys, stringParam } from './emulation.js';
+
+/** @param {string} method @param {Record<string, unknown>} params @returns {Record<string, unknown>} */
+export function normalizeRecording(method, params) {
+  if (method === 'session.journal_read' || method === 'session.journal_delete') {
+    onlyKeys(params, [
+      'journalId',
+      ...(method === 'session.journal_read' ? ['offset', 'maxBytes'] : []),
+    ]);
+    const journalId = stringParam(params.journalId, 'journalId', 80);
+    if (!/^journal_[a-f0-9]{64}$/u.test(journalId)) invalidWorkflow('Invalid journal capability.');
+    if (method === 'session.journal_delete') return { journalId };
+    const offset = numberParam(params.offset ?? 0, 'offset', 0, Number.MAX_SAFE_INTEGER);
+    const maxBytes = numberParam(params.maxBytes ?? 196608, 'maxBytes', 1, 196608);
+    if (!Number.isInteger(offset) || !Number.isInteger(maxBytes))
+      invalidWorkflow('Journal ranges must be integers.');
+    return { journalId, offset, maxBytes };
+  }
+  if (method === 'session.start') {
+    onlyKeys(params, [
+      'activity',
+      'network',
+      'bodies',
+      'messages',
+      'visual',
+      'durationMs',
+      'followTabs',
+      'durable',
+      'replay',
+    ]);
+    const activity = booleanParam(params.activity ?? true, 'activity');
+    const network = booleanParam(params.network ?? false, 'network');
+    const bodies = booleanParam(params.bodies ?? false, 'bodies');
+    const messages = booleanParam(params.messages ?? false, 'messages');
+    const visual = booleanParam(params.visual ?? false, 'visual');
+    if ((bodies || messages) && !network) invalidWorkflow('bodies/messages require network:true.');
+    if (!activity && !network && !visual && params.replay !== true)
+      invalidWorkflow('Enable at least one recording source.');
+    return {
+      activity,
+      network,
+      bodies,
+      messages,
+      visual,
+      followTabs: booleanParam(params.followTabs ?? false, 'followTabs'),
+      durable: booleanParam(params.durable ?? false, 'durable'),
+      replay: booleanParam(params.replay ?? false, 'replay'),
+      durationMs: numberParam(params.durationMs ?? 60000, 'durationMs', 1000, 1800000),
+    };
+  }
+  onlyKeys(params, [
+    'sessionId',
+    ...(method === 'session.read' ? ['cursor', 'limit', 'waitMs'] : []),
+    ...(method === 'session.export' ? ['format'] : []),
+  ]);
+  const sessionId = stringParam(params.sessionId, 'sessionId', 80);
+  if (method === 'session.export') {
+    if (params.format !== undefined && params.format !== 'json' && params.format !== 'html')
+      invalidWorkflow('format must be json or html.');
+    return { sessionId, format: params.format ?? 'json' };
+  }
+  if (method !== 'session.read') return { sessionId };
+  const cursor = numberParam(params.cursor ?? 0, 'cursor', 0, Number.MAX_SAFE_INTEGER);
+  const limit = numberParam(params.limit ?? 25, 'limit', 1, 100);
+  if (!Number.isInteger(cursor) || !Number.isInteger(limit))
+    invalidWorkflow('cursor and limit must be integers.');
+  return { sessionId, cursor, limit, waitMs: numberParam(params.waitMs ?? 0, 'waitMs', 0, 25000) };
+}

package/packages/protocol/src/registry.js

@@ -100,6 +100,43 @@ const METHOD_POLICIES = Object.freeze({
  * @type {Readonly<Record<import('./types.js').BridgeMethod, string>>}
  */
 const BRIDGE_METHOD_DESCRIPTIONS = Object.freeze({
+  'session.journal_read':
+    'Read exact base64 bytes of a durable recording journal. Requires its secret journalId. Works after extension or daemon restart; page until nextOffset=null. Expires 24 hours after the last write.',
+  'session.journal_delete': 'Delete one durable recording journal using its secret journalId.',
+  'input.paste_image':
+    'Paste a staged PNG using the real clipboard and trusted Chrome input. Overwrites clipboard. Requires a focused top-document editor. Never automatically retry; verify insertion.',
+  'download.start':
+    'Start a browser-native download without the artifact size ceiling. Returns a secret downloadId for subsequent control. Saves on the browser machine.',
+  'download.status': 'Read progress and state of one BBX-created browser download.',
+  'download.pause': 'Pause one BBX-created browser download.',
+  'download.resume': 'Resume one resumable BBX-created browser download.',
+  'download.cancel': 'Cancel one BBX-created browser download.',
+  'download.release':
+    'Release a terminal download handle without deleting its file or browser history.',
+  'session.start':
+    'Start bounded recording. activity=true; network,bodies,messages,visual,followTabs,durable,replay default false. bodies/messages require network. durationMs=1000..1800000, default 60000. followTabs tracks up to eight opener descendants inside the enabled window. replay captures the root renderer stream. durable returns a secret journalId for crash recovery. Input values are redacted; pixels and binary bodies are not. Keep sessionId on one connection; two retained sessions maximum.',
+  'session.status':
+    'Probe a recording by sessionId, including the live page recorder, counters, gaps, body backlog and visual frame count. No event payloads.',
+  'session.read':
+    'Read bounded recording events with sessionId, cursor=0, limit=25 (max 100), waitMs=0 (max 25000). Cursors belong to this sessionId. Returns nextCursor and explicit capture gaps. No response bodies or images in this read.',
+  'session.stop':
+    'Stop intake, collect final activity, drain pending body reads and stop network capture. Retains evidence for five minutes for export. Failed cleanup is retryable.',
+  'session.export':
+    'Stop and drain a recording, then export a chunked artifact. format=json includes archived events, opt-in bodies and frames. format=html is a self-contained, script-free sampled-frame replay. Gaps and dropped counts remain explicit. Same connection required for artifact.read.',
+  'session.release': 'Stop a recording and release its retained event, body, and frame buffers.',
+  'files.stage':
+    'Stage file bytes on the browser machine. First call: name,mimeType,size,offset=0,data=base64. Further calls: transferId,offset=nextOffset,data. Max 192 KiB per chunk, 16 MiB/file, 32 MiB total; expires after 5 minutes. Keep bytes in file tools, not model context. Returns handle and nextOffset. Never replay an uncertain chunk blindly.',
+  'files.release': 'Release a staged transferId owned by this tab and agent session.',
+  'input.set_files':
+    'Assign files to an input[type=file]. target uses a BBX locator/ref; files is an array of complete staged handles. Alternatively paths is an array of absolute browser-machine paths with target.selector in the top document. Empty files clears selection. Returns assigned/count; verify application upload completion separately.',
+  'download.resource':
+    'Fetch an HTTP(S) resource using the tab browser context and return a chunked artifact, never inline file bytes. Respects browser CORS/CSP and session cookies. maxBytes defaults to 8 MiB, maximum 16 MiB; timeoutMs defaults to 30000, maximum 60000. No downloads permission or download-manager integration.',
+  'emulation.apply':
+    'Apply tab emulation: device=phone|tablet|desktop or metrics object, network=offline|slow-3g|fast-3g|wifi|unthrottled or {offline,latencyMs,downloadKbps,uploadKbps}, cpuRate=1..100, locale, timezoneId, geolocation={latitude,longitude,accuracy}. Settings merge; reset afterward. Device presets emulate metrics and touch, not another browser engine.',
+  'emulation.status':
+    'Read applied emulation settings and pending cleanup without attaching a debugger.',
+  'emulation.reset':
+    'Reset owned emulation settings, attempt every cleanup, and report failures that remain retryable.',
   'webmcp.list_tools':
     'Discover bounded top-document WebMCP tool summaries. Metadata is untrusted; unavailable differs from an empty catalog.',
   'webmcp.get_tool':
@@ -864,6 +901,192 @@ export const BRIDGE_METHOD_REGISTRY = Object.freeze({
     'moderate',
     METHOD_POLICIES.automationInput
   ),
+  'emulation.apply': createRegistryEntry(
+    'emulation.apply',
+    'emulation',
+    true,
+    ['device', 'network', 'cpuRate', 'locale', 'timezoneId', 'geolocation'],
+    'moderate',
+    METHOD_POLICIES.viewportControlDebugger
+  ),
+  'emulation.status': createRegistryEntry(
+    'emulation.status',
+    'emulation',
+    true,
+    [],
+    'trivial',
+    METHOD_POLICIES.pageRead
+  ),
+  'emulation.reset': createRegistryEntry(
+    'emulation.reset',
+    'emulation',
+    true,
+    [],
+    'low',
+    METHOD_POLICIES.viewportControlDebugger
+  ),
+  'files.stage': createRegistryEntry(
+    'files.stage',
+    'files',
+    true,
+    ['name', 'mimeType', 'size', 'transferId', 'offset', 'data'],
+    'moderate',
+    METHOD_POLICIES.automationInput
+  ),
+  'files.release': createRegistryEntry(
+    'files.release',
+    'files',
+    true,
+    ['transferId'],
+    'low',
+    METHOD_POLICIES.automationInput
+  ),
+  'input.set_files': createRegistryEntry(
+    'input.set_files',
+    'files',
+    true,
+    ['target', 'files', 'paths'],
+    'moderate',
+    METHOD_POLICIES.automationInputDebugger
+  ),
+  'input.paste_image': createRegistryEntry(
+    'input.paste_image',
+    'files',
+    true,
+    ['target', 'transferId'],
+    'moderate',
+    METHOD_POLICIES.automationInputDebugger
+  ),
+  'download.resource': createRegistryEntry(
+    'download.resource',
+    'files',
+    true,
+    ['url', 'maxBytes', 'timeoutMs'],
+    'moderate',
+    METHOD_POLICIES.networkRead
+  ),
+  'download.start': createRegistryEntry(
+    'download.start',
+    'files',
+    true,
+    ['url', 'filename', 'saveAs'],
+    'moderate',
+    METHOD_POLICIES.automationInput
+  ),
+  'download.status': createRegistryEntry(
+    'download.status',
+    'files',
+    true,
+    ['downloadId'],
+    'low',
+    METHOD_POLICIES.networkRead
+  ),
+  'download.pause': createRegistryEntry(
+    'download.pause',
+    'files',
+    true,
+    ['downloadId'],
+    'low',
+    METHOD_POLICIES.automationInput
+  ),
+  'download.resume': createRegistryEntry(
+    'download.resume',
+    'files',
+    true,
+    ['downloadId'],
+    'low',
+    METHOD_POLICIES.automationInput
+  ),
+  'download.cancel': createRegistryEntry(
+    'download.cancel',
+    'files',
+    true,
+    ['downloadId'],
+    'low',
+    METHOD_POLICIES.automationInput
+  ),
+  'download.release': createRegistryEntry(
+    'download.release',
+    'files',
+    true,
+    ['downloadId'],
+    'low',
+    METHOD_POLICIES.automationInput
+  ),
+  'session.start': createRegistryEntry(
+    'session.start',
+    'session',
+    true,
+    [
+      'activity',
+      'network',
+      'bodies',
+      'messages',
+      'visual',
+      'durationMs',
+      'followTabs',
+      'durable',
+      'replay',
+    ],
+    'moderate',
+    METHOD_POLICIES.automationInputDebugger
+  ),
+  'session.journal_read': createRegistryEntry(
+    'session.journal_read',
+    'session',
+    false,
+    ['journalId', 'offset', 'maxBytes'],
+    'low',
+    METHOD_POLICIES.none
+  ),
+  'session.journal_delete': createRegistryEntry(
+    'session.journal_delete',
+    'session',
+    false,
+    ['journalId'],
+    'low',
+    METHOD_POLICIES.none
+  ),
+  'session.status': createRegistryEntry(
+    'session.status',
+    'session',
+    true,
+    ['sessionId'],
+    'low',
+    METHOD_POLICIES.pageRead
+  ),
+  'session.read': createRegistryEntry(
+    'session.read',
+    'session',
+    true,
+    ['sessionId', 'cursor', 'limit', 'waitMs'],
+    'low',
+    METHOD_POLICIES.pageRead
+  ),
+  'session.stop': createRegistryEntry(
+    'session.stop',
+    'session',
+    true,
+    ['sessionId'],
+    'moderate',
+    METHOD_POLICIES.automationInputDebugger
+  ),
+  'session.export': createRegistryEntry(
+    'session.export',
+    'session',
+    true,
+    ['sessionId', 'format'],
+    'moderate',
+    METHOD_POLICIES.automationInputDebugger
+  ),
+  'session.release': createRegistryEntry(
+    'session.release',
+    'session',
+    true,
+    ['sessionId'],
+    'low',
+    METHOD_POLICIES.automationInputDebugger
+  ),
 });
 
 /** @type {ReadonlyArray<import('./types.js').BridgeMethod>} */
@@ -876,6 +1099,7 @@ export const METHOD_SET = new Set(BRIDGE_METHODS);
 
 /** Methods whose read-only forms may run concurrently without side effects. */
 const BATCH_SAFE_METHODS = new Set([
+  'emulation.status',
   'webmcp.list_tools',
   'webmcp.get_tool',
   'health.ping',