@browserbridge/bbx 1.11.3 → 1.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserbridge/bbx",
-  "version": "1.11.3",
+  "version": "1.11.5",
   "private": false,
   "keywords": [
     "agent-tools",
@@ -73,25 +73,29 @@
     "install-manifest": "node packages/native-host/bin/install-manifest.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/server": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.3.1",
     "@mozilla/readability": "^0.6.0",
     "linkedom": "^0.18.13",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@modelcontextprotocol/client": "^2.0.0",
-    "@types/chrome": "^0.3.0",
-    "@types/node": "^26.6.1",
+    "@modelcontextprotocol/client": "^2.3.1",
+    "@types/chrome": "^0.3.4",
+    "@types/node": "^26.6.4",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "c8": "^12.0.0",
     "har-schema": "^2.0.0",
-    "oxfmt": "^0.68.0",
-    "oxlint": "^1.83.0",
-    "tsx": "^4.23.13",
+    "oxfmt": "^0.72.0",
+    "oxlint": "^1.87.0",
+    "tsx": "^4.23.15",
     "typescript": "^7.0.2"
   },
   "engines": {
     "node": ">=20"
+  },
+  "allowScripts": {
+    "esbuild@0.28.1": true,
+    "fsevents@2.3.3": true
   }
 }

package/packages/mcp-server/src/handlers-capture.js

@@ -348,7 +348,7 @@ function createInputOptions(args) {
 }
 
 /**
- * @param {{ action: string, elementRef?: string, selector?: string, button?: string, clickCount?: number, text?: string, value?: string, mode?: 'auto' | 'setter' | 'keystrokes', executionMode?: 'dom' | 'cdp', recoverStale?: boolean, clear?: boolean, submit?: boolean, key?: string, code?: string, modifiers?: string[], checked?: boolean, values?: string[], labels?: string[], indexes?: number[], duration?: number, sourceElementRef?: string, sourceSelector?: string, destinationElementRef?: string, destinationSelector?: string, offsetX?: number, offsetY?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ action: string, elementRef?: string, selector?: string, button?: string, clickCount?: number, holdMs?: number, text?: string, value?: string, mode?: 'auto' | 'setter' | 'keystrokes', executionMode?: 'dom' | 'cdp', recoverStale?: boolean, clear?: boolean, submit?: boolean, key?: string, code?: string, modifiers?: string[], checked?: boolean, values?: string[], labels?: string[], indexes?: number[], duration?: number, sourceElementRef?: string, sourceSelector?: string, destinationElementRef?: string, destinationSelector?: string, offsetX?: number, offsetY?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleInputTool(args) {
@@ -391,6 +391,7 @@ export async function handleInputTool(args) {
               button: args.button,
               clickCount: args.clickCount,
               modifiers: args.modifiers,
+              ...(typeof args.holdMs === 'number' ? { holdMs: args.holdMs } : {}),
               ...createInputOptions(args),
             },
             {
@@ -464,6 +465,7 @@ export async function handleInputTool(args) {
               target,
               key: args.key,
               modifiers: args.modifiers,
+              ...(typeof args.holdMs === 'number' ? { holdMs: args.holdMs } : {}),
               ...createInputOptions(args),
             },
             {

package/packages/mcp-server/src/server.js

@@ -707,7 +707,7 @@ export function createBridgeMcpServer(options = {}) {
           .enum(['dom', 'cdp'])
           .optional()
           .describe(
-            'Input execution path (default: dom; CDP supports click, hover, drag, type, fill)'
+            'Input execution path (default: dom; CDP supports click, hover, drag, type, fill, press_key). Use cdp when the page needs trusted input, e.g. to start audio or media.'
           ),
         recoverStale: z
           .boolean()
@@ -729,6 +729,15 @@ export function createBridgeMcpServer(options = {}) {
           .array(z.enum(['Alt', 'Control', 'Meta', 'Shift']))
           .optional()
           .describe('Modifier keys'),
+        holdMs: z
+          .number()
+          .int()
+          .min(0)
+          .max(10000)
+          .optional()
+          .describe(
+            'Keep the mouse button or key pressed this long (click, press_key; default: 0)'
+          ),
         checked: z.boolean().optional().describe('Checked state (for set_checked action)'),
         values: z.array(z.string()).optional().describe('Option values to select'),
         labels: z

package/packages/protocol/src/defaults.js

@@ -45,6 +45,22 @@ export const MAX_BATCH_CALLS = 20;
 
 /** Maximum read-only batch calls executing concurrently. */
 export const MAX_BATCH_CONCURRENCY = 5;
+
+/** Maximum press-and-hold time for one pointer, key, or touch action (ms). */
+export const MAX_INPUT_HOLD_MS = 10_000;
+
+/** Default contact time for an input.touch gesture without explicit holdMs (ms). */
+export const DEFAULT_TOUCH_HOLD_MS = 50;
+
+/** Maximum simultaneous touch points in one input.touch gesture. */
+export const MAX_TOUCH_POINTS = 10;
+
+/** Maximum steps accepted by one input.perform sequence. */
+export const MAX_PERFORM_STEPS = 200;
+
+/** Default and maximum total budget for one input.perform sequence (ms). */
+export const DEFAULT_PERFORM_TIMEOUT_MS = 30_000;
+export const MAX_PERFORM_TIMEOUT_MS = 120_000;
 export const MAX_INTERCEPT_RULES_PER_TAB = 32;
 export const MAX_INTERCEPT_URL_PATTERN_LENGTH = 2_048;
 export const MAX_INTERCEPT_BODY_BYTES = 262_144;

package/packages/protocol/src/protocol.js

@@ -19,19 +19,25 @@ import {
   DEFAULT_NETWORK_INTERCEPT_ACTION,
   DEFAULT_NETWORK_LIMIT,
   DEFAULT_PAGE_TEXT_BUDGET,
+  DEFAULT_PERFORM_TIMEOUT_MS,
   DEFAULT_TEXT_BUDGET,
+  DEFAULT_TOUCH_HOLD_MS,
   DEFAULT_VIEWPORT_HEIGHT,
   DEFAULT_VIEWPORT_WIDTH,
   DEFAULT_WAIT_TIMEOUT_MS,
   MAX_EXTRACT_SETTLE_TIMEOUT_MS,
   MAX_ARTIFACT_BYTES,
   MAX_HAR_ENTRIES,
+  MAX_INPUT_HOLD_MS,
   MAX_INTERCEPT_BODY_BYTES,
   MAX_INTERCEPT_HEADER_BYTES,
   MAX_INTERCEPT_HEADERS,
   MAX_INTERCEPT_HEADER_VALUE_BYTES,
   MAX_INTERCEPT_URL_PATTERN_LENGTH,
+  MAX_PERFORM_STEPS,
+  MAX_PERFORM_TIMEOUT_MS,
   MAX_SENSITIVE_VALUE_BYTES,
+  MAX_TOUCH_POINTS,
 } from './defaults.js';
 import { BridgeError, ERROR_CODES, getErrorRecovery } from './errors.js';
 import { BRIDGE_METHODS, METHOD_SET, createBridgeMethodGroups } from './registry.js';
