takomi 2.1.39 → 2.1.41

package/plugins/takomi-flow/scripts/lib/mcp-tools.mjs

@@ -1,150 +1,165 @@
-import * as z from 'zod/v4';
-import * as api from './api.mjs';
-
-export function registerTools(server) {
-  const register = toolRegister(server);
-  register('takomi_flow_capabilities', 'List supported TakomiFlow kinds, modes, outputs, commands, and safety rules.', {}, () => api.capabilities());
-  register('takomi_flow_doctor', 'Check local TakomiFlow readiness: Playwright, FFmpeg, FFprobe, profile path, and output path.', {
-    profileDir: z.string().optional(),
-    outputDir: z.string().optional(),
-  }, args => api.doctor(args));
-  register('takomi_flow_audit', 'Summarize TakomiFlow readiness, safe actions, gated actions, and recent run state.', {
-    profileDir: z.string().optional(),
-    outputDir: z.string().optional(),
-    limit: z.number().int().positive().optional(),
-  }, args => api.audit(args));
-  register('takomi_flow_examples', 'Return TakomiFlow example requests and downstream handoff patterns.', {
-    name: z.string().optional(),
-  }, args => api.examples(args));
-  register('takomi_flow_plan', 'Create a safe agent execution plan with MCP calls, CLI fallbacks, gates, and expected outputs.', {
-    kind: z.enum(['video', 'image']),
-    prompt: z.string(),
-    variations: z.number().int().positive().optional(),
-    aspectRatio: z.string().optional(),
-    durationSeconds: z.number().positive().optional(),
-    mode: z.string().optional(),
-    modelHint: z.string().optional(),
-    outputDir: z.string().optional(),
-    allowSpend: z.boolean().optional(),
-    extractFrames: z.number().int().nonnegative().optional(),
-    sourceAssets: z.array(z.string()).optional(),
-    submit: z.boolean().optional(),
-    targetDir: z.string().optional(),
-  }, args => api.plan(args));
-  registerRequestTools(register);
-  registerBrowserTools(register);
-  registerResultTools(register);
-}
-
-function registerRequestTools(register) {
-  register('takomi_flow_template', 'Return or write a video/image request template.', {
-    kind: z.enum(['video', 'image']).optional(),
-    outputDir: z.string().optional(),
-  }, args => api.template(args));
-  const requestShape = {
-    kind: z.enum(['video', 'image']),
-    prompt: z.string(),
-    variations: z.number().int().positive().optional(),
-    aspectRatio: z.string().optional(),
-    durationSeconds: z.number().positive().optional(),
-    mode: z.string().optional(),
-    modelHint: z.string().optional(),
-    outputDir: z.string().optional(),
-    allowSpend: z.boolean().optional(),
-    extractFrames: z.number().int().nonnegative().optional(),
-    sourceAssets: z.array(z.string()).optional(),
-    notes: z.string().optional(),
-  };
-  register('takomi_flow_prepare', 'Create a prepared request JSON file for a Flow image or video generation.', requestShape, args => api.prepare(args));
-  register('takomi_flow_workflow', 'Prepare, validate, and optionally submit a Flow image/video generation from one agent call.', {
-    ...requestShape,
-    submit: z.boolean().optional(),
-    allowBrowser: z.boolean().optional(),
-    profileDir: z.string().optional(),
-    browserChannel: z.string().optional(),
-    cdpUrl: z.string().optional(),
-    headless: z.boolean().optional(),
-  }, args => api.workflow(args));
-  register('takomi_flow_validate', 'Validate a TakomiFlow request JSON before opening Flow or spending credits.', {
-    request: z.string(),
-  }, args => api.validate(args));
-}
-
-function registerBrowserTools(register) {
-  register('takomi_flow_observe', 'Open Flow and observe UI controls/screenshots. Requires allowBrowser=true.', {
-    allowBrowser: z.boolean(),
-    profileDir: z.string().optional(),
-    outputDir: z.string().optional(),
-    browserChannel: z.string().optional(),
-    cdpUrl: z.string().optional(),
-    headless: z.boolean().optional(),
-  }, args => requireBrowser(args, () => api.observe(args)));
-  register('takomi_flow_generate', 'Run guarded Flow generation from a request file. Requires allowBrowser=true and request allowSpend=true to submit.', {
-    allowBrowser: z.boolean(),
-    request: z.string(),
-    profileDir: z.string().optional(),
-    browserChannel: z.string().optional(),
-    cdpUrl: z.string().optional(),
-    headless: z.boolean().optional(),
-  }, args => requireBrowser(args, () => api.generate(args)));
-}
-
-function registerResultTools(register) {
-  register('takomi_flow_selftest', 'Run deterministic no-spend TakomiFlow checks, including media catalog/frame extraction.', {
-    outputDir: z.string().optional(),
-  }, args => api.selftest(args));
-  register('takomi_flow_inspect', 'Summarize a TakomiFlow run.json or run directory.', { run: z.string() }, args => api.inspect(args));
-  register('takomi_flow_latest', 'Summarize the latest TakomiFlow run under an output directory.', {
-    outputDir: z.string().optional(),
-  }, args => api.latest(args));
-  register('takomi_flow_runs', 'List recent TakomiFlow runs under an output directory.', {
-    outputDir: z.string().optional(),
-    limit: z.number().int().positive().optional(),
-  }, args => api.runs(args));
-  register('takomi_flow_assets', 'Catalog downloaded run assets and optionally extract video review frames.', {
-    run: z.string(),
-    frames: z.number().int().nonnegative().optional(),
-  }, args => api.assets(args));
-  register('takomi_flow_review', 'Inspect a run, catalog assets, extract review frames, and write a Markdown handoff.', {
-    run: z.string(),
-    frames: z.number().int().nonnegative().optional(),
-    reportPath: z.string().optional(),
-  }, args => api.review(args));
-  register('takomi_flow_collect', 'Copy reviewed assets, frames, report, and manifest into a downstream target folder.', {
-    run: z.string(),
-    targetDir: z.string(),
-    frames: z.number().int().nonnegative().optional(),
-    includeFrames: z.boolean().optional(),
-    reportPath: z.string().optional(),
-  }, args => api.collect(args));
-  register('takomi_flow_report', 'Create a Markdown report for a run or recent TakomiFlow history.', {
-    run: z.string().optional(),
-    outputDir: z.string().optional(),
-    limit: z.number().int().positive().optional(),
-    reportPath: z.string().optional(),
-  }, args => api.report(args));
-}
-
-function toolRegister(server) {
-  return (name, description, inputSchema, handler) => {
-    server.registerTool(name, { description, inputSchema }, async args => {
-      const structuredContent = await handler(args || {});
-      return {
-        content: [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
-        structuredContent,
-      };
-    });
-  };
-}
-
-function requireBrowser(args, handler) {
-  if (!args?.allowBrowser) {
-    return {
-      schemaVersion: 1,
-      status: 'blocked',
-      errors: [],
-      manualActions: ['Set allowBrowser=true to permit TakomiFlow to open or drive a browser.'],
-    };
-  }
-  return handler();
-}
+import * as z from 'zod/v4';
+import * as api from './api.mjs';
+
+export function registerTools(server) {
+  const register = toolRegister(server);
+  register('takomi_flow_capabilities', 'List supported TakomiFlow kinds, modes, outputs, commands, and safety rules.', {}, () => api.capabilities());
+  register('takomi_flow_doctor', 'Check local TakomiFlow readiness: Playwright, FFmpeg, FFprobe, profile path, and output path.', {
+    profileDir: z.string().optional(),
+    outputDir: z.string().optional(),
+  }, args => api.doctor(args));
+  register('takomi_flow_audit', 'Summarize TakomiFlow readiness, safe actions, gated actions, and recent run state.', {
+    profileDir: z.string().optional(),
+    outputDir: z.string().optional(),
+    limit: z.number().int().positive().optional(),
+  }, args => api.audit(args));
+  register('takomi_flow_examples', 'Return TakomiFlow example requests and downstream handoff patterns.', {
+    name: z.string().optional(),
+  }, args => api.examples(args));
+  register('takomi_flow_plan', 'Create a safe agent execution plan with MCP calls, CLI fallbacks, gates, and expected outputs.', {
+    kind: z.enum(['video', 'image']),
+    prompt: z.string(),
+    variations: z.number().int().positive().optional(),
+    aspectRatio: z.string().optional(),
+    durationSeconds: z.number().positive().optional(),
+    mode: z.string().optional(),
+    modelHint: z.string().optional(),
+    outputDir: z.string().optional(),
+    allowSpend: z.boolean().optional(),
+    extractFrames: z.number().int().nonnegative().optional(),
+    sourceAssets: z.array(z.string()).optional(),
+    projectUrl: z.string().optional(),
+    reuseCurrentProject: z.boolean().optional(),
+    allowNewProject: z.boolean().optional(),
+    freshChatOnFailure: z.boolean().optional(),
+    editorWaitMs: z.number().int().positive().optional(),
+    submit: z.boolean().optional(),
+    targetDir: z.string().optional(),
+  }, args => api.plan(args));
+  registerRequestTools(register);
+  registerBrowserTools(register);
+  registerResultTools(register);
+}
+
+function registerRequestTools(register) {
+  register('takomi_flow_template', 'Return or write a video/image request template.', {
+    kind: z.enum(['video', 'image']).optional(),
+    outputDir: z.string().optional(),
+  }, args => api.template(args));
+  const requestShape = {
+    kind: z.enum(['video', 'image']),
+    prompt: z.string(),
+    variations: z.number().int().positive().optional(),
+    aspectRatio: z.string().optional(),
+    durationSeconds: z.number().positive().optional(),
+    mode: z.string().optional(),
+    modelHint: z.string().optional(),
+    outputDir: z.string().optional(),
+    allowSpend: z.boolean().optional(),
+    extractFrames: z.number().int().nonnegative().optional(),
+    sourceAssets: z.array(z.string()).optional(),
+    projectUrl: z.string().optional(),
+    reuseCurrentProject: z.boolean().optional(),
+    allowNewProject: z.boolean().optional(),
+    freshChatOnFailure: z.boolean().optional(),
+    editorWaitMs: z.number().int().positive().optional(),
+    notes: z.string().optional(),
+  };
+  register('takomi_flow_prepare', 'Create a prepared request JSON file for a Flow image or video generation.', requestShape, args => api.prepare(args));
+  register('takomi_flow_workflow', 'Prepare, validate, and optionally submit a Flow image/video generation from one agent call.', {
+    ...requestShape,
+    submit: z.boolean().optional(),
+    allowBrowser: z.boolean().optional(),
+    profileDir: z.string().optional(),
+    browserChannel: z.string().optional(),
+    cdpUrl: z.string().optional(),
+    headless: z.boolean().optional(),
+  }, args => api.workflow(args));
+  register('takomi_flow_validate', 'Validate a TakomiFlow request JSON before opening Flow or spending credits.', {
+    request: z.string(),
+  }, args => api.validate(args));
+}
+
+function registerBrowserTools(register) {
+  register('takomi_flow_observe', 'Open Flow and observe UI controls/screenshots. Requires allowBrowser=true.', {
+    allowBrowser: z.boolean(),
+    profileDir: z.string().optional(),
+    outputDir: z.string().optional(),
+    browserChannel: z.string().optional(),
+    cdpUrl: z.string().optional(),
+    headless: z.boolean().optional(),
+  }, args => requireBrowser(args, () => api.observe(args)));
+  register('takomi_flow_generate', 'Run guarded Flow generation from a request file. Requires allowBrowser=true and request allowSpend=true to submit.', {
+    allowBrowser: z.boolean(),
+    request: z.string(),
+    profileDir: z.string().optional(),
+    browserChannel: z.string().optional(),
+    cdpUrl: z.string().optional(),
+    headless: z.boolean().optional(),
+    projectUrl: z.string().optional(),
+    reuseCurrentProject: z.boolean().optional(),
+    allowNewProject: z.boolean().optional(),
+    freshChatOnFailure: z.boolean().optional(),
+    editorWaitMs: z.number().int().positive().optional(),
+  }, args => requireBrowser(args, () => api.generate(args)));
+}
+
+function registerResultTools(register) {
+  register('takomi_flow_selftest', 'Run deterministic no-spend TakomiFlow checks, including media catalog/frame extraction.', {
+    outputDir: z.string().optional(),
+  }, args => api.selftest(args));
+  register('takomi_flow_inspect', 'Summarize a TakomiFlow run.json or run directory.', { run: z.string() }, args => api.inspect(args));
+  register('takomi_flow_latest', 'Summarize the latest TakomiFlow run under an output directory.', {
+    outputDir: z.string().optional(),
+  }, args => api.latest(args));
+  register('takomi_flow_runs', 'List recent TakomiFlow runs under an output directory.', {
+    outputDir: z.string().optional(),
+    limit: z.number().int().positive().optional(),
+  }, args => api.runs(args));
+  register('takomi_flow_assets', 'Catalog downloaded run assets and optionally extract video review frames.', {
+    run: z.string(),
+    frames: z.number().int().nonnegative().optional(),
+  }, args => api.assets(args));
+  register('takomi_flow_review', 'Inspect a run, catalog assets, extract review frames, and write a Markdown handoff.', {
+    run: z.string(),
+    frames: z.number().int().nonnegative().optional(),
+    reportPath: z.string().optional(),
+  }, args => api.review(args));
+  register('takomi_flow_collect', 'Copy reviewed assets, frames, report, and manifest into a downstream target folder.', {
+    run: z.string(),
+    targetDir: z.string(),
+    frames: z.number().int().nonnegative().optional(),
+    includeFrames: z.boolean().optional(),
+    reportPath: z.string().optional(),
+  }, args => api.collect(args));
+  register('takomi_flow_report', 'Create a Markdown report for a run or recent TakomiFlow history.', {
+    run: z.string().optional(),
+    outputDir: z.string().optional(),
+    limit: z.number().int().positive().optional(),
+    reportPath: z.string().optional(),
+  }, args => api.report(args));
+}
+
+function toolRegister(server) {
+  return (name, description, inputSchema, handler) => {
+    server.registerTool(name, { description, inputSchema }, async args => {
+      const structuredContent = await handler(args || {});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
+        structuredContent,
+      };
+    });
+  };
+}
+
+function requireBrowser(args, handler) {
+  if (!args?.allowBrowser) {
+    return {
+      schemaVersion: 1,
+      status: 'blocked',
+      errors: [],
+      manualActions: ['Set allowBrowser=true to permit TakomiFlow to open or drive a browser.'],
+    };
+  }
+  return handler();
+}

