amalgm 0.1.93 → 0.1.94

package/runtime/scripts/amalgm-mcp/browser/engine.js

@@ -111,9 +111,30 @@ async function press(args = {}, context) {
   return sessionInfo(session, { pressed: args.key });
 }
 
+/**
+ * Native <select> needs a real selection action — synthetic clicks and arrow
+ * keys do not move it (verified in stress testing). Value matching follows
+ * agent-browser: option value, then visible label.
+ */
+async function select(args = {}, context) {
+  const session = sessionFor(args, context);
+  await run(session, ['select', String(args.target || ''), String(args.value ?? '')], { context });
+  return sessionInfo(session, { selected: args.target, value: args.value });
+}
+
 async function evaluate(args = {}, context) {
   const session = sessionFor(args, context);
-  const result = await run(session, ['eval', args.script || ''], { context });
+  const script = args.script || '';
+  let result;
+  try {
+    result = await run(session, ['eval', script], { context });
+  } catch (err) {
+    // The script is evaluated as an expression; a top-level `return` is the
+    // one natural idiom that breaks. Re-run it as a function body instead of
+    // making every agent learn the distinction.
+    if (!/illegal return/i.test(String(err?.message || ''))) throw err;
+    result = await run(session, ['eval', `(() => { ${script} })()`], { context });
+  }
   const data = result?.data ?? result;
   // agent-browser wraps eval results as { origin, result }.
   const value = data && typeof data === 'object' && 'result' in data ? data.result : data;
@@ -153,6 +174,14 @@ async function passthrough(args = {}, context) {
   const session = sessionFor(args, context);
   const commandArgs = (args.args || []).map(String);
   if (!commandArgs.length) throw new Error('args is required, e.g. ["scroll", "down"] or ["get", "text", "@e1"]');
+  if (backend.mode() === 'attached' && commandArgs[0] === 'tab' && commandArgs.length > 1) {
+    // In the desktop app a session IS its surface; hopping targets is how a
+    // session ends up driving another session's page. Listing stays allowed.
+    throw new Error(
+      'Tab switching is managed per session in the desktop app — each session drives its own surface. '
+      + 'Use a different `session` id for a second page.',
+    );
+  }
   const result = await run(session, commandArgs, { timeoutMs: args.timeoutMs || 60_000, context });
   return { ...sessionInfo(session), result: result?.data ?? result };
 }
@@ -278,14 +307,19 @@ async function close(args = {}, context) {
   }
   // Tear down this session's daemon. In attached mode this only disconnects
   // from the app's chromium (verified live: the app, its webviews, and other
-  // sessions' daemons survive) — the visible surface belongs to the UI and
-  // stays open for the user. Without this, every attached session leaks a
+  // sessions' daemons survive). Without this, every attached session leaks a
   // daemon process for the life of the machine.
   try {
     await cli.runCli(['close'], attach.cliOptions(session, { timeoutMs: 15_000 }));
   } catch {
     // No daemon (never started, or already gone) — nothing to tear down.
   }
+  // Tell the UI to unmount the splitview/tab. Each surface is a full
+  // renderer process; ended sessions must not accumulate them (ten zombie
+  // webviews were live in the app when this was written).
+  if (sessions.attachedSessions.has(session) || sessions.knownSessions.has(session)) {
+    attach.requestSurfaceClose(session);
+  }
   sessions.attachedSessions.delete(session);
   sessions.knownSessions.delete(session);
 }