@@ -96,6 +102,8 @@ import { BRIDGE_METHODS, METHOD_SET, createBridgeMethodGroups } from './registry
 /** @typedef {import('./types.js').NormalizedNetworkParams} NormalizedNetworkParams */
 /** @typedef {import('./types.js').NormalizedPageTextParams} NormalizedPageTextParams */
 /** @typedef {import('./types.js').NormalizedPatchOperation} NormalizedPatchOperation */
+/** @typedef {import('./types.js').NormalizedPerformParams} NormalizedPerformParams */
+/** @typedef {import('./types.js').NormalizedPerformStep} NormalizedPerformStep */
 /** @typedef {import('./types.js').NormalizedSelectAction} NormalizedSelectAction */
 /** @typedef {import('./types.js').NormalizedScreenshotParams} NormalizedScreenshotParams */
 /** @typedef {import('./types.js').NormalizedStorageParams} NormalizedStorageParams */
@@ -103,11 +111,17 @@ import { BRIDGE_METHODS, METHOD_SET, createBridgeMethodGroups } from './registry
 /** @typedef {import('./types.js').NormalizedStyleQuery} NormalizedStyleQuery */
 /** @typedef {import('./types.js').NormalizedTabCloseParams} NormalizedTabCloseParams */
 /** @typedef {import('./types.js').NormalizedTabCreateParams} NormalizedTabCreateParams */
+/** @typedef {import('./types.js').NormalizedTouchParams} NormalizedTouchParams */
+/** @typedef {import('./types.js').NormalizedTouchPoint} NormalizedTouchPoint */
+/** @typedef {import('./types.js').NormalizedTouchPosition} NormalizedTouchPosition */
 /** @typedef {import('./types.js').NormalizedViewportAction} NormalizedViewportAction */
 /** @typedef {import('./types.js').NormalizedViewportResizeParams} NormalizedViewportResizeParams */
 /** @typedef {import('./types.js').NormalizedWaitForLoadStateParams} NormalizedWaitForLoadStateParams */
 /** @typedef {import('./types.js').NormalizedWaitForParams} NormalizedWaitForParams */
 /** @typedef {import('./types.js').PageTextParams} PageTextParams */
+/** @typedef {import('./types.js').PerformParams} PerformParams */
+/** @typedef {import('./types.js').PerformStepMethod} PerformStepMethod */
+/** @typedef {import('./types.js').TouchParams} TouchParams */
 /** @typedef {import('./types.js').PatchOperationParams} PatchOperationParams */
 /** @typedef {import('./types.js').SelectActionParams} SelectActionParams */
 /** @typedef {import('./types.js').ScreenshotParams} ScreenshotParams */
@@ -528,6 +542,10 @@ function normalizeRequestParams(method, params) {
       return normalizeHoverParams(params);
     case 'input.drag':
       return normalizeDragParams(params);
+    case 'input.touch':
+      return normalizeTouchParams(params);
+    case 'input.perform':
+      return normalizeInputPerformParams(params);
     case 'screenshot.capture_region':
       return { ...params, ...normalizeScreenshotParams(params) };
     case 'screenshot.capture_element':
@@ -604,11 +622,23 @@ export function getBridgeOperationTimeoutMs(method, params = {}) {
     }
     case 'dom.wait_for':
       return clampInt(params.timeoutMs, 100, 30_000, 5_000);
+    case 'input.perform':
+      return normalizeInputPerformParams(params).timeoutMs;
+    case 'input.click':
+    case 'input.press_key': {
+      const holdMs = normalizeHoldMs(params.holdMs, 0);
+      return holdMs > 0 ? holdMs + INPUT_HOLD_TIMEOUT_MARGIN_MS : null;
+    }
+    case 'input.touch':
+      return normalizeHoldMs(params.holdMs, DEFAULT_TOUCH_HOLD_MS) + INPUT_HOLD_TIMEOUT_MARGIN_MS;
     default:
       return null;
   }
 }
 
+/** Resolution and dispatch allowance added around an input hold (ms). */
+const INPUT_HOLD_TIMEOUT_MARGIN_MS = 5_000;
+
 /**
  * @param {DomQueryParams} [params={}]
  * @returns {NormalizedDomQuery}
@@ -774,11 +804,204 @@ export function normalizeInputAction(params = {}) {
     modifiers: Array.isArray(params.modifiers)
       ? params.modifiers.filter((modifier) => typeof modifier === 'string' && modifier.trim())
       : [],
+    holdMs: normalizeHoldMs(params.holdMs, 0),
+    executionMode: normalizeInputExecutionMode(params.executionMode),
+    recoverStale: params.recoverStale === true,
+  };
+}
+
+/**
+ * Normalize a press-and-hold duration, honoring an explicit zero.
+ *
+ * @param {unknown} value
+ * @param {number} fallback
+ * @returns {number}
+ */
+function normalizeHoldMs(value, fallback) {
+  return Math.round(clampNumber(value, 0, MAX_INPUT_HOLD_MS, fallback));
+}
+
+/**
+ * @param {unknown} value
+ * @param {string} label
+ * @returns {NormalizedTouchPosition}
+ */
+function normalizeTouchPosition(value, label) {
+  if (!isPlainRecord(value)) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `${label} must be an object with either target or numeric x and y.`
+    );
+  }
+  const hasTarget = isPlainRecord(value.target);
+  const hasPoint =
+    typeof value.x === 'number' &&
+    Number.isFinite(value.x) &&
+    typeof value.y === 'number' &&
+    Number.isFinite(value.y);
+  if (hasTarget === hasPoint) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `${label} needs exactly one of target or numeric x and y.`
+    );
+  }
+  if (hasTarget) {
+    return {
+      target: normalizeTarget(
+        /** @type {{ elementRef?: string, selector?: string }} */ (value.target)
+      ),
+      x: null,
+      y: null,
+    };
+  }
+  return { target: null, x: /** @type {number} */ (value.x), y: /** @type {number} */ (value.y) };
+}
+
+/**
+ * Normalize a simultaneous touch gesture: one to MAX_TOUCH_POINTS fingers,
+ * each placed on a target or viewport point and optionally moved to an end
+ * position while all fingers stay down for holdMs.
+ *
+ * @param {TouchParams} [params={}]
+ * @returns {NormalizedTouchParams}
+ */
+export function normalizeTouchParams(params = {}) {
+  const rawPoints = params.points;
+  if (!Array.isArray(rawPoints) || rawPoints.length < 1 || rawPoints.length > MAX_TOUCH_POINTS) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `points must be an array of 1 to ${MAX_TOUCH_POINTS} touch points.`
+    );
+  }
+  /** @type {NormalizedTouchPoint[]} */
+  const points = rawPoints.map((point, index) => {
+    const start = normalizeTouchPosition(point, `points[${index}]`);
+    const rawEnd = isPlainRecord(point) ? point.to : undefined;
+    return {
+      ...start,
+      to: rawEnd == null ? null : normalizeTouchPosition(rawEnd, `points[${index}].to`),
+    };
+  });
+  return {
+    points,
+    holdMs: normalizeHoldMs(params.holdMs, DEFAULT_TOUCH_HOLD_MS),
+    moveSteps: clampInt(params.moveSteps, 1, 60, 10),
     executionMode: normalizeInputExecutionMode(params.executionMode),
     recoverStale: params.recoverStale === true,
   };
 }
 