package/plugins/takomi-flow/scripts/lib/media.mjs

@@ -1,78 +1,78 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { ensureDir, writeJson } from './paths.mjs';
-
-const execFileAsync = promisify(execFile);
-const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.webm', '.mkv', '.avi']);
-const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
-
-export async function catalogAssets(run, assets = [], options = {}) {
-  const catalog = [];
-  const frameCount = Math.max(0, Number.parseInt(options.frames || '0', 10) || 0);
-  for (const assetPath of assets) {
-    const absolutePath = path.resolve(assetPath);
-    if (!fs.existsSync(absolutePath)) {
-      catalog.push({ path: absolutePath, exists: false, errors: ['Asset file not found.'] });
-      continue;
-    }
-    const kind = classifyAsset(absolutePath);
-    const item = {
-      path: absolutePath,
-      exists: true,
-      kind,
-      bytes: fs.statSync(absolutePath).size,
-      frames: [],
-      metadata: {},
-      errors: [],
-    };
-    if (kind === 'video') {
-      item.metadata = await probeMedia(absolutePath).catch(error => ({ probeError: error.message }));
-      if (frameCount > 0) {
-        item.frames = await extractFrames(absolutePath, path.join(run.runDir, 'frames'), frameCount)
-          .catch(error => {
-            item.errors.push(error.message);
-            return [];
-          });
-      }
-    }
-    catalog.push(item);
-  }
-  const catalogPath = path.join(run.runDir, 'assets.json');
-  writeJson(catalogPath, { schemaVersion: 1, runId: run.runId, assets: catalog });
-  return { catalogPath, assets: catalog };
-}
-
-export function classifyAsset(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  if (VIDEO_EXTENSIONS.has(ext)) return 'video';
-  if (IMAGE_EXTENSIONS.has(ext)) return 'image';
-  return 'unknown';
-}
-
-async function probeMedia(filePath) {
-  const { stdout } = await execFileAsync('ffprobe', [
-    '-v', 'error',
-    '-show_entries', 'format=duration,size:stream=width,height,codec_type,codec_name',
-    '-of', 'json',
-    filePath,
-  ]);
-  return JSON.parse(stdout);
-}
-
-async function extractFrames(filePath, framesDir, count) {
-  ensureDir(framesDir);
-  const outputPattern = path.join(framesDir, `${path.basename(filePath, path.extname(filePath))}_%03d.jpg`);
-  await execFileAsync('ffmpeg', [
-    '-y',
-    '-i', filePath,
-    '-vf', 'fps=1,scale=640:-1',
-    '-frames:v', String(count),
-    outputPattern,
-  ]);
-  return fs.readdirSync(framesDir)
-    .filter(name => name.startsWith(path.basename(filePath, path.extname(filePath))) && name.endsWith('.jpg'))
-    .sort()
-    .map(name => path.join(framesDir, name));
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { ensureDir, writeJson } from './paths.mjs';
+
+const execFileAsync = promisify(execFile);
+const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.webm', '.mkv', '.avi']);
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
+
+export async function catalogAssets(run, assets = [], options = {}) {
+  const catalog = [];
+  const frameCount = Math.max(0, Number.parseInt(options.frames || '0', 10) || 0);
+  for (const assetPath of assets) {
+    const absolutePath = path.resolve(assetPath);
+    if (!fs.existsSync(absolutePath)) {
+      catalog.push({ path: absolutePath, exists: false, errors: ['Asset file not found.'] });
+      continue;
+    }
+    const kind = classifyAsset(absolutePath);
+    const item = {
+      path: absolutePath,
+      exists: true,
+      kind,
+      bytes: fs.statSync(absolutePath).size,
+      frames: [],
+      metadata: {},
+      errors: [],
+    };
+    if (kind === 'video') {
+      item.metadata = await probeMedia(absolutePath).catch(error => ({ probeError: error.message }));
+      if (frameCount > 0) {
+        item.frames = await extractFrames(absolutePath, path.join(run.runDir, 'frames'), frameCount)
+          .catch(error => {
+            item.errors.push(error.message);
+            return [];
+          });
+      }
+    }
+    catalog.push(item);
+  }
+  const catalogPath = path.join(run.runDir, 'assets.json');
+  writeJson(catalogPath, { schemaVersion: 1, runId: run.runId, assets: catalog });
+  return { catalogPath, assets: catalog };
+}
+
+export function classifyAsset(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (VIDEO_EXTENSIONS.has(ext)) return 'video';
+  if (IMAGE_EXTENSIONS.has(ext)) return 'image';
+  return 'unknown';
+}
+
+async function probeMedia(filePath) {
+  const { stdout } = await execFileAsync('ffprobe', [
+    '-v', 'error',
+    '-show_entries', 'format=duration,size:stream=width,height,codec_type,codec_name',
+    '-of', 'json',
+    filePath,
+  ]);
+  return JSON.parse(stdout);
+}
+
+async function extractFrames(filePath, framesDir, count) {
+  ensureDir(framesDir);
+  const outputPattern = path.join(framesDir, `${path.basename(filePath, path.extname(filePath))}_%03d.jpg`);
+  await execFileAsync('ffmpeg', [
+    '-y',
+    '-i', filePath,
+    '-vf', 'fps=1,scale=640:-1',
+    '-frames:v', String(count),
+    outputPattern,
+  ]);
+  return fs.readdirSync(framesDir)
+    .filter(name => name.startsWith(path.basename(filePath, path.extname(filePath))) && name.endsWith('.jpg'))
+    .sort()
+    .map(name => path.join(framesDir, name));
+}

package/plugins/takomi-flow/scripts/lib/observe.mjs

@@ -1,54 +1,54 @@
-import { defaultProfileDir, defaultRunsDir, FLOW_URL, resolvePath } from './paths.mjs';
-import { closeFlowBrowser, launchFlowBrowser } from './browser.mjs';
-import { createRun, baseResult, saveResult } from './result.mjs';
-import { capture, inspectFlowState, openFlow } from './flow-ui.mjs';
-
-export async function observeFlow(options = {}) {
-  const outputDir = resolvePath(options.outputDir, defaultRunsDir());
-  const run = createRun({ outputDir }, 'observe');
-  const profileDir = resolvePath(options.profileDir, defaultProfileDir());
-  const browser = await launchFlowBrowser({
-    profileDir,
-    downloadsDir: run.downloadsDir,
-    browserChannel: options.browserChannel,
-    cdpUrl: options.cdpUrl,
-    headless: options.headless === true,
-  });
-  const result = baseResult('ok', run, { command: 'observe', flowUrl: FLOW_URL, profileDir });
-  try {
-    await openFlow(browser.page);
-    result.screenshots.push(await capture(browser.page, run, 'observe-flow'));
-    Object.assign(result, await inspectFlowState(browser.page));
-    result.controls = await collectControls(browser.page);
-    if (result.manualActions.length) result.status = 'manual_action_required';
-  } catch (error) {
-    result.status = 'failed';
-    result.errors.push(error.message);
-  } finally {
-    await closeFlowBrowser(browser);
-    saveResult(run, result);
-  }
-  return result;
-}
-
-async function collectControls(page) {
-  return page.evaluate(() => {
-    const text = node => (node.innerText || node.textContent || node.getAttribute('aria-label') || '').trim();
-    const pick = selector => Array.from(document.querySelectorAll(selector))
-      .slice(0, 80)
-      .map(node => ({
-        tag: node.tagName.toLowerCase(),
-        text: text(node).slice(0, 120),
-        ariaLabel: node.getAttribute('aria-label') || '',
-        placeholder: node.getAttribute('placeholder') || '',
-        role: node.getAttribute('role') || '',
-        type: node.getAttribute('type') || '',
-      }))
-      .filter(item => item.text || item.ariaLabel || item.placeholder || item.role || item.type);
-    return {
-      buttons: pick('button,[role="button"]'),
-      inputs: pick('input,textarea,[contenteditable="true"],[role="textbox"]'),
-      links: pick('a'),
-    };
-  }).catch(error => ({ error: error.message }));
-}
+import { defaultProfileDir, defaultRunsDir, FLOW_URL, resolvePath } from './paths.mjs';
+import { closeFlowBrowser, launchFlowBrowser } from './browser.mjs';
+import { createRun, baseResult, saveResult } from './result.mjs';
+import { capture, inspectFlowState, openFlow } from './flow-ui.mjs';
+
+export async function observeFlow(options = {}) {
+  const outputDir = resolvePath(options.outputDir, defaultRunsDir());
+  const run = createRun({ outputDir }, 'observe');
+  const profileDir = resolvePath(options.profileDir, defaultProfileDir());
+  const browser = await launchFlowBrowser({
+    profileDir,
+    downloadsDir: run.downloadsDir,
+    browserChannel: options.browserChannel,
+    cdpUrl: options.cdpUrl,
+    headless: options.headless === true,
+  });
+  const result = baseResult('ok', run, { command: 'observe', flowUrl: FLOW_URL, profileDir });
+  try {
+    await openFlow(browser.page);
+    result.screenshots.push(await capture(browser.page, run, 'observe-flow'));
+    Object.assign(result, await inspectFlowState(browser.page));
+    result.controls = await collectControls(browser.page);
+    if (result.manualActions.length) result.status = 'manual_action_required';
+  } catch (error) {
+    result.status = 'failed';
+    result.errors.push(error.message);
+  } finally {
+    await closeFlowBrowser(browser);
+    saveResult(run, result);
+  }
+  return result;
+}
+
+async function collectControls(page) {
+  return page.evaluate(() => {
+    const text = node => (node.innerText || node.textContent || node.getAttribute('aria-label') || '').trim();
+    const pick = selector => Array.from(document.querySelectorAll(selector))
+      .slice(0, 80)
+      .map(node => ({
+        tag: node.tagName.toLowerCase(),
+        text: text(node).slice(0, 120),
+        ariaLabel: node.getAttribute('aria-label') || '',
+        placeholder: node.getAttribute('placeholder') || '',
+        role: node.getAttribute('role') || '',
+        type: node.getAttribute('type') || '',
+      }))
+      .filter(item => item.text || item.ariaLabel || item.placeholder || item.role || item.type);
+    return {
+      buttons: pick('button,[role="button"]'),
+      inputs: pick('input,textarea,[contenteditable="true"],[role="textbox"]'),
+      links: pick('a'),
+    };
+  }).catch(error => ({ error: error.message }));
+}