@@ -312,6 +346,7 @@ module.exports = {
   press,
   saveState,
   screenshot,
+  select,
   snapshot,
   state,
   wait,

package/runtime/scripts/amalgm-mcp/browser/recorder.js

@@ -3,12 +3,11 @@
 /**
  * Session recorder: capture any browser session to a local WebM file.
  *
- * Frames come from capture.js (CDP Page.startScreencast on a target that
- * actually rasters — the page itself headless, the app window cropped to the
- * webview rectangle when attached) and pipe into ffmpeg. Recordings are
- * local-only: nothing leaves this computer, and in attached mode the crop
- * runs inside ffmpeg before any frame reaches disk, so the file only ever
- * contains the page — not the app around it.
+ * Frames come from capture.js (CDP Page.startScreencast on the session's own
+ * page target — the headless page, or the attached <webview> guest itself)
+ * and pipe into ffmpeg. The frames are the page and nothing else, so no
+ * cropping is ever needed; recordings are local-only and nothing leaves this
+ * computer.
  *
  * This is deliberately NOT agent-browser's `record` command:
  *  - `record` needs ffmpeg on the daemon's PATH at daemon-spawn time, and
@@ -183,7 +182,8 @@ async function start(args = {}, context = {}) {
 
   const file = recordingFile(args, context, session);
   const fps = clampFps(args.fps);
-  const filters = [source.crop, 'pad=ceil(iw/2)*2:ceil(ih/2)*2'].filter(Boolean).join(',');
+  // VP8 wants even dimensions; screencast frames can be odd-sized.
+  const filters = 'pad=ceil(iw/2)*2:ceil(ih/2)*2';
 
   const ffmpeg = spawn(binary, ffmpegArgs({ fps, filters, file }), { stdio: ['pipe', 'ignore', 'pipe'] });
   let ffmpegErr = '';
@@ -251,7 +251,7 @@ async function start(args = {}, context = {}) {
     fps,
     mimeType: 'video/webm',
     backend: backend.mode(),
-    cropped: Boolean(source.crop),
+    source: source.guest ? 'visible surface' : 'page',
   };
 }
 
@@ -283,21 +283,26 @@ async function stop(args = {}, context = {}) {
     }
   });
 
-  const durationMs = Date.now() - recording.startedAt;
+  const wallMs = Date.now() - recording.startedAt;
   const { received, encoded, skippedTicks } = recording.sampler.stats;
   const bytes = fs.existsSync(recording.file) ? fs.statSync(recording.file).size : 0;
 
   if (encoded === 0 || bytes === 0) {
     try { fs.rmSync(recording.file, { force: true }); } catch {}
     throw new Error(encoded === 0
-      ? 'No frames captured — the surface never produced a pixel while recording '
-        + '(it likely went off screen; in the desktop app the Amalgm window must stay on screen).'
+      ? 'No frames captured — the surface never produced a pixel while recording. '
+        + 'In the desktop app its tab likely stayed hidden; retry (the app refocuses the surface automatically).'
       : `ffmpeg failed (exit ${exitCode}): ${recording.ffmpegErr()}`);
   }
 
   // WebM is cluster-streamed: even a force-killed encode leaves the frames
   // written so far playable. Captured video beats a deleted file — return it
   // and say what happened instead of throwing it away.
+  //
+  // Two durations, named for what they measure: the file plays for
+  // videoSeconds (frames ÷ fps); the recording spanned wallSeconds of real
+  // time. They differ when frames starved — conflating them under one
+  // "duration" is how a 25-second number got reported for an 11-second file.
   const result = {
     session,
     path: recording.file,
@@ -307,7 +312,8 @@ async function stop(args = {}, context = {}) {
     framesReceived: received,
     skippedTicks,
     fps: recording.fps,
-    durationMs,
+    videoSeconds: Math.round((encoded / recording.fps) * 10) / 10,
+    wallSeconds: Math.round(wallMs / 100) / 10,
     mimeType: 'video/webm',
   };
   if (exitCode !== 0) {
@@ -332,7 +338,15 @@ function list(args = {}, context = {}) {
       })
       .sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
   } catch {}
-  return { dir, recordings: entries, activeSession: active.has(session) ? session : null };
+  // activeSessions is global on purpose: a recording from another session
+  // writing to disk while this one reads "no active recording" looks like a
+  // zombie encoder unless the listing says who owns it.
+  return {
+    dir,
+    recordings: entries,
+    activeSession: active.has(session) ? session : null,
+    activeSessions: [...active.keys()],
+  };
 }
 
 function isActive(session) {

package/runtime/scripts/amalgm-mcp/browser/tools.js

@@ -3,8 +3,9 @@
 /**
  * Browser core actions — the thin surface.
  *
- * Ten verbs built on the agent-browser CLI (vercel-labs/agent-browser). The
- * loop is: open → snapshot (@refs) → click/fill (@ref) → re-snapshot.
+ * Eleven verbs built on the agent-browser CLI (vercel-labs/agent-browser).
+ * The loop is: open → snapshot (@refs) → click/fill/select (@ref) →
+ * re-snapshot.
  * Everything else agent-browser can do (scroll, hover, cookies, network
  * mocking, traces, diffs, React inspection, ...) is reachable through `cli`
  * without widening this schema.
@@ -76,7 +77,7 @@ module.exports = [
   },
   {
     name: 'screenshot',
-    description: 'Screenshot the page (PNG). Prefer snapshot for driving the page; use this to verify visuals. fullPage captures the whole scroll height when headless; in the desktop app you always get the visible surface.',
+    description: 'Screenshot the page (PNG). Prefer snapshot for driving the page; use this to verify visuals. Image coordinates match cua_* input 1:1. fullPage captures the whole scroll height when headless; in the desktop app you get the visible surface (works even while the app window is hidden).',
     inputSchema: {
       type: 'object',
       properties: {
@@ -141,7 +142,7 @@ module.exports = [
   },
   {
     name: 'press',
-    description: 'Press a key or combination at the focused element, e.g. "Enter", "Escape", "Tab", "Control+a".',
+    description: 'Press a key or combination at the focused element, e.g. "Enter", "Escape", "Tab", "Control+a". For native <select> dropdowns use the select action — key presses do not move them.',
     inputSchema: {
       type: 'object',
       properties: { key: { type: 'string', description: 'Key or combination' }, ...sessionProperty },
@@ -157,9 +158,31 @@ module.exports = [
       }
     },
   },
+  {
+    name: 'select',
+    description: 'Choose an option in a <select> dropdown by value or visible label. Clicks and key presses cannot drive native dropdowns — this can.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        ...targetProperty,
+        value: { type: 'string', description: 'Option value or visible label to select' },
+        ...sessionProperty,
+      },
+      required: ['target', 'value'],
+    },
+    async handler(args, ctx) {
+      if (!args.target || typeof args.value !== 'string') return errorResult('target and value are required');
+      try {
+        const result = await engine.select(args, ctx);
+        return textResult(`Selected "${args.value}" in ${args.target}\nSession: ${result.session}`);
+      } catch (err) {
+        return errorResult(`Select failed: ${err.message}`);
+      }
+    },
+  },
   {
     name: 'eval',
-    description: 'Run JavaScript in the page and return the result — the escape hatch for reading or mutating anything the page knows.',
+    description: 'Run JavaScript in the page and return the result — the escape hatch for reading or mutating anything the page knows. Both bare expressions and function bodies with `return` work.',
     inputSchema: {
       type: 'object',
       properties: { script: { type: 'string', description: 'JavaScript to evaluate' }, ...sessionProperty },
@@ -200,7 +223,7 @@ module.exports = [
   },
   {
     name: 'cli',
-    description: 'Run any agent-browser CLI command against this session — the full surface beyond the core verbs: ["scroll","down"], ["hover","@e3"], ["back"], ["tab"], ["get","html","@e1"], ["cookies","get"], ["network","requests"], ["find","role","button","click","--name","Submit"], and more. Run ["--help"] for the command list.',
+    description: 'Run any agent-browser CLI command against this session — the full surface beyond the core verbs: ["scroll","down"], ["hover","@e3"], ["back"], ["get","html","@e1"], ["cookies","get"], ["network","requests"], ["find","role","button","click","--name","Submit"], and more. Run ["--help"] for the command list. Commands run against this session\'s own page; in the desktop app, tab-switching to other surfaces is refused.',
     inputSchema: {
       type: 'object',
       properties: {

package/runtime/scripts/amalgm-mcp/fs/rest.js

@@ -17,6 +17,31 @@ const TEXT_EXTENSIONS = new Set([
   'c', 'cpp', 'cs', 'php', 'scss', 'log', 'ini', 'cfg', 'conf',
 ]);
 
+const MIME_TYPES = {
+  avif: 'image/avif',
+  bmp: 'image/bmp',
+  csv: 'text/csv; charset=utf-8',
+  doc: 'application/msword',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  gif: 'image/gif',
+  html: 'text/html; charset=utf-8',
+  ico: 'image/x-icon',
+  jpeg: 'image/jpeg',
+  jpg: 'image/jpeg',
+  json: 'application/json; charset=utf-8',
+  md: 'text/markdown; charset=utf-8',
+  mov: 'video/quicktime',
+  mp4: 'video/mp4',
+  pdf: 'application/pdf',
+  png: 'image/png',
+  svg: 'image/svg+xml; charset=utf-8',
+  txt: 'text/plain; charset=utf-8',
+  webm: 'video/webm',
+  webp: 'image/webp',
+  xls: 'application/vnd.ms-excel',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+};
+
 const IS_LOCAL_MACHINE = process.env.AMALGM_LOCAL_MODE === 'true';
 const CONTAINER_ROOT = process.env.AMALGM_WORKSPACE_ROOT || '/workspace';
 const MAX_READ_BYTES = Number.parseInt(process.env.AMALGM_FS_MAX_READ_BYTES || '', 10) || 25 * 1024 * 1024;
@@ -282,6 +307,50 @@ function classifyFile(targetPath) {
   };
 }
 
+function mimeTypeForPath(targetPath) {
+  const { ext, isText } = classifyFile(targetPath);
+  if (MIME_TYPES[ext]) return MIME_TYPES[ext];
+  return isText ? 'text/plain; charset=utf-8' : 'application/octet-stream';
+}
+
+function inlineFilename(targetPath) {
+  return path.basename(targetPath).replace(/["\\\r\n]/g, '_') || 'file';
+}
+
+function sendContentError(res, statusCode, message) {
+  if (!res.headersSent) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+  }
+  res.end(JSON.stringify({ error: message }));
+}
+
+function parseByteRange(rangeHeader, size) {
+  if (!rangeHeader) return null;
+  const header = String(rangeHeader).trim();
+  const match = /^bytes=(\d*)-(\d*)$/.exec(header);
+  if (!match || size <= 0) return { invalid: true };
+
+  const [, startRaw, endRaw] = match;
+  if (!startRaw && !endRaw) return { invalid: true };
+
+  let start;
+  let end;
+
+  if (!startRaw) {
+    const suffixLength = Number.parseInt(endRaw, 10);
+    if (!Number.isFinite(suffixLength) || suffixLength <= 0) return { invalid: true };
+    start = Math.max(size - suffixLength, 0);
+    end = size - 1;
+  } else {
+    start = Number.parseInt(startRaw, 10);
+    end = endRaw ? Number.parseInt(endRaw, 10) : size - 1;
+    if (!Number.isFinite(start) || !Number.isFinite(end)) return { invalid: true };
+  }
+
+  if (start < 0 || start >= size || end < start) return { invalid: true };
+  return { start, end: Math.min(end, size - 1) };
+}
+
 function directorySnapshot(targetPath) {
   const entries = fs.readdirSync(targetPath, { withFileTypes: true });
   const files = entries
@@ -524,6 +593,72 @@ async function handleRead(query, sendJson) {
   }
 }
 
+async function handleContent(query, req, res) {
+  try {
+    const targetPath = await resolveSafePath(query.path);
+    const stats = await fs.promises.stat(targetPath);
+    if (stats.isDirectory()) {
+      return sendContentError(res, 400, 'Cannot read a directory');
+    }
+
+    const totalSize = stats.size;
+    const baseHeaders = {
+      'Accept-Ranges': 'bytes',
+      'Cache-Control': 'no-store',
+      'Content-Disposition': `inline; filename="${inlineFilename(targetPath)}"`,
+      'Content-Type': mimeTypeForPath(targetPath),
+    };
+    const range = parseByteRange(req.headers.range, totalSize);
+
+    if (range?.invalid) {
+      res.writeHead(416, {
+        ...baseHeaders,
+        'Content-Range': `bytes */${totalSize}`,
+      });
+      res.end();
+      return;
+    }
+
+    if (totalSize === 0) {
+      res.writeHead(200, {
+        ...baseHeaders,
+        'Content-Length': '0',
+      });
+      res.end();
+      return;
+    }
+
+    const start = range ? range.start : 0;
+    const end = range ? range.end : totalSize - 1;
+    const contentLength = end - start + 1;
+    const statusCode = range ? 206 : 200;
+    const headers = {
+      ...baseHeaders,
+      'Content-Length': String(contentLength),
+      ...(range ? { 'Content-Range': `bytes ${start}-${end}/${totalSize}` } : {}),
+    };
+
+    res.writeHead(statusCode, headers);
+    if ((req.method || 'GET').toUpperCase() === 'HEAD') {
+      res.end();
+      return;
+    }
+
+    const stream = fs.createReadStream(targetPath, { start, end });
+    stream.on('error', (error) => {
+      if (!res.headersSent) {
+        sendContentError(res, statusForError(error), error instanceof Error ? error.message : 'Failed to read file');
+        return;
+      }
+      res.destroy(error);
+    });
+    stream.pipe(res);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to read file';
+    sendContentError(res, statusForError(error), message);
+  }
+}
+
 async function handleWrite(body, sendJson) {
   try {
     const targetPath = await resolveSafePath(body.path, { forCreate: true });
@@ -612,6 +747,7 @@ async function handleRename(body, sendJson) {
 }
 
 module.exports = {
+  handleContent,
   handleDelete,
   handleList,
   handleMkdir,

package/runtime/scripts/amalgm-mcp/server/routes/files.js

@@ -11,6 +11,10 @@ async function handleFileRoutes(ctx) {
     fsRest.handleRead(ctx.getQuery(), ctx.sendJson);
     return true;
   }
+  if (ctx.pathname === '/fs/content' && (ctx.method === 'GET' || ctx.method === 'HEAD')) {
+    await fsRest.handleContent(ctx.getQuery(), ctx.req, ctx.res);
+    return true;
+  }
   if (ctx.pathname === '/fs/write' && ctx.method === 'POST') {
     fsRest.handleWrite(await ctx.readJsonBody(), ctx.sendJson);
     return true;

package/runtime/scripts/amalgm-mcp/tests/browser-capture.test.js

@@ -6,28 +6,14 @@ const http = require('node:http');
 
 const capture = require('../browser/capture');
 
-test('clipFor turns a webview rect into integer CSS-px clip bounds', () => {
-  // 411.5 + 868.75 overhangs the 1280px viewport by a rounding hair — the
-  // clip clamps to the viewport edge (the overhang captures as a black bar).
-  const clip = capture.clipFor({ x: 411.5, y: 52.25, width: 868.75, height: 781.5, vw: 1280, vh: 834 });
-  assert.deepEqual(clip, { x: 412, y: 52, width: 868, height: 782, scale: 1 });
-  // Negative origins (mid-animation surfaces) clamp to the viewport.
-  assert.equal(capture.clipFor({ x: -4, y: 0, width: 100, height: 100 }).x, 0);
-  // A splitview sliding open can report a rect mostly past the right edge.
-  const sliding = capture.clipFor({ x: 1200, y: 0, width: 700, height: 600, vw: 1280, vh: 800 });
-  assert.deepEqual(sliding, { x: 1200, y: 0, width: 80, height: 600, scale: 1 });
-  // Retina displays render captures at devicePixelRatio; scale divides it
-  // back out so image pixels map 1:1 onto cua input coordinates.
-  assert.equal(capture.clipFor({ x: 0, y: 0, width: 100, height: 100, dpr: 2 }).scale, 0.5);
-});
-
-test('cropFilterFor crops by viewport fraction so any frame resolution works', () => {
-  const filter = capture.cropFilterFor({ x: 320, y: 0, width: 640, height: 600, vw: 1280, vh: 800 });
-  // width 640/1280=0.5, height 600/800=0.75, x 320/1280=0.25, y 0.
-  assert.equal(filter, 'crop=floor(iw*0.500000/2)*2:floor(ih*0.750000/2)*2:floor(iw*0.250000):floor(ih*0.000000)');
-  // Fractions clamp into [0, 1] even for slightly-out-of-viewport rects.
-  assert.match(capture.cropFilterFor({ x: -10, y: 0, width: 2000, height: 100, vw: 1000, vh: 500 }),
-    /^crop=floor\(iw\*1\.000000\/2\)\*2/);
+test('cssViewportClip sizes the capture in CSS pixels for cua 1:1 mapping', async () => {
+  const client = {
+    call: async () => ({ result: { value: JSON.stringify({ w: 726, h: 767, dpr: 2 }) } }),
+  };
+  assert.deepEqual(await capture.cssViewportClip(client), { x: 0, y: 0, width: 726, height: 767, scale: 0.5 });
+  // A surface with no laid-out viewport yet must refuse, not capture nothing.
+  const empty = { call: async () => ({ result: { value: JSON.stringify({ w: 0, h: 0, dpr: 2 }) } }) };
+  await assert.rejects(() => capture.cssViewportClip(empty), /no viewport/);
 });
 
 test('pageTargets keeps only capturable page targets', () => {
@@ -49,32 +35,59 @@ test('rectScript identifies the session surface and never guesses', () => {
   assert.match(script, /https:\/\/example\.com\//);
   // No current URL → the byUrl branch is disabled, not matching everything.
   const bare = capture.rectScript('amalgm-bsid-abc', '');
-  assert.match(bare, /"" \? views\.find/);
+  assert.match(bare, /"" \? views\.filter/);
   // "The only webview" is how one chat's capture reads another chat's page —
   // an unidentified surface must resolve to null, never to a guess.
   assert.doesNotMatch(script, /views\.length === 1/);
-  // The embedder's visibilityState rides along: full geometry with a hidden
-  // window is exactly the state captures must be able to name.
+  // Remounts leave stale 0x0 copies of a session's surface behind; the match
+  // with on-screen geometry must win or a live surface reads as "hidden".
+  assert.match(script, /r\.width && r\.height/);
   assert.match(script, /embedderVisibility/);
-  assert.match(script, /src: match\.src/);
 });
 
-test('starvationReason names the app window state', () => {
-  assert.match(capture.starvationReason({ embedderVisibility: 'hidden' }), /hidden or minimized/);
-  assert.match(capture.starvationReason({ embedderVisibility: null }), /stopped rendering/);
+test('rectScript prefers the on-screen copy over a stale 0x0 duplicate', async () => {
+  // Execute the script against a fake DOM: two elements match the marker —
+  // the first (a stale remnant) has no geometry, the second is live.
+  const script = capture.rectScript('amalgm-bsid-abc', '');
+  const fakeViews = [
+    {
+      getAttribute: (name) => (name === 'data-amalgm-surface' ? 'about:blank#amalgm-bsid-abc' : ''),
+      src: 'about:blank#amalgm-bsid-abc',
+      getBoundingClientRect: () => ({ x: 0, y: 0, width: 0, height: 0 }),
+    },
+    {
+      getAttribute: (name) => (name === 'data-amalgm-surface' ? 'about:blank#amalgm-bsid-abc' : ''),
+      src: 'https://example.com/',
+      getBoundingClientRect: () => ({ x: 700, y: 80, width: 726, height: 767 }),
+    },
+  ];
+  const result = new Function('document', 'window', `return (${script})`)(
+    { querySelectorAll: () => fakeViews, visibilityState: 'visible' },
+    { innerWidth: 1470, innerHeight: 920, devicePixelRatio: 2 },
+  );
+  const rect = JSON.parse(result);
+  assert.equal(rect.width, 726);
+  assert.equal(rect.src, 'https://example.com/');
+});
+
+test('starvationReason names the real precondition: the surface tab', () => {
+  const reason = capture.starvationReason();
+  assert.match(reason, /tab in the Amalgm app is hidden/);
+  assert.match(reason, /AMALGM_BROWSER_BACKEND=cli/);
+  // Window state is irrelevant since the app keeps attached surfaces
+  // compositing while hidden — the message must not send users window-hunting.
+  assert.doesNotMatch(reason, /window/i);
 });
 
 test('assertCapturable converts a starved probe into a named refusal', async () => {
   const starvedClient = { call: () => new Promise(() => {}) };
-  // capture.js wraps the probe in its own deadline via cdp.call timeout — here
-  // the fake client never resolves, so rely on the call-site deadline shape:
   const probe = capture.assertCapturable(
     { call: (m, p, t) => capture.deadline(new Promise(() => {}), 50, m) },
-    { clip: { x: 0, y: 0, width: 10, height: 10 }, embedderVisibility: 'hidden' },
+    { guest: true },
   );
-  await assert.rejects(() => probe, /Cannot capture this surface: .*hidden or minimized/);
+  await assert.rejects(() => probe, /Cannot capture this surface: .*tab in the Amalgm app is hidden/);
   // Headless page targets raster unconditionally — no probe, no rejection.
-  await capture.assertCapturable(starvedClient, { clip: null });
+  await capture.assertCapturable(starvedClient, { guest: false });
 });
 
 test('targetListUrl accepts bare ports and ws urls', () => {