+/** Methods that may appear as input.perform steps. */
+const PERFORM_STEP_METHODS = new Set([
+  'input.click',
+  'input.focus',
+  'input.type',
+  'input.fill',
+  'input.press_key',
+  'input.set_checked',
+  'input.select_option',
+  'input.hover',
+  'input.drag',
+  'input.touch',
+  'input.scroll_into_view',
+  'viewport.scroll',
+  'dom.wait_for',
+  'page.wait_for_load_state',
+]);
+
+/** Step methods that accept executionMode=cdp. */
+const CDP_CAPABLE_STEP_METHODS = new Set([
+  'input.click',
+  'input.hover',
+  'input.drag',
+  'input.type',
+  'input.fill',
+  'input.press_key',
+  'input.touch',
+]);
+
+/**
+ * @param {unknown} value
+ * @param {string} label
+ * @param {number} maximum
+ * @returns {number | null}
+ */
+function normalizeStepTiming(value, label, maximum) {
+  if (value == null) return null;
+  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > maximum) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `${label} must be a number between 0 and the sequence timeoutMs (${maximum}).`
+    );
+  }
+  return Math.round(value);
+}
+
+/**
+ * Normalize an ordered, timed input sequence. Each step reuses an existing
+ * bridge method and its own normalizer; the sequence adds only scheduling.
+ *
+ * @param {PerformParams} [params={}]
+ * @returns {NormalizedPerformParams}
+ */
+export function normalizeInputPerformParams(params = {}) {
+  const timeoutMs = clampInt(
+    params.timeoutMs,
+    100,
+    MAX_PERFORM_TIMEOUT_MS,
+    DEFAULT_PERFORM_TIMEOUT_MS
+  );
+  const executionMode =
+    params.executionMode === undefined ? null : normalizeInputExecutionMode(params.executionMode);
+  const rawSteps = params.steps;
+  if (!Array.isArray(rawSteps) || rawSteps.length < 1 || rawSteps.length > MAX_PERFORM_STEPS) {
+    throw new BridgeError(
+      ERROR_CODES.INVALID_REQUEST,
+      `steps must be an array of 1 to ${MAX_PERFORM_STEPS} steps.`
+    );
+  }
+  /** @type {NormalizedPerformStep[]} */
+  const steps = rawSteps.map((step, index) => {
+    if (!isPlainRecord(step)) {
+      throw new BridgeError(ERROR_CODES.INVALID_REQUEST, `steps[${index}] must be an object.`);
+    }
+    const method = step.method;
+    if (typeof method !== 'string' || !PERFORM_STEP_METHODS.has(method)) {
+      throw new BridgeError(
+        ERROR_CODES.INVALID_REQUEST,
+        `steps[${index}].method must be one of ${[...PERFORM_STEP_METHODS].join(', ')}.`
+      );
+    }
+    if (step.params !== undefined && !isPlainRecord(step.params)) {
+      throw new BridgeError(
+        ERROR_CODES.INVALID_REQUEST,
+        `steps[${index}].params must be an object.`
+      );
+    }
+    const rawParams = /** @type {Record<string, unknown>} */ (step.params ?? {});
+    const stepParams =
+      executionMode && CDP_CAPABLE_STEP_METHODS.has(method) && rawParams.executionMode === undefined
+        ? { ...rawParams, executionMode }
+        : rawParams;
+    const delayMs = normalizeStepTiming(step.delayMs, `steps[${index}].delayMs`, timeoutMs);
+    const atMs = normalizeStepTiming(step.atMs, `steps[${index}].atMs`, timeoutMs);
+    if (delayMs && atMs !== null) {
+      throw new BridgeError(
+        ERROR_CODES.INVALID_REQUEST,
+        `steps[${index}] accepts either delayMs or atMs, not both.`
+      );
+    }
+    const stepMethod = /** @type {PerformStepMethod} */ (method);
+    return {
+      method: stepMethod,
+      params: normalizeRequestParams(stepMethod, stepParams),
+      delayMs: delayMs ?? 0,
+      atMs,
+    };
+  });
+  return { steps, timeoutMs, continueOnError: params.continueOnError === true };
+}
+
 /**
  * @param {CdpDispatchKeyEventParams} [params={}]
  * @returns {NormalizedCdpDispatchKeyEventParams}

package/packages/protocol/src/registry.js

@@ -153,16 +153,22 @@ const BRIDGE_METHOD_DESCRIPTIONS = Object.freeze({
     'Read element classes and inline style context (not stylesheet cascade data).',
   'viewport.scroll': 'Scroll the viewport or a scrollable element.',
   'viewport.resize': 'Resize or reset the tab viewport.',
-  'input.click': 'Actionability-check and click an element through DOM or optional CDP input.',
+  'input.click':
+    'Actionability-check and click an element through DOM or optional CDP input; holdMs keeps the button pressed.',
   'input.focus': 'Actionability-check and focus an element through DOM input.',
   'input.type': 'Actionability-check and type through DOM or optional CDP text input.',
   'input.fill':
     'Fill an editable target using a DOM strategy or optional CDP text input; verify afterward.',
-  'input.press_key': 'Send a key press to the page or an element.',
+  'input.press_key':
+    'Send a key press to the page or an element through DOM or optional CDP input; holdMs keeps the key down.',
   'input.set_checked': 'Set checkbox or radio checked state.',
   'input.select_option': 'Select options in a select element.',
   'input.hover': 'Actionability-check and hover through DOM or optional CDP pointer input.',
   'input.drag': 'Actionability-check and drag through DOM or optional CDP pointer input.',
+  'input.touch':
+    'Press one or more touch points at the same time (chords, multi-finger taps, swipes, pinches) through DOM or optional CDP touch input.',
+  'input.perform':
+    'Run an ordered, timed sequence of input steps inside the browser in one call; use for rhythm, games, gestures, and multi-step flows.',
   'input.scroll_into_view': 'Scroll an element into the visible viewport.',
   'screenshot.capture_region': 'Capture a screenshot of a viewport region.',
   'screenshot.capture_element': 'Capture a screenshot of one element.',
@@ -600,7 +606,7 @@ export const BRIDGE_METHOD_REGISTRY = Object.freeze({
     'input.click',
     'interact',
     true,
-    ['target', 'button', 'clickCount', 'modifiers', 'executionMode', 'recoverStale'],
+    ['target', 'button', 'clickCount', 'modifiers', 'holdMs', 'executionMode', 'recoverStale'],
     'low',
     METHOD_POLICIES.automationInput
   ),
@@ -632,7 +638,7 @@ export const BRIDGE_METHOD_REGISTRY = Object.freeze({
     'input.press_key',
     'interact',
     true,
-    ['target', 'key', 'modifiers', 'executionMode', 'recoverStale'],
+    ['target', 'key', 'modifiers', 'holdMs', 'executionMode', 'recoverStale'],
     'low',
     METHOD_POLICIES.automationInput
   ),
@@ -668,6 +674,22 @@ export const BRIDGE_METHOD_REGISTRY = Object.freeze({
     'moderate',
     METHOD_POLICIES.automationInput
   ),
+  'input.touch': createRegistryEntry(
+    'input.touch',
+    'interact',
+    true,
+    ['points', 'holdMs', 'moveSteps', 'executionMode', 'recoverStale'],
+    'moderate',
+    METHOD_POLICIES.automationInput
+  ),
+  'input.perform': createRegistryEntry(
+    'input.perform',
+    'interact',
+    true,
+    ['steps', 'executionMode', 'timeoutMs', 'continueOnError'],
+    'moderate',
+    METHOD_POLICIES.automationInput
+  ),
   'input.scroll_into_view': createRegistryEntry(
     'input.scroll_into_view',
     'interact',

package/packages/protocol/src/summary.js

@@ -56,8 +56,67 @@ import { sanitizeIncidentalUrl } from './incidental-sanitizer.js';
  * }} BatchItemSummary
  */
 
+/** Evaluate values longer than this stay out of the summary; evidence holds them. */
+const MAX_EVALUATE_SUMMARY_CHARS = 160;
+const EVALUATE_PREVIEW_CHARS = 80;
+
+/**
+ * Keep evaluate summaries short: small values inline, larger ones as a shape
+ * description, because the full value is already delivered in evidence.
+ *
+ * @param {unknown} value
+ * @returns {string}
+ */
+function summarizeEvaluateValue(value) {
+  const json = JSON.stringify(value) ?? String(value);
+  if (json.length <= MAX_EVALUATE_SUMMARY_CHARS) return json;
+  const shape = Array.isArray(value)
+    ? `${value.length} item(s)`
+    : value && typeof value === 'object'
+      ? `${Object.keys(value).length} key(s)`
+      : `${json.length} chars`;
+  return `${shape}, ${json.length} chars as JSON; full value in evidence.value`;
+}
+
+/**
+ * @param {string | undefined} method
+ * @param {Record<string, unknown>} result
+ * @returns {string}
+ */
+function describeTabResult(method, result) {
+  const url = typeof result.url === 'string' && result.url ? ` (${result.url})` : '';
+  switch (method) {
+    case 'navigation.reload':
+      return `Reloaded tab ${result.tabId}${url}.`;
+    case 'navigation.go_back':
+      return `Navigated back in tab ${result.tabId}${url}.`;
+    case 'navigation.go_forward':
+      return `Navigated forward in tab ${result.tabId}${url}.`;
+    case 'tabs.activate':
+      return `Tab ${result.tabId} activated${url}.`;
+    case 'page.wait_for_load_state':
+      return `Tab ${result.tabId} ${typeof result.status === 'string' ? result.status : 'ready'}${url}.`;
+    default:
+      return `Tab ${result.tabId} created${url}.`;
+  }
+}
+
 /** @type {Record<string, ActionSummary>} */
 const ACTION_SUMMARIES = {
+  performed: {
+    text: (r) => {
+      const failures = Array.isArray(r.failures) ? r.failures.length : 0;
+      return `Performed ${r.completed ?? 0}/${r.total ?? 0} step(s) in ${r.elapsedMs ?? 0}ms${failures ? ` with ${failures} failed step(s)` : ''}.`;
+    },
+    evidence: (r) => r,
+  },
+  touched: {
+    text: (r) => {
+      const mode = toRecord(r.execution).actualMode;
+      return `Touched ${r.pointCount ?? 0} point(s)${typeof mode === 'string' ? ` via ${mode}` : ''}.`;
+    },
+    evidence: (r) => r,
+  },
   hovered: {
     text: (r) => `Hover ${r.hovered ? 'active' : 'failed'} on ${r.elementRef}.`,
     evidence: (r) => r,
@@ -545,7 +604,10 @@ export function summarizeBridgeResponse(response, method) {
     } else if (isNull) {
       repr = '';
     } else if (typeof result.value === 'string') {
-      repr = result.value.length > 200 ? `${result.value.slice(0, 199)}\u2026` : result.value;
+      repr =
+        result.value.length > MAX_EVALUATE_SUMMARY_CHARS
+          ? `${result.value.length} chars, starts ${JSON.stringify(result.value.slice(0, EVALUATE_PREVIEW_CHARS))}\u2026`
+          : result.value;
     } else if (
       typeof result.value === 'object' &&
       result.value !== null &&
@@ -553,7 +615,7 @@ export function summarizeBridgeResponse(response, method) {
     ) {
       repr = '(empty - may be a Promise, Map, or non-serializable value)';
     } else {
-      repr = JSON.stringify(result.value);
+      repr = summarizeEvaluateValue(result.value);
     }
     const typeLabel = isNull ? 'null' : result.type;
     return {
@@ -724,10 +786,7 @@ export function summarizeBridgeResponse(response, method) {
     }
     return {
       ok: true,
-      summary: appendProtocolWarning(
-        `Tab ${result.tabId} created${result.url ? ` (${result.url})` : ''}.`,
-        protocolWarning
-      ),
+      summary: appendProtocolWarning(describeTabResult(actionMethod, result), protocolWarning),
       evidence: result,
     };
   }

package/packages/protocol/src/types.ts

@@ -119,6 +119,8 @@ export type BridgeMethod =
   | 'input.select_option'
   | 'input.hover'
   | 'input.drag'
+  | 'input.touch'
+  | 'input.perform'
   | 'input.scroll_into_view'
   | 'screenshot.capture_region'
   | 'screenshot.capture_element'
@@ -479,6 +481,7 @@ export interface InputActionParams {
   submit?: boolean;
   key?: string;
   modifiers?: string[];
+  holdMs?: number;
   executionMode?: InputExecutionMode;
   recoverStale?: boolean;
 }
@@ -494,10 +497,106 @@ export interface NormalizedInputAction extends BridgeParams {
   submit: boolean;
   key: string;
   modifiers: string[];
+  holdMs: number;
   executionMode: InputExecutionMode;
   recoverStale: boolean;
 }
 
+// Nullable fields let already-normalized params pass through normalization again.
+export interface TouchPositionParams {
+  target?: InputTarget | null;
+  x?: number | null;
+  y?: number | null;
+}
+
+export interface TouchPointParams extends TouchPositionParams {
+  to?: TouchPositionParams | null;
+}
+
+export interface TouchParams {
+  points?: TouchPointParams[];
+  holdMs?: number;
+  moveSteps?: number;
+  executionMode?: InputExecutionMode;
+  recoverStale?: boolean;
+}
+
+export type NormalizedTouchPosition =
+  | { target: InputTarget; x: null; y: null }
+  | { target: null; x: number; y: number };
+
+export type NormalizedTouchPoint = NormalizedTouchPosition & {
+  to: NormalizedTouchPosition | null;
+};
+
+export interface NormalizedTouchParams extends BridgeParams {
+  points: NormalizedTouchPoint[];
+  holdMs: number;
+  moveSteps: number;
+  executionMode: InputExecutionMode;
+  recoverStale: boolean;
+}
+
+export type PerformStepMethod =
+  | 'input.click'
+  | 'input.focus'
+  | 'input.type'
+  | 'input.fill'
+  | 'input.press_key'
+  | 'input.set_checked'
+  | 'input.select_option'
+  | 'input.hover'
+  | 'input.drag'
+  | 'input.touch'
+  | 'input.scroll_into_view'
+  | 'viewport.scroll'
+  | 'dom.wait_for'
+  | 'page.wait_for_load_state';
+
+export interface PerformStepParams {
+  method?: string;
+  params?: Record<string, unknown>;
+  delayMs?: number | null;
+  atMs?: number | null;
+}
+
+export interface PerformParams {
+  steps?: PerformStepParams[];
+  executionMode?: InputExecutionMode;
+  timeoutMs?: number;
+  continueOnError?: boolean;
+}
+
+export interface NormalizedPerformStep {
+  method: PerformStepMethod;
+  params: Record<string, unknown>;
+  delayMs: number;
+  atMs: number | null;
+}
+
+export interface NormalizedPerformParams extends BridgeParams {
+  steps: NormalizedPerformStep[];
+  timeoutMs: number;
+  continueOnError: boolean;
+}
+
+export interface PerformStepFailure {
+  index: number;
+  method: PerformStepMethod;
+  code: string;
+  message: string;
+  details?: unknown;
+}
+
+export interface PerformResult {
+  performed: true;
+  completed: number;
+  total: number;
+  elapsedMs: number;
+  startedAtMs: number[];
+  failures: PerformStepFailure[];
+}
+
 export interface CdpDispatchKeyEventParams {
   key?: string;
   code?: string;

package/skills/browser-bridge/SKILL.md

@@ -195,6 +195,9 @@ they contain no page data, URLs, selectors, payloads, errors, or group names.
 23. **Dialogs are explicit** - inspect first, then accept or dismiss only when intended. `expectedDialogId` is a pre-dispatch stale-decision check, not an atomic CDP binding; never auto-repeat `DIALOG_ACTION_CONFLICT`.
 24. **DOM diffs use explicit baselines** - call `dom.baseline.create` before the action, `dom.baseline.compare` afterward, then `dom.baseline.release`. Use a narrow selector and bounded evidence. Never substitute unrelated DOM reads for the retained baseline, and recreate it after `DOM_BASELINE_INVALIDATED`.
 25. **HAR export reads an armed capture** - use CDP capture `start`, reproduce, `network.export_har`/`bbx har`, then `stop`. Export never starts, stops, or clears capture. Inspect truncation plus `dropped`, `abandoned`, and `inflight` before claiming completeness.
+26. **Keep timing inside the browser** - for rhythm, games, gestures, or any steps that must happen at set times or back-to-back, send one `input.perform` with the whole schedule (`atMs` from the sequence start, or `delayMs` after the previous step). Never spread timed input across tool calls (each call costs an agent round-trip) and never issue input as parallel tool calls (they land all at once).
+27. **Use trusted input when the page needs a user gesture** - DOM-mode events are untrusted, so Chrome may refuse audio or media start, popups, clipboard writes, and fullscreen. Use `executionMode: "cdp"` (click, hover, drag, type, fill, press_key, touch) for those pages; `input.perform` accepts it once for every step.
+28. **Simultaneous presses need touch** - a mouse has one pointer. For chords or multi-finger gestures use `input.touch` with several `points` (optionally `to` end positions for swipes and pinches); add `holdMs` to `input.click`/`input.press_key` when the press must last.
 
 ## Token Budget Quick Rules
 
@@ -267,7 +270,7 @@ bbx page-text 2000                                  # extract page content
 | Page State  | `page.get_console`, `page.get_storage`, `page.get_text`, `page.wait_for_load_state`, `page.evaluate` (debugger-backed)                              |
 | Dialogs     | `page.handle_dialog` (debugger-backed; explicit inspect/accept/dismiss only)                                                                  |
 | Network     | `page.get_network` (fetch/XHR default; optional CDP lifecycle), `network.export_har`, `network.intercept.add/remove/list/clear` (debugger-backed)   |
-| Interact    | `input.click`, `input.type`, `input.fill`, `input.focus`, `input.press_key`, `cdp.dispatch_key_event`, `input.hover`, `input.drag`, `input.scroll_into_view` |
+| Interact    | `input.click`, `input.type`, `input.fill`, `input.focus`, `input.press_key`, `cdp.dispatch_key_event`, `input.hover`, `input.drag`, `input.touch`, `input.perform` (timed sequences), `input.scroll_into_view` |
 | Tabs        | `tabs.list` (preferred), `tabs.create` (avoid unless necessary), `tabs.close`, `tabs.activate`                                                      |
 | Patch       | `patch.apply_styles`, `patch.apply_dom`, `patch.rollback`                                                                                           |
 | Navigate    | `navigation.navigate`, `viewport.scroll`, `viewport.resize`                                                                                         |
@@ -349,7 +352,8 @@ Every CLI shortcut command produces consistent `{ok, summary, evidence}` JSON. U
   bbx call input.click '{"elementRef":"el_xxx"}'
   ```
 - `input.drag` uses `source`, `destination`, and optional destination offsets `offsetX` / `offsetY`.
-- `executionMode` accepts `dom` or `cdp` and defaults to `dom`; CDP supports only click, hover, drag, type, and fill. `input.fill.mode` (`auto`, `setter`, `keystrokes`) is a separate DOM strategy.
+- `executionMode` accepts `dom` or `cdp` and defaults to `dom`; CDP supports click, hover, drag, type, fill, press_key, and touch. `input.fill.mode` (`auto`, `setter`, `keystrokes`) is a separate DOM strategy.
+- `input.perform` takes `steps: [{ method, params, atMs | delayMs }]` using the same params each method takes alone. Steps run in order inside the extension; it stops at the first failed step (or a `dom.wait_for` that times out) unless `continueOnError: true`, and reports `startedAtMs` for every step.
 - `page.get_network` defaults to low-cost fetch/XHR instrumentation. All-resource CDP capture must be armed before the activity with `source: "cdp", capture: "start"`, read later, and explicitly stopped.
 - `network.export_har` requires that explicit capture to still be armed. Params are `limit` (1-200), sanitized-URL substring `urlPattern`, and `delivery` (`auto`, `inline`, `artifact`). Inline bounds remove whole oldest entries; export never changes capture state. `bbx har` uses the same client to download, length/SHA-256 verify, delete, validate, and atomically write artifacts locally.
 - `page.handle_dialog` mutations are not atomically bound to `expectedDialogId`; treat `commandDispatched` as dispatch evidence and verify follow-up state.

package/skills/browser-bridge/references/interaction.md

@@ -4,16 +4,18 @@
 
 | Method                   | CLI Shortcut                          | Purpose                                                     |
 | ------------------------ | ------------------------------------- | ----------------------------------------------------------- |
-| `input.click`            | `click <ref> [button]`                | Actionability-aware DOM click; optional CDP native click    |
+| `input.click`            | `click <ref> [button]`                | Actionability-aware DOM click; optional CDP native click; `holdMs` keeps the button down |
 | `input.focus`            | `focus <ref>`                         | Focus an element                                            |
 | `input.type`             | `type <ref> <text>`                   | DOM key sequence; optional CDP native text insertion        |
 | `input.fill`             | `fill <ref> <value>`                  | DOM fill strategy; optional CDP clear and text insertion    |
-| `input.press_key`        | `press-key <key> [ref]`               | Send keyboard key (Enter, Backspace, etc.)                  |
+| `input.press_key`        | `press-key <key> [ref]`               | Send keyboard key (Enter, Backspace, etc.); optional CDP; `holdMs` |
 | `cdp.dispatch_key_event` | `cdp-press-key --tab <id> <key>`      | CDP keyDown/keyUp without focusing the target tab           |
 | `input.set_checked`      | `call input.set_checked '{...}'`      | Toggle checkbox/radio                                       |
 | `input.select_option`    | `call input.select_option '{...}'`    | Select native `<select>` by value/label/index               |
 | `input.hover`            | `hover <ref>`                         | DOM hover events or optional CDP pointer move               |
-| `input.drag`             | `call input.drag '{...}'`             | DOM drag events or optional CDP pointer drag                |
+| `input.drag`             | `call input.drag '{...}'`             | HTML5 drag for draggable sources, pointer drag otherwise; optional CDP |
+| `input.touch`            | `call input.touch '{...}'`            | One or more simultaneous touch points: chords, taps, swipes, pinches |
+| `input.perform`          | `call input.perform '{...}'`          | Ordered, timed sequence of input steps run inside the browser |
 | `input.scroll_into_view` | `call input.scroll_into_view '{...}'` | Ensure a target is visible before inspect/capture           |
 
 ## Navigation
@@ -225,7 +227,69 @@ bbx type el_123 hello                    # simulate per-character keystrokes
 
 Prefer `fill` for setting form values: it uses the native prototype setter plus `input`/`change`/`blur` events, which React, Vue, and Angular pick up reliably. `mode` defaults to `auto` (setter first, keystroke fallback if the value did not stick); pass `"mode":"keystrokes"` via `bbx call input.fill` for components that only react to per-key events. Use `type` when page logic depends on individual key events (autocomplete, masked inputs).
 
-`mode` is not `executionMode`. The latter accepts only `dom` or `cdp`, defaults to `dom` for compatibility, and selects the dispatch path. CDP execution is available only for click, hover, drag, type, and fill; unsupported combinations fail with `INPUT_UNSUPPORTED` instead of silently changing paths.
+`mode` is not `executionMode`. The latter accepts only `dom` or `cdp`, defaults to `dom` for compatibility, and selects the dispatch path. CDP execution is available for click, hover, drag, type, fill, press_key, and touch; unsupported combinations fail with `INPUT_UNSUPPORTED` instead of silently changing paths.
+
+## DOM vs CDP Input
+
+DOM mode dispatches the same event sequence a real device produces, so most pages cannot tell the difference:
+
+- **Clicks**: `pointerover`/`pointerenter`/`mouseover`/`mouseenter` (only when the virtual pointer moves onto a new element), `pointermove`/`mousemove`, `pointerdown`/`mousedown`, focus, optional hold, `pointerup`/`mouseup`, then `click` (`contextmenu` for right, `auxclick` for middle) carrying coordinates, modifiers, `detail`, and `pointerType`. A canceled `pointerdown` suppresses the mouse events; a canceled `mousedown` keeps focus where it was. Leaving an element fires `pointerout`/`mouseout`/`leave` on it.
+- **Keys**: `keydown` with `key`, `code`, and `keyCode`, `keypress` for character keys, the editing action, then `keyup`. A canceled `keydown` suppresses the character, as in browsers.
+
+DOM events are still untrusted (`isTrusted: false`) and do not count as a user gesture, so Chrome may refuse what a page gates on one: starting audio or media (unless the site already has autoplay engagement), popups, clipboard writes, and fullscreen. When a page needs a real gesture, use `executionMode: "cdp"`, which dispatches trusted input through Chrome. If sound or video stays silent after a DOM click, retry the first interaction with CDP.
+
+## Press and Hold
+
+`holdMs` (0-10000) keeps a mouse button or key pressed between down and up:
+
+```bash
+bbx call input.click '{"target":{"selector":"[data-midi=\"60\"]"},"holdMs":400}'
+bbx call input.press_key '{"key":"q","holdMs":400,"executionMode":"cdp"}'
+```
+
+Use it for long-press menus, sustained notes, and buttons that act while pressed.
+
+## Timed Sequences
+
+Every tool call costs an agent round-trip, so steps sent one call at a time arrive seconds apart, and steps sent as parallel tool calls all land at once. When timing matters (music, games, animations, gestures, quick reactions), send the whole schedule as one `input.perform`:
+
+```bash
+bbx call input.perform '{
+  "executionMode": "cdp",
+  "steps": [
+    {"method":"input.click","params":{"target":{"selector":"[data-midi=\"60\"]"},"holdMs":350},"atMs":0},
+    {"method":"input.click","params":{"target":{"selector":"[data-midi=\"62\"]"},"holdMs":350},"atMs":400},
+    {"method":"input.touch","params":{"points":[{"target":{"selector":"[data-midi=\"60\"]"}},{"target":{"selector":"[data-midi=\"64\"]"}},{"target":{"selector":"[data-midi=\"67\"]"}}],"holdMs":700},"atMs":800}
+  ]
+}'
+```
+
+- Each step is `{ method, params, atMs | delayMs }`; `params` are exactly what the method takes on its own.
+- Allowed step methods: `input.click`, `input.focus`, `input.type`, `input.fill`, `input.press_key`, `input.set_checked`, `input.select_option`, `input.hover`, `input.drag`, `input.touch`, `input.scroll_into_view`, `viewport.scroll`, `dom.wait_for`, `page.wait_for_load_state`.
+- `atMs` is the earliest start measured from the sequence start, so delays never accumulate; `delayMs` waits after the previous step finished. Steps always run in order, so a step whose `atMs` has already passed starts immediately.
+- A top-level `executionMode` applies to every step that supports it unless the step sets its own.
+- Add `dom.wait_for` steps to react to the page without a round-trip, e.g. click, wait for `.menu`, click the item. A wait that times out counts as a failed step.
+- The sequence stops at the first failure with that step's error code and `details.failedStep`, `completed`, and `startedAtMs`. Set `continueOnError: true` to run every step and collect `failures`.
+- `timeoutMs` (default 30000, max 120000) bounds the whole sequence, and waiting steps are capped to the remaining budget. At most 200 steps.
+- The result reports `startedAtMs` (actual start of every step), so you can verify the rhythm without a screenshot. Then verify application state as usual.
+
+## Touch and Multi-Finger Input
+
+A mouse is one pointer, so it cannot press two things at once. `input.touch` puts every point down together, holds them for `holdMs` (default 50), and lifts them together:
+
+```bash
+# Three-finger chord
+bbx call input.touch '{"points":[{"target":{"selector":"#c4"}},{"target":{"selector":"#e4"}},{"target":{"selector":"#g4"}}],"holdMs":600,"executionMode":"cdp"}'
+# Swipe, and pinch-out with viewport coordinates
+bbx call input.touch '{"points":[{"x":300,"y":400,"to":{"x":60,"y":400}}],"holdMs":250}'
+bbx call input.touch '{"points":[{"x":200,"y":300,"to":{"x":120,"y":300}},{"x":240,"y":300,"to":{"x":320,"y":300}}],"holdMs":300,"moveSteps":12}'
+```
+
+- Each point is either `target` (`elementRef`/`selector`, actionability-checked at its center) or viewport `x`/`y`, plus an optional `to` end position. Up to 10 points.
+- Points with `to` move in `moveSteps` (default 10) interpolated steps spread across `holdMs`.
+- DOM mode fires per-finger `pointerdown`/`pointermove`/`pointerup` (`pointerType: "touch"`, distinct `pointerId`, first finger primary) and `touchstart`/`touchmove`/`touchend` with accurate `touches`. A single-finger tap without movement also produces the compatibility `mousedown`/`mouseup`/`click`.
+- CDP mode sends trusted `Input.dispatchTouchEvent` events; fingers are always lifted, even after an error. Pages that only enable touch handlers after feature-detecting a touch screen may still ignore desktop touch input.
+- Result: `pointCount`, per-point `elementRef` and coordinates, and in DOM mode `canceled` (the page called `preventDefault`) and `clicked`.
 
 ## Actionability And Stale Refs
 
@@ -256,7 +320,7 @@ bbx hover el_abc123
 bbx call input.hover '{"target":{"elementRef":"el_abc123"}}'
 ```
 
-**Hold hover for inspection:** set `duration` (ms) to keep hover active before auto-releasing with `mouseleave`:
+**Hold hover for inspection:** set `duration` (ms) to wait after hovering before the call returns. The pointer stays over the element until a later input moves it elsewhere, which then fires `mouseout`/`mouseleave`:
 
 ```bash
 bbx call input.hover '{"target":{"elementRef":"el_abc123"},"duration":2000}'
@@ -283,7 +347,12 @@ With pixel offsets for precise positioning:
 bbx call input.drag '{"source":{"elementRef":"el_src"},"destination":{"elementRef":"el_dst"},"offsetX":5,"offsetY":5}'
 ```
 
-Event sequence: `mousedown → dragstart → drag → dragenter → dragover → drop → dragend → mouseup`.
+DOM mode picks the sequence a browser would use:
+
+- **Draggable sources** (`draggable="true"`, links, images): `pointerdown → mousedown → dragstart → pointercancel → drag → dragenter → dragover → drop → dragend`. `drop` only fires when the destination cancels `dragover`, as real drop zones must; otherwise it gets `dragleave`.
+- **Other sources** (sortable lists, sliders, canvases, and other pointer-driven UIs): `pointerdown/mousedown`, ten interpolated `pointermove/mousemove` steps with the button held across whatever elements lie under the path (with over/out transitions), then `pointerup/mouseup` at the destination.
+
+The result's `strategy` reports `html5` or `pointer`. CDP mode drives a real pointer drag either way.
 
 Typical workflow - reorder a list:
 

package/skills/browser-bridge/references/protocol.md

@@ -85,15 +85,17 @@ omit both for the group index.
 | `styles.get_matched_rules`         | Yes  | -          | inspect     | `styles.read`        | Element ref, class list, and inline style only; not stylesheet cascade data                |
 | `viewport.scroll`                  | Yes  | -          | navigate    | `viewport.control`   | Window or element scroll                                                                   |
 | `viewport.resize`                  | Yes  | CDP        | navigate    | `viewport.control`   | Set viewport via device emulation; `reset: true`                                           |
-| `input.click`                      | Yes  | Optional   | interact    | `automation.input`   | Actionability-aware DOM or CDP click                                                       |
+| `input.click`                      | Yes  | Optional   | interact    | `automation.input`   | Actionability-aware DOM or CDP click; `holdMs` keeps the button pressed                    |
 | `input.focus`                      | Yes  | -          | interact    | `automation.input`   | Actionability-aware DOM focus                                                              |
 | `input.type`                       | Yes  | Optional   | interact    | `automation.input`   | DOM key sequence or CDP text insertion                                                     |
 | `input.fill`                       | Yes  | Optional   | interact    | `automation.input`   | DOM fill strategy or CDP clear/insert; see `mode` versus `executionMode`                   |
-| `input.press_key`                  | Yes  | -          | interact    | `automation.input`   | DOM key event                                                                              |
+| `input.press_key`                  | Yes  | Optional   | interact    | `automation.input`   | DOM key events (with `code`/`keyCode`) or trusted CDP key pair; `holdMs`                   |
 | `input.set_checked`                | Yes  | -          | interact    | `automation.input`   | Checkbox/radio toggle                                                                      |
 | `input.select_option`              | Yes  | -          | interact    | `automation.input`   | Native select by value/label/index                                                         |
 | `input.hover`                      | Yes  | Optional   | interact    | `automation.input`   | DOM hover events or native CDP pointer move                                                |
-| `input.drag`                       | Yes  | Optional   | interact    | `automation.input`   | DOM drag events or native interpolated pointer drag                                        |
+| `input.drag`                       | Yes  | Optional   | interact    | `automation.input`   | HTML5 drag for draggable sources, pointer drag otherwise; or native CDP pointer drag       |
+| `input.touch`                      | Yes  | Optional   | interact    | `automation.input`   | 1-10 simultaneous touch points (chords, taps, swipes, pinches) held for `holdMs`           |
+| `input.perform`                    | Yes  | Per step   | interact    | `automation.input`   | Ordered, timed sequence of input steps executed inside the extension                       |
 | `input.scroll_into_view`           | Yes  | -          | interact    | `automation.input`   | Explicitly scroll target into view before inspect/capture                                  |
 | `screenshot.capture_element`       | Yes  | CDP        | capture     | `screenshot.partial` | Complete element screenshot with explicit completeness metadata                            |
 | `screenshot.capture_region`        | Yes  | CDP        | capture     | `screenshot.partial` | Cropped viewport region in PNG, JPEG, or WebP                                               |
@@ -294,7 +296,7 @@ When `properties` is omitted, `styles.get_computed` returns exactly `display`, `
 
 Input calls preserve an explicit `elementRef`. For selectors, the first actionable match wins; if it is not actionable, Browser Bridge evaluates at most 25 matches and chooses only a uniquely better candidate. It scrolls the selected target if needed and rechecks visibility, disabled/inert state, rendered bounds, and pointer hit testing before dispatch. Failures use `ELEMENT_NOT_FOUND`, `ELEMENT_NOT_ACTIONABLE`, `ELEMENT_OBSCURED`, or `ELEMENT_AMBIGUOUS` with bounded details.
 
-Successful targeted click, focus, type, fill, press-key, checked-state, option-selection, hover, and drag results include `resolution` (`strategy`, candidate/evaluated counts, scrolling, hit test, and recovery fields) and `execution` (`requestedMode`, `actualMode`, `fallbackReason`, `debuggerUsed`, and coordinates). `cdp.dispatch_key_event`/MCP `cdp_press_key` and `input.scroll_into_view` use separate response contracts. `executionMode` is the dispatch path and accepts only `dom` or `cdp`, defaulting to `dom` for compatibility. CDP is supported only by click, hover, drag, type, and fill; unsupported combinations return `INPUT_UNSUPPORTED` instead of falling back silently.
+Successful targeted click, focus, type, fill, press-key, checked-state, option-selection, hover, and drag results include `resolution` (`strategy`, candidate/evaluated counts, scrolling, hit test, and recovery fields) and `execution` (`requestedMode`, `actualMode`, `fallbackReason`, `debuggerUsed`, and coordinates). `cdp.dispatch_key_event`/MCP `cdp_press_key` and `input.scroll_into_view` use separate response contracts. `executionMode` is the dispatch path and accepts only `dom` or `cdp`, defaulting to `dom` for compatibility. CDP is supported by click, hover, drag, type, fill, press_key, and touch; unsupported combinations return `INPUT_UNSUPPORTED` instead of falling back silently. DOM events mirror real device event order (pointer events, boundary transitions, `code`/`keyCode`) but are untrusted, so Chrome may refuse gesture-gated features such as audio/media start; use CDP for those.
 
 `input.fill.mode` is separate: `auto`, `setter`, and `keystrokes` choose the DOM fill strategy. `mode: "auto"` may fall back from the setter to keystrokes and reports the used `mode`; it does not select CDP. With `executionMode: "cdp"`, fill uses native clear/text dispatch and reports `mode: "cdp"`.
 
@@ -313,13 +315,30 @@ bbx call input.hover '{"target":{"elementRef":"el_abc123"},"duration":1000}'
 
 ### input.drag
 
-The DOM path dispatches `mousedown → dragstart → drag → dragenter → dragover → drop → dragend → mouseup`. The CDP path performs a bounded interpolated native pointer drag and guarantees a release attempt after failure. Both accept source, destination, and optional destination offsets.
+For natively draggable sources the DOM path dispatches `pointerdown → mousedown → dragstart → pointercancel → drag → dragenter → dragover → drop → dragend` (`drop` only when the destination cancels `dragover`). Other sources get a pointer drag: press, ten interpolated moves with the button held, release at the destination. `strategy` reports `html5` or `pointer`. The CDP path performs a bounded interpolated native pointer drag and guarantees a release attempt after failure. Both accept source, destination, and optional destination offsets.
 
 ```bash
 bbx call input.drag '{"source":{"elementRef":"el_src"},"destination":{"elementRef":"el_dst"}}'
 bbx call input.drag '{"source":{"elementRef":"el_src"},"destination":{"elementRef":"el_dst"},"offsetX":10,"offsetY":10}'
 ```
 
+### input.touch
+
+Put 1-10 fingers down at once, hold them for `holdMs` (default 50), optionally move points that have a `to` end position over `moveSteps` (default 10), then lift them. Each point is `{ target }` or viewport `{ x, y }`. DOM mode fires per-finger pointer events (`pointerType: "touch"`) and touch events; CDP mode uses trusted `Input.dispatchTouchEvent`.
+
+```bash
+bbx call input.touch '{"points":[{"target":{"selector":"#c4"}},{"target":{"selector":"#e4"}}],"holdMs":500,"executionMode":"cdp"}'
+bbx call input.touch '{"points":[{"x":300,"y":400,"to":{"x":60,"y":400}}],"holdMs":250}'
+```
+
+### input.perform
+
+Run `steps: [{ method, params, atMs | delayMs }]` in order inside the extension, so timing does not depend on agent round-trips. Step methods: input click/focus/type/fill/press_key/set_checked/select_option/hover/drag/touch/scroll_into_view, `viewport.scroll`, `dom.wait_for`, and `page.wait_for_load_state`. `atMs` is measured from the sequence start (no drift); `delayMs` follows the previous step. A top-level `executionMode` applies to steps that support it. The sequence stops at the first failed step (including a timed-out `dom.wait_for`) with that step's code and `details.failedStep`, unless `continueOnError: true`. `timeoutMs` defaults to 30000 (max 120000); at most 200 steps. Success returns `completed`, `total`, `elapsedMs`, `startedAtMs`, and `failures`.
+
+```bash
+bbx call input.perform '{"executionMode":"cdp","steps":[{"method":"input.click","params":{"target":{"selector":"#c4"},"holdMs":300},"atMs":0},{"method":"input.click","params":{"target":{"selector":"#d4"},"holdMs":300},"atMs":400}]}'
+```
+
 ### input.scroll_into_view
 
 Explicitly scroll an element into the visible viewport before inspecting, hovering, or capturing it.