stuntdouble 0.0.0-stage → 0.1.0

package/dist/mcp-HXJQN2C7.js

@@ -0,0 +1,2391 @@
+import {
+  startUi
+} from "./chunk-VWTYG7G4.js";
+import {
+  ActorSchema,
+  ChecklistSchema,
+  ConfigSchema,
+  appendJsonl,
+  describeRunScore,
+  isAlive,
+  newChecklistScoring,
+  projectDir,
+  readJson,
+  readRuns,
+  resolveHaltedChecks,
+  resolveSkippedChecks,
+  scoreChecklistRun,
+  sdDir,
+  writeFileAtomic,
+  writeJsonAtomic
+} from "./chunk-JAB46QV7.js";
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../browser-toolset/src/keys.ts
+var ALIASES = {
+  ctrl: "Control",
+  control: "Control",
+  cmd: "Meta",
+  command: "Meta",
+  meta: "Meta",
+  super: "Meta",
+  win: "Meta",
+  alt: "Alt",
+  option: "Alt",
+  shift: "Shift",
+  enter: "Enter",
+  return: "Enter",
+  kp_enter: "Enter",
+  esc: "Escape",
+  escape: "Escape",
+  tab: "Tab",
+  space: " ",
+  backspace: "Backspace",
+  delete: "Delete",
+  del: "Delete",
+  insert: "Insert",
+  home: "Home",
+  end: "End",
+  page_up: "PageUp",
+  pageup: "PageUp",
+  prior: "PageUp",
+  page_down: "PageDown",
+  pagedown: "PageDown",
+  next: "PageDown",
+  up: "ArrowUp",
+  down: "ArrowDown",
+  left: "ArrowLeft",
+  right: "ArrowRight",
+  arrowup: "ArrowUp",
+  arrowdown: "ArrowDown",
+  arrowleft: "ArrowLeft",
+  arrowright: "ArrowRight",
+  capslock: "CapsLock",
+  caps_lock: "CapsLock"
+};
+function normaliseKey(raw) {
+  const key = raw.trim();
+  const alias = ALIASES[key.toLowerCase()];
+  if (alias) return alias;
+  if (/^f([1-9]|1[0-2])$/i.test(key)) return key.toUpperCase();
+  return key;
+}
+function toPlaywrightChord(chord) {
+  const parts = chord.split("+").filter((p) => p.length > 0);
+  if (chord.endsWith("+") && chord.length > 1 && chord[chord.length - 2] === "+") parts.push("+");
+  if (parts.length === 0) return chord === "+" ? "+" : chord;
+  const keys = parts.map(normaliseKey);
+  if (keys.length > 1) {
+    const last = keys[keys.length - 1];
+    if (last.length === 1) keys[keys.length - 1] = last.toUpperCase();
+  }
+  return keys.join("+");
+}
+function toPlaywrightKeySequence(text2) {
+  if (text2 === " ") return [" "];
+  return text2.split(/\s+/).filter((k) => k.length > 0).map(toPlaywrightChord);
+}
+
+// ../browser-toolset/src/safety.ts
+var INDEX_SESSION_SAFETY = {
+  refuseSensitiveInput: true,
+  blockSubmit: true
+};
+var SAFETY_REFUSAL_SUFFIX = "This session is not allowed to pay, subscribe, create an account or enter passwords or card details. Do not try another way round: report what you observed and what the next step would be, then carry on or call done.";
+var PAYMENT_PROVIDER_DOMAINS = [
+  "js.stripe.com",
+  "api.stripe.com",
+  "checkout.stripe.com",
+  "m.stripe.network",
+  "hooks.stripe.com",
+  "paypal.com",
+  "paypalobjects.com",
+  "adyen.com",
+  "adyenpayments.com",
+  "braintreegateway.com",
+  "braintree-api.com",
+  "pay.google.com",
+  "payments.google.com",
+  "applepay.cdn-apple.com",
+  "klarna.com",
+  "klarnaservices.com",
+  "afterpay.com",
+  "checkout.com",
+  "squareup.com",
+  "squarecdn.com",
+  "paddle.com",
+  "lemonsqueezy.com"
+];
+function hostMatchesDomain(host, domain) {
+  const h = host.toLowerCase().replace(/\.$/, "");
+  const d = domain.toLowerCase().replace(/^\*\./, "");
+  return h === d || h.endsWith(`.${d}`);
+}
+function isPaymentProviderHost(host, domains = PAYMENT_PROVIDER_DOMAINS) {
+  return domains.some((d) => hostMatchesDomain(host, d));
+}
+function luhnValid(digits) {
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = digits.charCodeAt(i) - 48;
+    if (n < 0 || n > 9) return false;
+    if (double) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    double = !double;
+  }
+  return sum > 0 && sum % 10 === 0;
+}
+function containsCardNumber(value) {
+  const runs = value.match(/\d(?:[ -]?\d){12,18}/g) ?? [];
+  return runs.some((run) => {
+    const digits = run.replace(/[ -]/g, "");
+    return digits.length >= 13 && digits.length <= 19 && luhnValid(digits);
+  });
+}
+var CARD_FIELD_PATTERN = /card.?(?:number|num|no\b)|cc.?(?:num|number|no\b|exp|csc|cvv|cvc)|credit.?card|debit.?card|\bcvc\b|\bcvv2?\b|\bcsc\b|security.?code|card.?(?:verification|code)|expir(?:y|ation)|exp.?(?:date|month|year)|\bmm.?\/?.?yy\b|card.?holder|name.?on.?card|\bpan\b/i;
+var PAYMENT_ACTION_PATTERN = /^(?:pay(?:\s+now)?\b(?!\s+(?:monthly|annually|yearly|per|by|with|later|in|over|as))|purchase\b|complete (?:my |your |the )?(?:purchase|order|payment|booking)\b|place (?:my |your |the )?order\b|confirm (?:and|&) pay\b|confirm (?:order|purchase|payment|booking)\b|submit (?:order|payment)\b|book and pay\b)/i;
+var COMMIT_ACTION_PATTERN = /\b(?:pay|purchase|place (?:my |your |the )?order|complete (?:my |your |the )?(?:order|purchase|booking)|subscribe|buy now|sign ?up|create (?:an |my |your )?account|register|join now|start (?:my |your )?(?:free )?trial|confirm (?:order|booking)|submit order)\b/i;
+var FORMLESS_COMMIT_PATTERN = /^(?:create (?:an |my |your )?account|complete (?:my |your )?(?:registration|sign ?up)|start (?:my |your )?(?:free )?trial)\b/i;
+function hostOf(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return "";
+  }
+}
+function sensitiveFieldReason(f) {
+  if (f.type === "password" || /(?:current|new)-password/.test(f.autocomplete)) {
+    return "That is a password field.";
+  }
+  if (/\bcc-/.test(f.autocomplete)) return "That is a payment card field.";
+  if (f.tag === "iframe") {
+    if (isPaymentProviderHost(hostOf(f.iframeSrc)))
+      return "That is a payment provider\u2019s card field.";
+    if (CARD_FIELD_PATTERN.test(`${f.iframeTitle} ${f.name}`))
+      return "That is a payment card field.";
+  }
+  const text2 = [f.name, f.id, f.ariaLabel, f.placeholder, f.label].join(" ");
+  if (f.tag !== "a" && f.tag !== "button" && CARD_FIELD_PATTERN.test(text2)) {
+    return "That is a payment card field.";
+  }
+  return null;
+}
+function submitReason(f) {
+  if (f.isNavigatingLink) return null;
+  if (f.isSubmit && f.formSensitive) {
+    return "That would submit a form holding a password or payment card field.";
+  }
+  if (f.isSubmit && COMMIT_ACTION_PATTERN.test(f.label)) {
+    return `That would submit "${f.label.slice(0, 60)}".`;
+  }
+  if (f.isButton && !f.inForm && f.formSensitive && FORMLESS_COMMIT_PATTERN.test(f.label.trim())) {
+    return `That would press "${f.label.slice(0, 60)}".`;
+  }
+  if (f.isButton && PAYMENT_ACTION_PATTERN.test(f.label.trim())) {
+    return `That would press "${f.label.slice(0, 60)}".`;
+  }
+  return null;
+}
+function enterSubmitReason(f) {
+  if (!f.inForm || f.tag === "textarea") return null;
+  if (f.formSensitive) return "Enter would submit a form holding a password or payment card field.";
+  if (COMMIT_ACTION_PATTERN.test(f.formSubmitLabel)) {
+    return `Enter would submit "${f.formSubmitLabel.slice(0, 60)}".`;
+  }
+  return null;
+}
+function refusalText(reason) {
+  return `Refused: ${reason} ${SAFETY_REFUSAL_SUFFIX}`;
+}
+
+// ../browser-toolset/src/page-script.ts
+var MAX_PAGE_TEXT_CHARS = 5e4;
+var CARD_PATTERN_SOURCE = JSON.stringify(CARD_FIELD_PATTERN.source);
+var PAYMENT_DOMAINS_JSON = JSON.stringify(PAYMENT_PROVIDER_DOMAINS);
+var SCRIPT = String.raw`
+(function (args) {
+  var REF_ATTR = 'data-sd-ref';
+  var MAX = ${MAX_PAGE_TEXT_CHARS};
+  var w = window;
+  if (typeof w.__sdRefSeq !== 'number') w.__sdRefSeq = 0;
+
+  function refOf(el) {
+    var existing = el.getAttribute(REF_ATTR);
+    if (existing) return existing;
+    w.__sdRefSeq += 1;
+    var ref = 'ref_' + w.__sdRefSeq;
+    el.setAttribute(REF_ATTR, ref);
+    return ref;
+  }
+
+  function findRef(ref, root) {
+    root = root || document;
+    var hit = root.querySelector('[' + REF_ATTR + '="' + ref + '"]');
+    if (hit) return hit;
+    var all = root.querySelectorAll('*');
+    for (var i = 0; i < all.length; i++) {
+      if (all[i].shadowRoot) {
+        var inner = findRef(ref, all[i].shadowRoot);
+        if (inner) return inner;
+      }
+    }
+    return null;
+  }
+
+  function isHidden(el) {
+    if (el.getAttribute('aria-hidden') === 'true') return true;
+    var style = w.getComputedStyle(el);
+    if (style.display === 'none' || style.visibility === 'hidden' || style.visibility === 'collapse') return true;
+    if (parseFloat(style.opacity) === 0) return true;
+    var rect = el.getBoundingClientRect();
+    return rect.width === 0 && rect.height === 0;
+  }
+
+  function inViewport(el) {
+    var r = el.getBoundingClientRect();
+    return r.bottom > 0 && r.right > 0 && r.top < w.innerHeight && r.left < w.innerWidth;
+  }
+
+  var INPUT_ROLES = {
+    button: 'button', submit: 'button', reset: 'button', image: 'button',
+    checkbox: 'checkbox', radio: 'radio', range: 'slider', search: 'searchbox',
+    email: 'textbox', tel: 'textbox', url: 'textbox', text: 'textbox',
+    password: 'textbox', number: 'spinbutton', date: 'textbox', file: 'button'
+  };
+  var TAG_ROLES = {
+    A: 'link', BUTTON: 'button', SELECT: 'combobox', TEXTAREA: 'textbox',
+    H1: 'heading', H2: 'heading', H3: 'heading', H4: 'heading', H5: 'heading', H6: 'heading',
+    IMG: 'img', NAV: 'navigation', MAIN: 'main', HEADER: 'banner', FOOTER: 'contentinfo',
+    FORM: 'form', DIALOG: 'dialog', TABLE: 'table', UL: 'list', OL: 'list', LI: 'listitem',
+    SUMMARY: 'button', LABEL: 'label', OPTION: 'option', IFRAME: 'iframe', VIDEO: 'video'
+  };
+  var INTERACTIVE_ROLES = {
+    button: 1, link: 1, checkbox: 1, radio: 1, textbox: 1, searchbox: 1, combobox: 1,
+    slider: 1, spinbutton: 1, switch: 1, tab: 1, menuitem: 1, menuitemcheckbox: 1,
+    menuitemradio: 1, option: 1, treeitem: 1
+  };
+
+  function roleOf(el) {
+    var explicit = el.getAttribute('role');
+    if (explicit) return explicit.split(' ')[0];
+    if (el.tagName === 'INPUT') {
+      var t = (el.getAttribute('type') || 'text').toLowerCase();
+      if (t === 'hidden') return null;
+      return INPUT_ROLES[t] || 'textbox';
+    }
+    if (el.tagName === 'A' && !el.hasAttribute('href')) return null;
+    if (el.tagName === 'IMG' && !el.getAttribute('alt')) return null;
+    if (el.isContentEditable && el.parentElement && !el.parentElement.isContentEditable) return 'textbox';
+    return TAG_ROLES[el.tagName] || null;
+  }
+
+  function isInteractive(el, role) {
+    if (role && INTERACTIVE_ROLES[role]) return true;
+    if (el.hasAttribute('onclick')) return true;
+    var tab = el.getAttribute('tabindex');
+    return tab !== null && Number(tab) >= 0 && !!role;
+  }
+
+  function clean(s) {
+    return (s || '').replace(/\s+/g, ' ').trim();
+  }
+
+  // Roles whose own text is their name. Containers (banner, list, table, form)
+  // take a name only from an explicit label: their text is their children's,
+  // which the tree already lists, and repeating it drowns \`find\`.
+  var TEXT_NAMED = { heading: 1, option: 1, label: 1, text: 1, generic: 1, listitem: 0 };
+
+  function nameOf(el, role) {
+    var label = el.getAttribute('aria-label');
+    if (label) return clean(label);
+    var by = el.getAttribute('aria-labelledby');
+    if (by) {
+      var parts = by.split(/\s+/).map(function (id) {
+        var n = document.getElementById(id);
+        return n ? n.textContent : '';
+      });
+      var joined = clean(parts.join(' '));
+      if (joined) return joined;
+    }
+    if (el.id) {
+      var forLabel = document.querySelector('label[for="' + CSS.escape(el.id) + '"]');
+      if (forLabel) return clean(forLabel.textContent);
+    }
+    var alt = el.getAttribute('alt') || el.getAttribute('title');
+    if (alt) return clean(alt);
+    if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+      return clean(el.getAttribute('placeholder') || '');
+    }
+    if (role && !INTERACTIVE_ROLES[role] && !TEXT_NAMED[role]) return '';
+    return clean(el.innerText || el.textContent).slice(0, 100);
+  }
+
+  function valueOf(el) {
+    if (el.tagName === 'INPUT') {
+      var t = (el.getAttribute('type') || 'text').toLowerCase();
+      if (t === 'checkbox' || t === 'radio') return el.checked ? 'checked' : 'unchecked';
+      if (t === 'password') return el.value ? '••••' : '';
+      return el.value ? clean(el.value).slice(0, 80) : '';
+    }
+    if (el.tagName === 'TEXTAREA') return el.value ? clean(el.value).slice(0, 80) : '';
+    if (el.tagName === 'SELECT') {
+      var opt = el.options[el.selectedIndex];
+      return opt ? clean(opt.text) : '';
+    }
+    return '';
+  }
+
+  function hasOwnText(el) {
+    for (var c = el.firstChild; c; c = c.nextSibling) {
+      if (c.nodeType === 3 && c.nodeValue && c.nodeValue.trim()) return true;
+    }
+    return false;
+  }
+
+  function children(el) {
+    var out = Array.prototype.slice.call(el.children);
+    if (el.shadowRoot) out = out.concat(Array.prototype.slice.call(el.shadowRoot.children));
+    return out;
+  }
+
+  function describe(el, role) {
+    var name = nameOf(el, role);
+    var line = role + (name ? ' "' + name.replace(/"/g, "'") + '"' : '');
+    var value = valueOf(el);
+    if (value) line += ' value="' + value.replace(/"/g, "'") + '"';
+    if (el.tagName === 'A' && el.getAttribute('href')) {
+      var href = el.getAttribute('href');
+      if (href.indexOf('javascript:') !== 0) line += ' href="' + href.slice(0, 200) + '"';
+    }
+    var description = clean(el.getAttribute('aria-description'));
+    if (description) line += ' description="' + description.slice(0, 200).replace(/"/g, "'") + '"';
+    if (el.disabled) line += ' disabled';
+    // Semantics WAO (@stunt-double/wao) inferred rather than the page's authors
+    // wrote: \`data-wao="role name"\` lists what it set.
+    var inferred = clean(el.getAttribute('data-wao'));
+    if (inferred) line += ' inferred="' + inferred.replace(/"/g, "'") + '"';
+    return line + ' [' + refOf(el) + ']';
+  }
+
+  function read(filter, depth, rootRef) {
+    var root = document.body;
+    if (rootRef) {
+      root = findRef(rootRef);
+      if (!root) return { ok: false, error: rootRef + ' is stale or not found on the current page. Re-read the page to get fresh references.' };
+    }
+    var lines = [];
+    var size = 0;
+    var truncated = false;
+    function walk(el, level, reported) {
+      if (truncated || !el || el.nodeType !== 1) return;
+      if (el.tagName === 'SCRIPT' || el.tagName === 'STYLE' || el.tagName === 'NOSCRIPT' || el.tagName === 'TEMPLATE') return;
+      if (isHidden(el)) return;
+      var role = roleOf(el);
+      var interactive = isInteractive(el, role);
+      var include;
+      if (filter === 'interactive') include = interactive;
+      else include = !!role || interactive || (hasOwnText(el) && clean(el.innerText).length > 0);
+      if (include && filter !== 'all' && !inViewport(el)) include = false;
+      var next = reported;
+      if (include) {
+        var line = '  '.repeat(Math.min(reported, 20)) + describe(el, role || (interactive ? 'generic' : 'text'));
+        if (size + line.length + 1 > ${MAX_PAGE_TEXT_CHARS}) { truncated = true; return; }
+        lines.push(line);
+        size += line.length + 1;
+        next = reported + 1;
+        if (!interactive && !role) return;
+      }
+      // Depth counts levels of the reported tree, not DOM nesting: a real
+      // page nests its buttons far deeper than 15 elements.
+      if (next >= depth) return;
+      var kids = children(el);
+      for (var i = 0; i < kids.length; i++) walk(kids[i], level + 1, next);
+    }
+    walk(root, 0, 0);
+    var text = lines.join('\n');
+    if (!text) text = filter === 'all' ? 'The page has no readable elements.' : 'No elements in the viewport match. Scroll, or read with filter "all".';
+    if (truncated) text += '\n[truncated: the page tree exceeded ' + MAX + ' characters; pass a ref or a smaller depth]';
+    return { ok: true, text: text, truncated: truncated };
+  }
+
+  function find(query) {
+    var terms = clean(query).toLowerCase().split(' ').filter(function (t) { return t.length > 1; });
+    if (!terms.length) return { ok: false, error: 'find needs a query.' };
+    var scored = [];
+    var all = document.body.querySelectorAll('*');
+    for (var i = 0; i < all.length; i++) {
+      var el = all[i];
+      if (isHidden(el)) continue;
+      var role = roleOf(el);
+      var interactive = isInteractive(el, role);
+      if (!role && !interactive) continue;
+      var hay = (role + ' ' + nameOf(el, role || 'generic') + ' ' + (el.getAttribute('aria-description') || '') + ' ' + (el.getAttribute('placeholder') || '') + ' ' + (el.getAttribute('name') || '')).toLowerCase();
+      var score = 0;
+      for (var j = 0; j < terms.length; j++) if (hay.indexOf(terms[j]) !== -1) score += 1;
+      if (score > 0) scored.push({ el: el, role: role || 'generic', score: score + (interactive ? 0.5 : 0) + (inViewport(el) ? 0.25 : 0) });
+    }
+    scored.sort(function (a, b) { return b.score - a.score; });
+    var top = scored.slice(0, 20);
+    if (!top.length) return { ok: true, text: 'No elements match "' + clean(query) + '".', truncated: false };
+    return { ok: true, text: top.map(function (s) { return describe(s.el, s.role); }).join('\n'), truncated: false };
+  }
+
+  function pageText() {
+    var main = document.querySelector('main, [role="main"], article');
+    var text = clean((main && main.innerText.length > 200 ? main.innerText : document.body.innerText) || '');
+    var truncated = text.length > MAX;
+    return { ok: true, text: truncated ? text.slice(0, MAX) + '\n[truncated]' : text || 'The page has no text.', truncated: truncated };
+  }
+
+  function resolve(ref, scroll) {
+    var el = findRef(ref);
+    if (!el || !el.isConnected) return { ok: false, error: ref + ' is stale or not found on the current page. Re-read the page to get fresh references.' };
+    // Instant, not the page's own scroll-behavior: smooth, which is still
+    // moving when the box is measured, so the click would land short.
+    if (scroll && !inViewport(el)) el.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' });
+    var r = el.getBoundingClientRect();
+    return { ok: true, x: Math.round(r.left + r.width / 2), y: Math.round(r.top + r.height / 2), inViewport: inViewport(el) };
+  }
+
+  function form(ref, value) {
+    var el = findRef(ref);
+    if (!el) return { ok: false, error: ref + ' is stale or not found on the current page. Re-read the page to get fresh references.' };
+    var fire = function (type) { el.dispatchEvent(new Event(type, { bubbles: true })); };
+    if (el.tagName === 'SELECT') {
+      var want = String(value).toLowerCase();
+      for (var i = 0; i < el.options.length; i++) {
+        var o = el.options[i];
+        if (o.value.toLowerCase() === want || clean(o.text).toLowerCase() === want) {
+          el.selectedIndex = i; fire('input'); fire('change');
+          return { ok: true, description: 'Selected "' + clean(o.text) + '"' };
+        }
+      }
+      return { ok: false, error: 'No option in ' + ref + ' matches that value. Read the page to see its options.' };
+    }
+    if (el.tagName === 'INPUT' && (el.type === 'checkbox' || el.type === 'radio')) {
+      var on = value === true || String(value).toLowerCase() === 'true' || String(value).toLowerCase() === 'checked';
+      if (el.checked !== on) el.click();
+      return { ok: true, description: (el.checked ? 'Checked ' : 'Unchecked ') + ref };
+    }
+    if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+      var proto = el.tagName === 'INPUT' ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype;
+      var setter = Object.getOwnPropertyDescriptor(proto, 'value').set;
+      el.focus();
+      setter.call(el, String(value));
+      fire('input'); fire('change');
+      // The value can be a password or a code, and results are recorded, so only its length.
+      return { ok: true, description: 'Set ' + ref + ' (' + String(value).length + ' characters)' };
+    }
+    if (el.isContentEditable) {
+      el.focus(); el.textContent = String(value); fire('input');
+      return { ok: true, description: 'Set ' + ref + ' text' };
+    }
+    return { ok: false, error: ref + ' is not a form field.' };
+  }
+
+  // --- inspect: the facts the safety guards decide on ----------------------
+
+  var CARD_RE = new RegExp(${CARD_PATTERN_SOURCE}, 'i');
+  var PAYMENT_DOMAINS = ${PAYMENT_DOMAINS_JSON};
+  var ACTIONABLE = 'a[href],button,input,select,textarea,summary,iframe,[role="button"],[role="link"],[role="checkbox"],[role="textbox"],[contenteditable="true"]';
+
+  function isPaymentFrame(src) {
+    var host = '';
+    try { host = new URL(src, location.href).hostname.toLowerCase(); } catch (e) { return false; }
+    for (var i = 0; i < PAYMENT_DOMAINS.length; i++) {
+      var d = PAYMENT_DOMAINS[i];
+      if (host === d || host.slice(-(d.length + 1)) === '.' + d) return true;
+    }
+    return false;
+  }
+
+  function isCardField(el) {
+    if (el.tagName === 'IFRAME') {
+      return isPaymentFrame(el.getAttribute('src') || '') || CARD_RE.test((el.getAttribute('title') || '') + ' ' + (el.getAttribute('name') || ''));
+    }
+    if (/(^|\s)cc-/.test((el.getAttribute('autocomplete') || '').toLowerCase())) return true;
+    var text = [el.getAttribute('name'), el.id, el.getAttribute('aria-label'), el.getAttribute('placeholder')].join(' ');
+    return CARD_RE.test(text);
+  }
+
+  // Across the whole page only visible fields count: a login modal parked
+  // in the DOM must not make every button on the page look like a submit.
+  function holdsSensitive(root, visibleOnly) {
+    if (!root) return false;
+    var fields = root.querySelectorAll('input, iframe');
+    for (var i = 0; i < fields.length; i++) {
+      var f = fields[i];
+      var t = (f.getAttribute('type') || '').toLowerCase();
+      if (t === 'hidden' || t === 'submit' || t === 'button') continue;
+      if (t !== 'password' && !isCardField(f)) continue;
+      if (visibleOnly && isHidden(f)) continue;
+      return true;
+    }
+    return false;
+  }
+
+  function deepActive() {
+    var el = document.activeElement;
+    for (var i = 0; el && i < 10; i++) {
+      if (el.shadowRoot && el.shadowRoot.activeElement) { el = el.shadowRoot.activeElement; continue; }
+      if (el.tagName === 'IFRAME') {
+        var inner = null;
+        try { inner = el.contentDocument && el.contentDocument.activeElement; } catch (e) { inner = null; }
+        if (inner && inner !== el.contentDocument.body) { el = inner; continue; }
+      }
+      break;
+    }
+    return el && el !== document.body && el !== document.documentElement ? el : null;
+  }
+
+  function atPoint(x, y) {
+    var el = document.elementFromPoint(x, y);
+    for (var i = 0; el && el.shadowRoot && i < 10; i++) {
+      var inner = el.shadowRoot.elementFromPoint(x, y);
+      if (!inner || inner === el) break;
+      el = inner;
+    }
+    return el;
+  }
+
+  function submitLabel(form) {
+    var controls = form.querySelectorAll('button, input[type="submit" i], input[type="image" i]');
+    for (var i = 0; i < controls.length; i++) {
+      var c = controls[i];
+      var t = (c.getAttribute('type') || 'submit').toLowerCase();
+      if (t === 'submit' || t === 'image') return labelOf(c);
+    }
+    return '';
+  }
+
+  function labelOf(el) {
+    var name = nameOf(el, roleOf(el) || 'generic');
+    if (!name && el.tagName === 'INPUT') name = clean(el.value || '');
+    return name;
+  }
+
+  function factsOf(raw) {
+    if (!raw || raw.nodeType !== 1) return null;
+    var el = raw.closest ? raw.closest(ACTIONABLE) || raw : raw;
+    var tag = el.tagName.toLowerCase();
+    var type = (el.getAttribute('type') || '').toLowerCase();
+    if (tag === 'button' && !type) type = 'submit';
+    var role = roleOf(el) || '';
+    var form = el.form || (el.closest ? el.closest('form') : null);
+    var href = tag === 'a' ? el.getAttribute('href') || '' : '';
+    var navigating = tag === 'a' && !!href && href.charAt(0) !== '#' && href.toLowerCase().indexOf('javascript:') !== 0 && el.getAttribute('role') !== 'button';
+    var isSubmit = !!form && ((tag === 'button' && type === 'submit') || (tag === 'input' && (type === 'submit' || type === 'image')));
+    var isButton = tag === 'button' || role === 'button' || (tag === 'input' && (type === 'submit' || type === 'button' || type === 'image'));
+    return {
+      tag: tag,
+      type: type,
+      autocomplete: (el.getAttribute('autocomplete') || '').toLowerCase(),
+      name: el.getAttribute('name') || '',
+      id: el.id || '',
+      ariaLabel: el.getAttribute('aria-label') || '',
+      placeholder: el.getAttribute('placeholder') || '',
+      label: labelOf(el).slice(0, 200),
+      role: role,
+      isNavigatingLink: navigating,
+      isSubmit: isSubmit,
+      isButton: isButton,
+      iframeSrc: tag === 'iframe' ? (el.getAttribute('src') || '').slice(0, 500) : '',
+      iframeTitle: tag === 'iframe' ? el.getAttribute('title') || '' : '',
+      inForm: !!form,
+      // Without a form, the page stands in for one: a single-page sign-up
+      // with a password box and a "Create account" button is still a sign-up.
+      formSensitive: form ? holdsSensitive(form, false) : holdsSensitive(document, true),
+      formSubmitLabel: form ? submitLabel(form).slice(0, 200) : ''
+    };
+  }
+
+  function inspect(target) {
+    if (target.type === 'focused') return { ok: true, facts: factsOf(deepActive()) };
+    if (target.type === 'coordinate') return { ok: true, facts: factsOf(atPoint(target.x, target.y)) };
+    var el = findRef(target.ref);
+    if (!el) return { ok: false, error: target.ref + ' is stale or not found on the current page. Re-read the page to get fresh references.' };
+    return { ok: true, facts: factsOf(el) };
+  }
+
+  switch (args.op) {
+    case 'read': return read(args.filter, args.depth, args.ref);
+    case 'find': return find(args.query);
+    case 'text': return pageText();
+    case 'resolve': return resolve(args.ref, args.scroll);
+    case 'form': return form(args.ref, args.value);
+    case 'viewport': return { ok: true, width: w.innerWidth, height: w.innerHeight };
+    case 'inspect': return inspect(args.target);
+  }
+  return { ok: false, error: 'unknown op' };
+})`;
+function buildPageCall(op) {
+  return `${SCRIPT}(${JSON.stringify(op)})`;
+}
+
+// ../browser-toolset/src/executor.ts
+var BROWSER_TOOLSET_NAME = "browser";
+var HALT_TEXT = "Not executed: an earlier action in this turn failed.";
+var DISABLED_MEMBERS = /* @__PURE__ */ new Set([
+  "javascript_exec",
+  "file_upload",
+  "read_console",
+  "read_network"
+]);
+var TAB_MEMBERS = /* @__PURE__ */ new Set(["new_tab", "list_tabs", "switch_tab", "close_tab"]);
+var MAX_WAIT_SECONDS = 30;
+var SCROLL_NOTCH_PX = 100;
+var FIELD_LIMIT = 4096;
+var ToolsetError = class extends Error {
+};
+function isPrivateHost(hostname) {
+  const host = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".internal"))
+    return true;
+  if (host === "metadata.google.internal") return true;
+  const v4 = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (v4) {
+    const [a, b] = [Number(v4[1]), Number(v4[2])];
+    return a === 0 || a === 10 || a === 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  if (host.includes(":")) {
+    return host === "::1" || host === "::" || /^f[cd]/.test(host) || /^fe[89ab]/.test(host) || host.startsWith("::ffff:");
+  }
+  return false;
+}
+function redactInput(name, input) {
+  if (name === "type" && typeof input.text === "string") {
+    return { ...input, text: `[${input.text.length} characters]` };
+  }
+  if (name === "form_input" && "value" in input) {
+    const v = input.value;
+    return { ...input, value: typeof v === "boolean" ? v : `[${String(v).length} characters]` };
+  }
+  return input;
+}
+function sanitiseStateField(value) {
+  return value.replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, " ").slice(0, FIELD_LIMIT);
+}
+function parseTarget(raw, allow) {
+  const t = raw ?? {};
+  if (t.type === "ref" && typeof t.ref === "string" && allow !== "coordinate") {
+    return { type: "ref", ref: t.ref };
+  }
+  if (t.type === "coordinate" && typeof t.x === "number" && typeof t.y === "number" && allow !== "ref") {
+    return { type: "coordinate", x: Math.round(t.x), y: Math.round(t.y) };
+  }
+  const want = allow === "ref" ? "a ref target" : allow === "coordinate" ? "a coordinate target" : "a ref or coordinate target";
+  throw new ToolsetError(`Error: expected ${want}.`);
+}
+function clampNumber(value, min, max, fallback) {
+  const n = typeof value === "number" && Number.isFinite(value) ? value : fallback;
+  return Math.min(max, Math.max(min, n));
+}
+var BrowserToolsetExecutor = class {
+  /** Tab ids by the driver's stable page id (page objects are not stable). */
+  tabIds = /* @__PURE__ */ new Map();
+  tabSeq = 0;
+  // Plain fields rather than parameter properties: `node --test` runs this
+  // file with type stripping only, which rejects parameter properties.
+  driver;
+  options;
+  constructor(driver, options = {}) {
+    this.driver = driver;
+    this.options = options;
+  }
+  /** Turns run one at a time: two batches interleaving on one page would be nonsense. */
+  queue = Promise.resolve();
+  /**
+   * Run every browser call in a turn, in order, halting after the first
+   * failure. An aborted `signal` halts the rest the same way, so a caller that
+   * gave up on a stuck turn does not have its remaining calls land on the
+   * connection it rebuilt.
+   */
+  runTurn(calls, opts = {}) {
+    const run = this.queue.then(() => this.runTurnNow(calls, opts.signal));
+    this.queue = run.catch(() => {
+    });
+    return run;
+  }
+  async runTurnNow(calls, signal) {
+    const results = [];
+    const records = [];
+    let failed = false;
+    for (const call of calls) {
+      const input = redactInput(call.name, call.input ?? {});
+      if (failed || signal?.aborted) {
+        results.push(this.errorResult(call.id, HALT_TEXT));
+        records.push({
+          toolUseId: call.id,
+          name: call.name,
+          input,
+          text: HALT_TEXT,
+          isError: true
+        });
+        continue;
+      }
+      try {
+        const content = await this.execute(
+          call.name,
+          call.input ?? {}
+        );
+        results.push({
+          type: "tool_result",
+          tool_use_id: call.id,
+          toolset_name: BROWSER_TOOLSET_NAME,
+          content
+        });
+        const text2 = content.map(
+          (b) => b.type === "text" ? b.text : b.type === "browser_state" ? describeState(b) : ""
+        ).filter(Boolean).join("\n");
+        const image2 = content.find((b) => b.type === "image");
+        records.push({
+          toolUseId: call.id,
+          name: call.name,
+          input,
+          text: text2,
+          screenshotBase64: image2 && image2.type === "image" && image2.source.type === "base64" ? image2.source.data : void 0,
+          isError: false
+        });
+      } catch (err) {
+        failed = true;
+        const message = err instanceof ToolsetError ? err.message : `Error: ${err instanceof Error ? err.message : String(err)}`;
+        results.push(this.errorResult(call.id, message));
+        records.push({ toolUseId: call.id, name: call.name, input, text: message, isError: true });
+      }
+    }
+    return { results, records };
+  }
+  errorResult(toolUseId, text2) {
+    return {
+      type: "tool_result",
+      tool_use_id: toolUseId,
+      toolset_name: BROWSER_TOOLSET_NAME,
+      is_error: true,
+      content: text2
+    };
+  }
+  /** Execute one member. Throws `ToolsetError` (or anything) to fail the call. */
+  async execute(name, input) {
+    if (DISABLED_MEMBERS.has(name)) {
+      throw new ToolsetError(`Error: ${name} is not enabled in this environment.`);
+    }
+    if (TAB_MEMBERS.has(name)) return [await this.tabMember(name, input)];
+    const page = await this.pageFor(input.tab_id);
+    switch (name) {
+      case "navigate":
+        return this.navigate(page, input);
+      case "screenshot":
+        return [await this.screenshot(page)];
+      case "zoom":
+        return [await this.zoom(page, input)];
+      case "left_click":
+      case "right_click":
+      case "middle_click":
+      case "double_click":
+      case "triple_click": {
+        if (this.options.safety?.blockSubmit && name !== "right_click") {
+          const target = parseTarget(input.target, "any");
+          const facts = await this.inspect(page, target);
+          const reason = facts && submitReason(facts);
+          if (reason) return [text(refusalText(reason))];
+        }
+        return [text(await this.click(page, name, input))];
+      }
+      case "hover": {
+        const { x, y } = await this.point(page, parseTarget(input.target, "any"));
+        await page.hover(x, y);
+        return [text(`Hovered at (${x}, ${y})`)];
+      }
+      case "mouse_move": {
+        const { x, y } = await this.point(page, parseTarget(input.target, "coordinate"));
+        await page.hover(x, y);
+        return [text(`Moved the mouse to (${x}, ${y})`)];
+      }
+      case "left_click_drag": {
+        const from = await this.point(page, parseTarget(input.from, "coordinate"));
+        const to = await this.point(page, parseTarget(input.target, "coordinate"));
+        await page.dragAndDrop(from.x, from.y, to.x, to.y);
+        return [text(`Dragged from (${from.x}, ${from.y}) to (${to.x}, ${to.y})`)];
+      }
+      case "left_mouse_down":
+      case "left_mouse_up":
+      case "hold_key":
+        throw new ToolsetError(
+          `Error: ${name} is not supported by this browser. Use left_click, left_click_drag or key instead.`
+        );
+      case "scroll":
+        return [text(await this.scroll(page, input))];
+      case "scroll_to": {
+        const target = parseTarget(input.target, "ref");
+        const r = await this.pageCall(page, {
+          op: "resolve",
+          ref: target.ref,
+          scroll: true
+        });
+        if (!r.ok) throw new ToolsetError(`Error: ${r.error}`);
+        return [text(`Scrolled ${target.ref} into view`)];
+      }
+      case "type": {
+        const value = String(input.text ?? "");
+        const refusal = await this.typeRefusal(page, value);
+        if (refusal) return [text(refusal)];
+        await page.type(value);
+        return [text(`Typed ${value.length} character${value.length === 1 ? "" : "s"}`)];
+      }
+      case "key": {
+        const keys = toPlaywrightKeySequence(String(input.text ?? ""));
+        if (keys.length === 0) throw new ToolsetError("Error: key needs text.");
+        const repeat = Math.round(clampNumber(input.repeat, 1, 100, 1));
+        const refusal = await this.keyRefusal(page, keys);
+        if (refusal) return [text(refusal)];
+        for (let i = 0; i < repeat; i++) for (const k of keys) await page.keyPress(k);
+        return [text(`Pressed ${keys.join(" ")}${repeat > 1 ? ` x${repeat}` : ""}`)];
+      }
+      case "wait": {
+        const seconds = clampNumber(input.duration, 0, MAX_WAIT_SECONDS, 1);
+        await page.waitForTimeout(seconds * 1e3);
+        return [text(`Waited ${seconds}s`)];
+      }
+      case "read_page": {
+        const filter = input.filter === "interactive" || input.filter === "all" ? input.filter : "visible";
+        const depth = Math.round(clampNumber(input.depth, 1, 100, 15));
+        const ref = typeof input.ref === "string" ? input.ref : void 0;
+        const r = await this.pageCall(page, { op: "read", filter, depth, ref });
+        if (!r.ok) throw new ToolsetError(`Error: ${r.error}`);
+        return [text(r.text)];
+      }
+      case "find": {
+        const r = await this.pageCall(page, {
+          op: "find",
+          query: String(input.query ?? "")
+        });
+        if (!r.ok) throw new ToolsetError(`Error: ${r.error}`);
+        return [text(r.text)];
+      }
+      case "get_page_text": {
+        const r = await this.pageCall(page, { op: "text" });
+        if (!r.ok) throw new ToolsetError(`Error: ${r.error}`);
+        return [text(r.text)];
+      }
+      case "form_input": {
+        const target = parseTarget(input.target, "ref");
+        const value = input.value;
+        if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+          throw new ToolsetError("Error: form_input needs a string, number or boolean value.");
+        }
+        if (this.options.safety?.refuseSensitiveInput && typeof value !== "boolean") {
+          const refusal = containsCardNumber(String(value)) && refusalText("That value is a card number.") || await this.fieldRefusal(page, target);
+          if (refusal) return [text(refusal)];
+        }
+        const r = await this.pageCall(page, { op: "form", ref: target.ref, value });
+        if (!r.ok) throw new ToolsetError(`Error: ${r.error}`);
+        return [text(r.description)];
+      }
+      default:
+        throw new ToolsetError(
+          `Error: ${name} is not a browser toolset member this executor knows.`
+        );
+    }
+  }
+  // --- members -------------------------------------------------------------
+  async navigate(page, input) {
+    const raw = String(input.url ?? "").trim();
+    if (raw === "back" || raw === "forward") {
+      await (raw === "back" ? page.goBack() : page.goForward());
+      return [text(`Went ${raw} to ${await page.url()}`), await this.browserState()];
+    }
+    let url;
+    try {
+      const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) || /^(javascript|data|file|about|blob|mailto|vbscript|chrome|view-source):/i.test(raw);
+      url = new URL(hasScheme ? raw : `https://${raw}`);
+    } catch {
+      throw new ToolsetError(`Error: "${raw.slice(0, 200)}" is not a valid URL.`);
+    }
+    if (/^https?:$/.test(url.protocol) && !url.hostname.includes(".") && url.hostname !== "localhost") {
+      throw new ToolsetError(
+        `Error: "${raw.slice(0, 200)}" is not a URL. Pass a full address, or click the link with left_click.`
+      );
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      throw new ToolsetError("Error: Navigation refused. Only http and https URLs are allowed.");
+    }
+    if (!this.options.allowPrivateHosts && isPrivateHost(url.hostname)) {
+      throw new ToolsetError(
+        "Error: Navigation refused. Local and private network addresses are not reachable from this browser."
+      );
+    }
+    const refusal = this.options.checkNavigation?.(url.href);
+    if (refusal) throw new ToolsetError(`Error: Navigation refused. ${refusal}`);
+    await page.goto(url.href, {
+      waitUntil: "domcontentloaded",
+      ...this.options.navigationTimeoutMs ? { timeoutMs: this.options.navigationTimeoutMs } : {}
+    });
+    return [text(`Navigated to ${await page.url()}`), await this.browserState()];
+  }
+  async screenshot(page) {
+    const bytes = await page.screenshot({
+      type: "png",
+      ...this.options.screenshotTimeoutMs ? { timeout: this.options.screenshotTimeoutMs } : {}
+    });
+    return image(bytes.toString("base64"));
+  }
+  async zoom(page, input) {
+    const region = input.region;
+    if (!Array.isArray(region) || region.length !== 4 || !region.every((n) => typeof n === "number")) {
+      throw new ToolsetError("Error: zoom needs region [x0, y0, x1, y1].");
+    }
+    const [x0, y0, x1, y1] = region;
+    const width = Math.abs(x1 - x0);
+    const height = Math.abs(y1 - y0);
+    if (width < 1 || height < 1) throw new ToolsetError("Error: zoom region is empty.");
+    const bytes = await page.screenshot({
+      type: "png",
+      clip: { x: Math.min(x0, x1), y: Math.min(y0, y1), width, height },
+      ...this.options.screenshotTimeoutMs ? { timeout: this.options.screenshotTimeoutMs } : {}
+    });
+    return image(bytes.toString("base64"));
+  }
+  async click(page, name, input) {
+    if (Array.isArray(input.modifiers) ? input.modifiers.length > 0 : input.modifiers) {
+      throw new ToolsetError(
+        "Error: modifier clicks are not supported by this browser. Click without modifiers, or use key."
+      );
+    }
+    const target = parseTarget(input.target, "any");
+    const { x, y } = await this.point(page, target);
+    const button = name === "right_click" ? "right" : name === "middle_click" ? "middle" : "left";
+    const clickCount = name === "double_click" ? 2 : name === "triple_click" ? 3 : 1;
+    await page.click(x, y, { button, clickCount });
+    const where = target.type === "ref" ? `${target.ref} at (${x}, ${y})` : `(${x}, ${y})`;
+    return `${name.replace("_", " ")} on ${where}`;
+  }
+  async scroll(page, input) {
+    const direction = input.scroll_direction;
+    if (direction !== "up" && direction !== "down" && direction !== "left" && direction !== "right") {
+      throw new ToolsetError("Error: scroll_direction must be up, down, left or right.");
+    }
+    const amount = Math.round(clampNumber(input.scroll_amount, 1, 10, 3));
+    const { x, y } = await this.point(page, parseTarget(input.target, "any"));
+    const delta = amount * SCROLL_NOTCH_PX;
+    const dx = direction === "left" ? -delta : direction === "right" ? delta : 0;
+    const dy = direction === "up" ? -delta : direction === "down" ? delta : 0;
+    await page.scroll(x, y, dx, dy);
+    return `Scrolled ${direction} ${amount} at (${x}, ${y})`;
+  }
+  async tabMember(name, input) {
+    const ctx = this.driver.context;
+    if (name === "list_tabs") return this.browserState();
+    if (name === "new_tab") {
+      for (const existing of await ctx.pages()) this.tabId(existing);
+      const page2 = await ctx.newPage();
+      return this.browserState([{ type: "tab_opened", tab_id: this.tabId(page2) }]);
+    }
+    const page = await this.pageFor(input.tab_id, true);
+    if (name === "switch_tab") {
+      await ctx.setActivePage(page);
+      return this.browserState();
+    }
+    const wasActive = (await ctx.activePage())?.id === page.id;
+    await page.close();
+    if (wasActive) {
+      const remaining = await ctx.pages();
+      if (remaining.length > 0) await ctx.setActivePage(remaining[remaining.length - 1]);
+    }
+    return this.browserState();
+  }
+  // --- helpers -------------------------------------------------------------
+  tabId(page) {
+    let id = this.tabIds.get(page.id);
+    if (!id) {
+      this.tabSeq += 1;
+      id = `tab-${this.tabSeq}`;
+      this.tabIds.set(page.id, id);
+    }
+    return id;
+  }
+  async pageFor(tabId, required = false) {
+    const ctx = this.driver.context;
+    if (typeof tabId === "string" && tabId.length > 0) {
+      for (const page2 of await ctx.pages()) if (this.tabId(page2) === tabId) return page2;
+      throw new ToolsetError(
+        `Error: no tab with tab_id ${tabId}. Call list_tabs for the current tabs.`
+      );
+    }
+    if (required) throw new ToolsetError("Error: tab_id is required.");
+    const page = await ctx.activePage();
+    if (!page) throw new ToolsetError("Error: the browser has no open tab. Call new_tab first.");
+    return page;
+  }
+  async point(page, target) {
+    if (target.type === "coordinate") return { x: target.x, y: target.y };
+    let r = await this.pageCall(page, {
+      op: "resolve",
+      ref: target.ref,
+      scroll: true
+    });
+    if (r.ok && !r.inViewport) {
+      await page.waitForTimeout(250);
+      r = await this.pageCall(page, {
+        op: "resolve",
+        ref: target.ref,
+        scroll: false
+      });
+    }
+    if (!r.ok) throw new ToolsetError(`Error: ${r.error}`);
+    if (!r.inViewport) {
+      throw new ToolsetError(
+        `Error: ${target.ref} could not be scrolled into view. Try coordinates from a screenshot.`
+      );
+    }
+    return { x: r.x, y: r.y };
+  }
+  // --- safety guards ------------------------------------------------------
+  /** What the guards need to know about an element; null when nothing is there. */
+  async inspect(page, target) {
+    const r = await this.pageCall(page, { op: "inspect", target });
+    return r.ok ? r.facts : null;
+  }
+  async fieldRefusal(page, target) {
+    const facts = await this.inspect(page, target);
+    const reason = facts && sensitiveFieldReason(facts);
+    return reason ? refusalText(reason) : null;
+  }
+  /** Typing goes to whatever has focus, so that is what is checked. */
+  async typeRefusal(page, value) {
+    const safety = this.options.safety;
+    if (!safety) return null;
+    if (safety.refuseSensitiveInput) {
+      if (containsCardNumber(value)) return refusalText("That value is a card number.");
+      const refusal = await this.fieldRefusal(page, { type: "focused" });
+      if (refusal) return refusal;
+    }
+    if (safety.blockSubmit && /[\r\n]/.test(value)) {
+      const facts = await this.inspect(page, { type: "focused" });
+      const reason = facts && enterSubmitReason(facts);
+      if (reason) return refusalText(reason);
+    }
+    return null;
+  }
+  /** Enter submits the focused field's form; Enter or Space presses a focused button. */
+  async keyRefusal(page, keys) {
+    if (!this.options.safety?.blockSubmit) return null;
+    const pressesEnter = keys.some((k) => /(^|\+)(Enter|NumpadEnter)$/.test(k));
+    const pressesSpace = keys.some((k) => /(^|\+)(Space| )$/.test(k));
+    if (!pressesEnter && !pressesSpace) return null;
+    const facts = await this.inspect(page, { type: "focused" });
+    if (!facts) return null;
+    const reason = facts.isButton && submitReason(facts) || pressesEnter && enterSubmitReason(facts);
+    return reason ? refusalText(reason) : null;
+  }
+  pageCall(page, op) {
+    return page.evaluate(buildPageCall(op));
+  }
+  async browserState(stateChanges) {
+    const ctx = this.driver.context;
+    const [pages, active] = await Promise.all([ctx.pages(), ctx.activePage()]);
+    const tabs = await Promise.all(
+      pages.slice(0, 100).map(async (page) => ({
+        tab_id: this.tabId(page),
+        title: sanitiseStateField(await page.title().catch(() => "")),
+        url: sanitiseStateField(await Promise.resolve(page.url()).catch(() => "")),
+        ...active && page.id === active.id ? { active: true } : {}
+      }))
+    );
+    if (tabs.length > 0 && !tabs.some((t) => t.active)) tabs[tabs.length - 1].active = true;
+    return {
+      type: "browser_state",
+      tabs,
+      ...stateChanges && stateChanges.length > 0 ? { state_changes: stateChanges } : {}
+    };
+  }
+};
+function text(value) {
+  return { type: "text", text: value };
+}
+function image(data) {
+  return { type: "image", source: { type: "base64", media_type: "image/png", data } };
+}
+function describeState(state) {
+  const active = state.tabs.find((t) => t.active);
+  return active ? `Tab ${active.tab_id}: ${active.url}` : `${state.tabs.length} tabs`;
+}
+
+// ../browser-toolset/src/direct-tools.ts
+var MAX_READ_CHARS = 2e4;
+var TOOL_TIMEOUT_MS = 45e3;
+var NAVIGATION_TIMEOUT_MS = 3e4;
+var SCREENSHOT_TIMEOUT_MS = 1e4;
+var SETTLE_MS = 400;
+var SETTLE_LOAD_TIMEOUT_MS = 5e3;
+var TARGET_PROPERTIES = {
+  ref: {
+    type: "string",
+    description: 'An element ref from read_page or find, e.g. "ref_12". Preferred.'
+  },
+  x: {
+    type: "number",
+    description: "Viewport x coordinate in screenshot pixels, when there is no ref."
+  },
+  y: {
+    type: "number",
+    description: "Viewport y coordinate in screenshot pixels, when there is no ref."
+  }
+};
+var DIRECT_TOOL_SPECS = [
+  {
+    name: "navigate",
+    description: 'Go to a URL, or "back" / "forward" in history. Returns the page it landed on and a screenshot.',
+    parameters: {
+      type: "object",
+      properties: { url: { type: "string", description: 'A full URL, "back" or "forward".' } },
+      required: ["url"]
+    }
+  },
+  {
+    name: "read_page",
+    description: 'Read the page as an accessibility tree. Each element worth acting on carries a ref (ref_N) to pass to click, type, form_input or scroll. The filter "visible" (default) covers what is on screen, "interactive" only controls, "all" the whole page. Pass a ref to read just that part of the page.',
+    parameters: {
+      type: "object",
+      properties: {
+        filter: { type: "string", enum: ["visible", "interactive", "all"] },
+        ref: { type: "string", description: "Read only this element and its descendants." }
+      }
+    }
+  },
+  {
+    name: "find",
+    description: 'Find elements matching a description or text (e.g. "search box", "Add to cart"). Returns up to 20 matches with refs.',
+    parameters: {
+      type: "object",
+      properties: { query: { type: "string", description: "What to look for." } },
+      required: ["query"]
+    }
+  },
+  {
+    name: "get_page_text",
+    description: "The page's visible text as plain text, for reading content such as a policy.",
+    parameters: { type: "object", properties: {} }
+  },
+  {
+    name: "click",
+    description: "Click an element by ref, or at a coordinate from a screenshot. Returns the resulting page and a screenshot.",
+    parameters: { type: "object", properties: TARGET_PROPERTIES }
+  },
+  {
+    name: "type",
+    description: "Type text. With a ref (or coordinate), clicks that field first; without one, types into whatever has focus. Does not press Enter: use key for that.",
+    parameters: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "The text to type." },
+        ...TARGET_PROPERTIES
+      },
+      required: ["text"]
+    }
+  },
+  {
+    name: "form_input",
+    description: 'Set a form control directly by ref: choose a select option (by its label or value), tick or untick a checkbox or radio ("true" / "false"), or fill an input.',
+    parameters: {
+      type: "object",
+      properties: {
+        ref: { type: "string", description: "The control ref from read_page or find." },
+        // A string on every provider: a union type is not something every
+        // provider's function declarations take reliably, and the page script reads
+        // "true" / "false" as a checked state.
+        value: { type: "string", description: 'The option, "true" / "false", or the text.' }
+      },
+      required: ["ref", "value"]
+    }
+  },
+  {
+    name: "key",
+    description: 'Press a key or chord, e.g. "Enter", "Escape", "Tab", "ctrl+a". Space-separate several to press them in turn.',
+    parameters: {
+      type: "object",
+      properties: { text: { type: "string", description: "The key or keys." } },
+      required: ["text"]
+    }
+  },
+  {
+    name: "scroll",
+    description: "Scroll the page (or the element at a ref or coordinate) up, down, left or right. amount is in wheel notches of about 100px, default 5.",
+    parameters: {
+      type: "object",
+      properties: {
+        direction: { type: "string", enum: ["up", "down", "left", "right"] },
+        amount: { type: "number", description: "Notches, 1 to 10." },
+        ...TARGET_PROPERTIES
+      },
+      required: ["direction"]
+    }
+  },
+  {
+    name: "screenshot",
+    description: "Look at the current page.",
+    parameters: { type: "object", properties: {} }
+  },
+  {
+    name: "done",
+    description: "Signal that the task is complete. Provide a concise summary of what was accomplished.",
+    parameters: {
+      type: "object",
+      properties: { message: { type: "string", description: "Summary." } },
+      required: ["message"]
+    }
+  }
+];
+var DIRECT_TOOL_NAMES = DIRECT_TOOL_SPECS.map((s) => s.name);
+function clampRead(text2) {
+  if (text2.length <= MAX_READ_CHARS) return text2;
+  return `${text2.slice(0, MAX_READ_CHARS)}
+[truncated at ${MAX_READ_CHARS} characters: read_page with a ref or the "interactive" filter, or find, reads less]`;
+}
+function targetOf(input) {
+  if (typeof input.ref === "string" && input.ref.trim()) {
+    return { type: "ref", ref: input.ref.trim() };
+  }
+  const x = Number(input.x);
+  const y = Number(input.y);
+  if (input.x !== void 0 && input.y !== void 0 && Number.isFinite(x) && Number.isFinite(y)) {
+    return { type: "coordinate", x, y };
+  }
+  return null;
+}
+function blocksToText(blocks) {
+  return blocks.map((b) => {
+    const block = b;
+    return block.type === "text" && typeof block.text === "string" ? block.text : "";
+  }).filter(Boolean).join("\n");
+}
+function withTimeout(work, ms, what) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new ToolsetError(`Error: ${what} did not finish within ${ms / 1e3}s.`)),
+      ms
+    );
+  });
+  return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
+}
+var DirectBrowserTools = class {
+  driver;
+  executor;
+  viewport;
+  settleMs;
+  toolTimeoutMs;
+  constructor(driver, options) {
+    this.driver = driver;
+    this.executor = new BrowserToolsetExecutor(driver, {
+      navigationTimeoutMs: NAVIGATION_TIMEOUT_MS,
+      screenshotTimeoutMs: SCREENSHOT_TIMEOUT_MS,
+      ...options.safety ? { safety: options.safety } : {},
+      ...options.allowPrivateHosts ? { allowPrivateHosts: true } : {},
+      ...options.checkNavigation ? { checkNavigation: options.checkNavigation } : {}
+    });
+    this.viewport = options.viewport;
+    this.settleMs = options.settleMs ?? SETTLE_MS;
+    this.toolTimeoutMs = options.toolTimeoutMs ?? TOOL_TIMEOUT_MS;
+  }
+  /**
+   * Run one call. Never throws: a failure comes back as `error` with text the
+   * model can act on, so a harness loop can always build its tool result.
+   */
+  async run(name, input) {
+    try {
+      return await withTimeout(this.execute(name, input), this.toolTimeoutMs, name);
+    } catch (err) {
+      const text2 = err instanceof ToolsetError ? err.message : `Error: ${err instanceof Error ? err.message : String(err)}`;
+      return { text: text2, error: text2 };
+    }
+  }
+  async execute(name, input) {
+    switch (name) {
+      case "navigate": {
+        const out = await this.executor.execute("navigate", { url: input.url });
+        return this.afterInput(blocksToText(out.filter((b) => b.type === "text")));
+      }
+      case "read_page": {
+        const out = await this.executor.execute("read_page", {
+          filter: input.filter,
+          ...typeof input.ref === "string" && input.ref ? { ref: input.ref } : {}
+        });
+        return { text: clampRead(blocksToText(out)) };
+      }
+      case "find": {
+        const out = await this.executor.execute("find", { query: input.query });
+        return { text: clampRead(blocksToText(out)) };
+      }
+      case "get_page_text": {
+        const out = await this.executor.execute("get_page_text", {});
+        return { text: clampRead(blocksToText(out)) };
+      }
+      case "click": {
+        const target = targetOf(input);
+        if (!target) throw new ToolsetError("Error: click needs a ref, or both x and y.");
+        const out = await this.executor.execute("left_click", { target });
+        return this.afterInput(blocksToText(out));
+      }
+      case "type": {
+        const value = String(input.text ?? "");
+        const target = targetOf(input);
+        const said = [];
+        if (target) {
+          said.push(blocksToText(await this.executor.execute("left_click", { target })));
+        }
+        said.push(blocksToText(await this.executor.execute("type", { text: value })));
+        return this.afterInput(said.join("\n"));
+      }
+      case "form_input": {
+        if (typeof input.ref !== "string" || !input.ref) {
+          throw new ToolsetError("Error: form_input needs a ref from read_page or find.");
+        }
+        const out = await this.executor.execute("form_input", {
+          target: { type: "ref", ref: input.ref },
+          value: typeof input.value === "boolean" || typeof input.value === "number" ? input.value : String(input.value ?? "")
+        });
+        return this.afterInput(blocksToText(out));
+      }
+      case "key": {
+        const out = await this.executor.execute("key", { text: input.text });
+        return this.afterInput(blocksToText(out));
+      }
+      case "scroll": {
+        const target = targetOf(input) ?? {
+          type: "coordinate",
+          x: Math.round(this.viewport.width / 2),
+          y: Math.round(this.viewport.height / 2)
+        };
+        const out = await this.executor.execute("scroll", {
+          scroll_direction: input.direction,
+          scroll_amount: input.amount ?? 5,
+          target
+        });
+        return this.afterInput(blocksToText(out));
+      }
+      case "screenshot": {
+        const page = await this.activePage();
+        return {
+          text: `Screenshot of ${await page.url()}`,
+          screenshotBase64: await this.capture(page)
+        };
+      }
+      case "done":
+        return { text: "Done tool invoked" };
+      default:
+        throw new ToolsetError(
+          `Error: ${name} is not an available tool. Use one of: ${DIRECT_TOOL_NAMES.join(", ")}.`
+        );
+    }
+  }
+  /**
+   * After anything that can change the page: let it settle, then report where
+   * the browser is with a screenshot. The agent sees the effect of its action
+   * without spending a turn asking.
+   */
+  async afterInput(said) {
+    const page = await this.activePage();
+    if (this.settleMs > 0) {
+      await page.waitForTimeout(this.settleMs);
+      await page.waitForLoadState("domcontentloaded", SETTLE_LOAD_TIMEOUT_MS).catch(() => {
+      });
+    }
+    const [url, title] = await Promise.all([
+      Promise.resolve(page.url()).catch(() => ""),
+      page.title().catch(() => "")
+    ]);
+    const where = title ? `Now on ${url} (${title.slice(0, 120)})` : `Now on ${url}`;
+    return {
+      text: said ? `${said}
+${where}` : where,
+      screenshotBase64: await this.capture(page)
+    };
+  }
+  async capture(page) {
+    const bytes = await page.screenshot({ type: "png", timeout: SCREENSHOT_TIMEOUT_MS });
+    return Buffer.from(bytes).toString("base64");
+  }
+  async activePage() {
+    const page = await this.driver.context.activePage();
+    if (!page) throw new ToolsetError("Error: the browser has no open page.");
+    return page;
+  }
+};
+
+// src/mcp.ts
+import { z } from "zod";
+
+// src/run.ts
+import { mkdir, mkdtemp, readFile, rm, stat } from "fs/promises";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+
+// package.json
+var package_default = {
+  name: "stuntdouble",
+  version: "0.1.0",
+  description: "Stunt Double Local: run Stunt Double checklists in a local Chrome from your own coding agent session, with the runs kept as files and a local viewer",
+  keywords: [
+    "stunt-double",
+    "testing",
+    "browser",
+    "checklist",
+    "mcp",
+    "playwright",
+    "agents"
+  ],
+  license: "Apache-2.0",
+  author: "Turnout Labs Ltd",
+  homepage: "https://github.com/stunt-double/stuntkit/tree/main/packages/local#readme",
+  bugs: {
+    url: "https://github.com/stunt-double/stuntkit/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/stunt-double/stuntkit.git",
+    directory: "packages/local"
+  },
+  type: "module",
+  bin: {
+    stuntdouble: "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    build: "tsup",
+    "type-check": "tsc -p tsconfig.json",
+    test: 'node --conditions=@stunt-double/source --test "test/**/*.test.ts"',
+    prepack: "pnpm run build"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "playwright-core": "^1.64.1",
+    zod: "^4.6.7"
+  },
+  devDependencies: {
+    "@stunt-double/browser-toolset": "workspace:*"
+  },
+  engines: {
+    node: ">=22.18"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org",
+    provenance: true
+  }
+};
+
+// src/brief.ts
+var CONDITION_LABELS = {
+  always: "always",
+  if_previous_passed: "only if the check before it passed",
+  if_previous_failed: "only if the check before it failed"
+};
+function checkLabel(check) {
+  const kind = check.type === "informational" ? "informational, record what you observe" : check.type === "weighted" ? `weighted x${check.weight ?? 1}${(check.weight ?? 1) < 0 ? ", a penalty" : ""}` : "pass/fail";
+  const parts = [kind, CONDITION_LABELS[check.run_condition]];
+  if (check.on_failure === "stop") parts.push("the run stops if it fails");
+  return `(${parts.join(", ")})`;
+}
+function checkLine(check) {
+  return `- [${check.key}] ${checkLabel(check)} ${check.description}`;
+}
+function buildBrief(input) {
+  const { actor, checklist, url, checks, resumed } = input;
+  const persona = [
+    `You are ${actor.name}${actor.description ? `: ${actor.description}` : ""}.`,
+    actor.system_prompt ?? ""
+  ].filter(Boolean).join("\n");
+  const knowledge = actor.knowledge.length ? [
+    "What you know:",
+    ...actor.knowledge.map((k) => `### ${k.title} (${k.kind})
+${k.content}`)
+  ].join("\n") : "";
+  return [
+    persona,
+    knowledge,
+    `Your task: ${checklist.instructions}`,
+    `Start at ${url}${resumed ? " (this run is resuming: earlier verdicts stand, judge only the checks below)" : ""}.`,
+    `Checks to judge:
+${checks.map(checkLine).join("\n")}`,
+    [
+      "How to work:",
+      "- Stay in persona: act and judge as this person would, not as a tester.",
+      "- Read the page with read_page and find. Ask for a screenshot only when how something looks is the question.",
+      "- Judge each check with evaluate_check as soon as you have observed it, while the evidence is on screen.",
+      "- A passed verdict needs a locator: text visible on the page, or a CSS selector, that shows the evidence. A failure may describe something missing.",
+      "- Cite only what you saw in this run. Never pass a check on what a page probably does.",
+      '- When something stops you (a sign-in wall, a broken page, a CAPTCHA), judge the checks you cannot reach as "blocked" and say what stopped you.',
+      "- Always end with finish_run and a one or two sentence summary, even when blocked or stopped."
+    ].join("\n")
+  ].filter(Boolean).join("\n\n");
+}
+
+// src/driver.ts
+import { chromium } from "playwright-core";
+var pageIds = /* @__PURE__ */ new WeakMap();
+var pageSeq = 0;
+function idOf(page) {
+  let id = pageIds.get(page);
+  if (!id) {
+    pageSeq += 1;
+    id = `pw-${pageSeq}`;
+    pageIds.set(page, id);
+  }
+  return id;
+}
+var PlaywrightPage = class {
+  id;
+  raw;
+  constructor(page) {
+    this.raw = page;
+    this.id = idOf(page);
+  }
+  goto(url, options = {}) {
+    return this.raw.goto(url, {
+      ...options.waitUntil ? { waitUntil: options.waitUntil } : {},
+      ...options.timeoutMs ? { timeout: options.timeoutMs } : {}
+    });
+  }
+  goBack() {
+    return this.raw.goBack();
+  }
+  goForward() {
+    return this.raw.goForward();
+  }
+  screenshot(options = {}) {
+    return this.raw.screenshot(options);
+  }
+  evaluate(expression, arg) {
+    if (typeof expression === "string") return this.raw.evaluate(expression);
+    return this.raw.evaluate(expression, arg);
+  }
+  url() {
+    return this.raw.url();
+  }
+  title() {
+    return this.raw.title();
+  }
+  setViewportSize(width, height) {
+    return this.raw.setViewportSize({ width, height });
+  }
+  waitForTimeout(ms) {
+    return this.raw.waitForTimeout(ms);
+  }
+  waitForSelector(selector, options = {}) {
+    return this.raw.waitForSelector(selector, options);
+  }
+  waitForLoadState(state, timeoutMs) {
+    return this.raw.waitForLoadState(state, timeoutMs ? { timeout: timeoutMs } : void 0);
+  }
+  locator(selector) {
+    return this.raw.locator(selector).first();
+  }
+  click(x, y, options = {}) {
+    return this.raw.mouse.click(x, y, options);
+  }
+  hover(x, y) {
+    return this.raw.mouse.move(x, y);
+  }
+  async scroll(x, y, deltaX, deltaY) {
+    await this.raw.mouse.move(x, y);
+    await this.raw.mouse.wheel(deltaX, deltaY);
+  }
+  async dragAndDrop(fromX, fromY, toX, toY) {
+    await this.raw.mouse.move(fromX, fromY);
+    await this.raw.mouse.down();
+    await this.raw.mouse.move(toX, toY, { steps: 10 });
+    await this.raw.mouse.up();
+  }
+  type(text2) {
+    return this.raw.keyboard.type(text2);
+  }
+  keyPress(key) {
+    return this.raw.keyboard.press(key);
+  }
+  close() {
+    return this.raw.close();
+  }
+};
+var PlaywrightContext = class {
+  context;
+  active;
+  policy = {};
+  routed = false;
+  constructor(context) {
+    this.context = context;
+    context.on("page", (page) => {
+      this.active = page;
+    });
+  }
+  activePage() {
+    const open = this.context.pages();
+    if (!this.active || this.active.isClosed()) this.active = open[open.length - 1];
+    return this.active ? new PlaywrightPage(this.active) : void 0;
+  }
+  pages() {
+    return this.context.pages().map((p) => new PlaywrightPage(p));
+  }
+  async newPage(url) {
+    const page = await this.context.newPage();
+    this.active = page;
+    if (url) await page.goto(url);
+    return new PlaywrightPage(page);
+  }
+  async setActivePage(page) {
+    const raw = this.context.pages().find((p) => idOf(p) === page.id);
+    if (!raw) throw new Error(`No open tab with id ${page.id}`);
+    this.active = raw;
+    await raw.bringToFront();
+  }
+  clearCookies() {
+    return this.context.clearCookies();
+  }
+  async addInitScript(source) {
+    await this.context.addInitScript(source);
+  }
+  /** Abort requests to blocked hosts, or to anything outside the allow list. */
+  async setDomainPolicy(policy) {
+    this.policy = policy;
+    if (this.routed) return;
+    this.routed = true;
+    await this.context.route("**/*", (route) => {
+      let host = "";
+      try {
+        host = new URL(route.request().url()).hostname;
+      } catch {
+        return route.continue();
+      }
+      const { allowedDomains, blockedDomains } = this.policy;
+      const blocked = (blockedDomains ?? []).some((d) => hostMatchesDomain(host, d)) || allowedDomains !== void 0 && allowedDomains.length > 0 && !allowedDomains.some((d) => hostMatchesDomain(host, d));
+      return blocked ? route.abort("blockedbyclient") : route.continue();
+    });
+  }
+};
+var PlaywrightDriver = class _PlaywrightDriver {
+  context;
+  browserContext;
+  refusal = null;
+  constructor(context) {
+    this.browserContext = context;
+    this.context = new PlaywrightContext(context);
+  }
+  /**
+   * The installed Google Chrome, or Playwright's own Chromium when Chrome is
+   * missing and `npx playwright install chromium` has been run.
+   */
+  static async launch(options) {
+    const settings = {
+      headless: options.headless,
+      viewport: options.viewport,
+      hasTouch: options.touch,
+      ...options.locale ? { locale: options.locale } : {}
+    };
+    let context;
+    try {
+      context = await chromium.launchPersistentContext(options.profileDir, {
+        ...settings,
+        channel: "chrome"
+      });
+    } catch (chromeError) {
+      try {
+        context = await chromium.launchPersistentContext(options.profileDir, settings);
+      } catch {
+        throw new Error(
+          `Could not start Chrome (${chromeError.message.split("\n")[0]}). Install Google Chrome, or run \`npx playwright install chromium\`.`
+        );
+      }
+    }
+    const driver = new _PlaywrightDriver(context);
+    const refuse = (request) => {
+      const reason = request.isNavigationRequest() ? options.refuseNavigation(request.url()) : null;
+      if (reason && !request.frame().parentFrame()) driver.refusal = reason;
+      return reason;
+    };
+    await context.route(
+      "**/*",
+      (route) => refuse(route.request()) ? route.abort("blockedbyclient") : route.fallback()
+    );
+    context.on("request", (request) => {
+      if (request.redirectedFrom() && refuse(request)) {
+        request.frame().goto("about:blank").catch(() => {
+        });
+      }
+    });
+    if (context.pages().length === 0) await driver.context.newPage();
+    return driver;
+  }
+  takeRefusal() {
+    const refusal = this.refusal;
+    this.refusal = null;
+    return refusal;
+  }
+  /** Instruction-style actions need a model of their own. Nothing here calls them. */
+  async act() {
+    throw new Error("act is not supported by this driver: use the browser toolset instead");
+  }
+  async extract() {
+    throw new Error("extract is not supported by this driver: use the browser toolset instead");
+  }
+  close() {
+    return this.browserContext.close();
+  }
+};
+
+// src/evidence.ts
+var MAX_LOCATOR_TEXT = 120;
+var MAX_LOCATOR_SELECTOR = 400;
+var SETTLE_MS2 = 350;
+function cleanLocator(locator) {
+  const clean = (value) => value?.replace(/\s+/g, " ").trim() || null;
+  const selector = clean(locator?.selector);
+  return {
+    selector: selector && selector.length <= MAX_LOCATOR_SELECTOR ? selector : null,
+    text: clean(locator?.text)?.slice(0, MAX_LOCATOR_TEXT) ?? null
+  };
+}
+async function focusEvidence(page, query) {
+  if (!query.selector && !query.text) return null;
+  const via = await page.evaluate(findAndScroll, query).catch(() => null);
+  if (via) await page.waitForTimeout(SETTLE_MS2).catch(() => {
+  });
+  return via;
+}
+function findAndScroll(query) {
+  const centre = { block: "center", inline: "center" };
+  const shown = (el) => {
+    const rect = el.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0 && el.checkVisibility({ visibilityProperty: true, opacityProperty: true });
+  };
+  const norm = (s) => (s ?? "").replace(/\s+/g, " ").toLowerCase();
+  const wanted = query.text ? norm(query.text) : null;
+  const labelled = (el, fragment) => {
+    const labels = ["placeholder", "aria-label", "alt", "title"].map((a) => el.getAttribute(a));
+    if ("value" in el && typeof el.value === "string") labels.push(el.value);
+    return labels.some((l) => norm(l).includes(fragment));
+  };
+  const rendered = (el) => norm(el instanceof HTMLElement ? el.innerText : "");
+  if (query.selector) {
+    let matches = [];
+    try {
+      matches = Array.from(document.querySelectorAll(query.selector));
+    } catch {
+    }
+    const el = matches.find(
+      (m) => m !== document.documentElement && m !== document.body && m.tagName !== "MAIN" && shown(m) && (!wanted || labelled(m, wanted) || rendered(m).includes(wanted))
+    );
+    if (el) {
+      el.scrollIntoView(centre);
+      return "selector";
+    }
+  }
+  if (!wanted) return null;
+  const elements = [];
+  const collect = (root) => {
+    for (const el of Array.from(root.querySelectorAll("*"))) {
+      elements.push(el);
+      if (el.shadowRoot) collect(el.shadowRoot);
+    }
+  };
+  collect(document.body);
+  let best = null;
+  let bestLength = Number.POSITIVE_INFINITY;
+  for (const el of elements) {
+    if (["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE"].includes(el.tagName)) continue;
+    let length = 0;
+    if (!labelled(el, wanted)) {
+      const text2 = rendered(el);
+      length = text2.includes(wanted) ? text2.length : Number.POSITIVE_INFINITY;
+    }
+    if (length >= bestLength || !shown(el)) continue;
+    best = el;
+    bestLength = length;
+  }
+  if (!best) return null;
+  best.scrollIntoView(centre);
+  return "text";
+}
+
+// src/run.ts
+var PACKAGE = `${package_default.name}@${package_default.version}`;
+var STOPPED = "This run was stopped from the viewer. Do not use the browser again: call finish_run now with a summary of what you found.";
+var NOT_JUDGED = "Not judged before the run finished.";
+var PRIVATE_REFUSED = "Local and private addresses other than the app under test are not reachable.";
+var LOG_TEXT_CHARS = 500;
+var PRESETS = {
+  desktop: { width: 1280, height: 720, touch: false },
+  tablet: { width: 1024, height: 1366, touch: true },
+  mobile: { width: 390, height: 844, touch: true }
+};
+function rebase(url, localBase) {
+  if (!localBase) return url;
+  const target = new URL(url);
+  return new URL(target.pathname + target.search + target.hash, new URL(localBase).origin).href;
+}
+function stamp(date = /* @__PURE__ */ new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${p(date.getMonth() + 1)}${p(date.getDate())}-${p(date.getHours())}${p(date.getMinutes())}${p(date.getSeconds())}`;
+}
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var LocalSession = class {
+  root;
+  launch;
+  active = null;
+  ui = null;
+  constructor(options) {
+    this.root = sdDir(options.project);
+    this.launch = options.launch ?? PlaywrightDriver.launch;
+  }
+  /** The viewer's address, starting it on first use. */
+  async openUi(path = "/") {
+    this.ui ??= await startUi({ root: this.root });
+    await writeJsonAtomic(join(this.root, ".live", "server.json"), {
+      port: this.ui.port,
+      token: this.ui.token,
+      pid: process.pid
+    });
+    return this.ui.link(path);
+  }
+  async startRun(input) {
+    if (this.active) return this.resumeActive(input);
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(input.checklist)) {
+      throw new Error(`"${input.checklist}" is not a checklist slug (checklists/<slug>.json).`);
+    }
+    const config = await readJson(
+      join(this.root, "stuntdouble.json"),
+      ConfigSchema,
+      ".stuntdouble/stuntdouble.json"
+    );
+    let checklist = await readJson(
+      join(this.root, "checklists", `${input.checklist}.json`),
+      ChecklistSchema,
+      `.stuntdouble/checklists/${input.checklist}.json`
+    );
+    const actor = await readJson(
+      join(this.root, "actors", `${checklist.actor}.json`),
+      ActorSchema,
+      `.stuntdouble/actors/${checklist.actor}.json`
+    );
+    await this.markInterrupted();
+    let run;
+    let dir;
+    if (input.resume) {
+      const entry = (await readRuns(this.root)).find(
+        (e) => "run" in e && e.run.checklist === input.checklist && e.run.runner.kind === "local" && (e.run.status === "interrupted" || e.run.status === "stopped")
+      );
+      if (!entry || !("run" in entry)) {
+        throw new Error(`No interrupted or stopped run of ${input.checklist} to resume.`);
+      }
+      dir = join(this.root, "runs", entry.id);
+      checklist = ChecklistSchema.parse(entry.run.checklist_snapshot);
+      await this.clearStop(entry.id);
+      run = {
+        ...entry.run,
+        results: entry.run.results.filter((r) => r.evidence !== NOT_JUDGED),
+        status: "running",
+        pid: process.pid,
+        finished_at: null,
+        score: null,
+        summary: null
+      };
+    } else {
+      dir = "";
+      run = {
+        format: "stuntdouble.run/1",
+        id: "",
+        runner: { kind: "local", package: PACKAGE, judged: false },
+        status: "running",
+        pid: process.pid,
+        url: rebase(checklist.url, config.local_base_url),
+        started_at: now(),
+        finished_at: null,
+        checklist: input.checklist,
+        actor: checklist.actor,
+        checklist_snapshot: { ...checklist, cloud: void 0 },
+        results: [],
+        score: null,
+        summary: null,
+        cloud: null
+      };
+    }
+    const trusted = [run.url, checklist.url, config.local_base_url].filter((u) => Boolean(u)).map((u) => new URL(u));
+    const trustedHosts = [...new Set(trusted.map((u) => u.hostname))];
+    const trustedOrigins = new Set(trusted.map((u) => u.origin));
+    const refuseNavigation = (href) => {
+      const url = URL.parse(href);
+      return url && isPrivateHost(url.hostname) && !trustedOrigins.has(url.origin) ? PRIVATE_REFUSED : null;
+    };
+    const preset = PRESETS[checklist.browser_config?.preset ?? "desktop"];
+    const toolOptions = {
+      viewport: checklist.browser_config?.viewport ?? preset,
+      allowPrivateHosts: true,
+      checkNavigation: refuseNavigation
+    };
+    const tempProfile = actor.persist_login ? null : await mkdtemp(join(tmpdir(), "stuntdouble-profile-"));
+    const profileDir = tempProfile ?? join(homedir(), ".stuntdouble", "profiles", checklist.actor);
+    await mkdir(profileDir, { recursive: true });
+    let driver;
+    try {
+      driver = await this.launch({
+        profileDir,
+        headless: config.headless,
+        viewport: toolOptions.viewport,
+        touch: checklist.browser_config?.touch ?? preset.touch,
+        locale: checklist.browser_config?.locale,
+        refuseNavigation
+      });
+    } catch (err) {
+      if (tempProfile) await rm(tempProfile, { recursive: true, force: true });
+      throw err;
+    }
+    if (!input.resume) {
+      await mkdir(join(this.root, "runs"), { recursive: true });
+      for (let n = 1; !dir; n++) {
+        const id = `${stamp()}-${input.checklist}${n > 1 ? `-${n}` : ""}`;
+        const made = await mkdir(join(this.root, "runs", id)).then(
+          () => true,
+          (err) => {
+            if (err.code === "EEXIST") return false;
+            throw err;
+          }
+        );
+        if (made) [run.id, dir] = [id, join(this.root, "runs", id)];
+      }
+    }
+    const gitignore = join(this.root, ".gitignore");
+    if (!await stat(gitignore).catch(() => null)) await writeFileAtomic(gitignore, ".live/\n");
+    this.active = {
+      dir,
+      run,
+      checklist,
+      actor,
+      driver,
+      trusted: new DirectBrowserTools(driver, toolOptions),
+      guarded: config.safety === "third_party" ? new DirectBrowserTools(driver, { ...toolOptions, safety: INDEX_SESSION_SAFETY }) : null,
+      trustedHosts,
+      tempProfile,
+      everyScreenshot: config.model_screenshots === "every_action",
+      stopped: false
+    };
+    await this.save();
+    await this.log("start_run", input, input.resume ? "Resumed" : "Started");
+    const opened = await this.browserTool("navigate", { url: run.url });
+    const pending = this.pending();
+    const viewer = await this.openUi(`/runs/${run.id}`);
+    return [
+      `Run ${run.id} ${input.resume ? "resumed" : "started"}. Watch it or stop it at ${viewer}`,
+      buildBrief({
+        actor,
+        checklist,
+        url: run.url,
+        checks: pending,
+        resumed: Boolean(input.resume)
+      }),
+      opened.isError ? `The start page did not load: ${opened.text}
+Try navigate again, or judge the checks you cannot reach as "blocked".` : opened.text,
+      this.nextStep()
+    ].join("\n\n");
+  }
+  /** One of the browser toolset's direct tools, on the active run's browser. */
+  async browserTool(name, input) {
+    const active = this.requireActive();
+    if (await this.stopRequested(active)) return { text: STOPPED, isError: true };
+    const page = await active.driver.context.activePage();
+    const host = page ? URL.parse(await page.url())?.hostname ?? "" : "";
+    const tools = active.guarded && host && !active.trustedHosts.some((t) => hostMatchesDomain(host, t)) ? active.guarded : active.trusted;
+    const result = await tools.run(name, input);
+    const refusal = active.driver.takeRefusal();
+    if (refusal) {
+      const text2 = `Error: Navigation refused. ${refusal}`;
+      await this.log(name, redactInput(name, input), text2);
+      return { text: text2, isError: true };
+    }
+    if (result.screenshotBase64)
+      await this.saveFrame(Buffer.from(result.screenshotBase64, "base64"));
+    await this.log(name, redactInput(name, input), result.text);
+    const image2 = result.screenshotBase64 && (name === "screenshot" || active.everyScreenshot) ? result.screenshotBase64 : void 0;
+    return { text: result.text, ...image2 ? { image: image2 } : {}, isError: Boolean(result.error) };
+  }
+  async evaluateCheck(input) {
+    const active = this.requireActive();
+    if (await this.stopRequested(active)) throw new Error(STOPPED);
+    const { run, checklist } = active;
+    const check = checklist.checks.find((c) => c.key === input.check);
+    if (!check) {
+      throw new Error(
+        `No check "${input.check}" in this run. The keys are: ${checklist.checks.map((c) => c.key).join(", ")}.`
+      );
+    }
+    const earlier = run.results.find((r) => r.check === check.key);
+    if (earlier) {
+      throw new Error(
+        `[${check.key}] already has a verdict (${earlier.status}). Each check gets one.`
+      );
+    }
+    if (check.type === "informational" && (input.status === "passed" || input.status === "failed")) {
+      throw new Error(
+        `[${check.key}] is informational: record what you observed with status "informational".`
+      );
+    }
+    if (check.type !== "informational" && input.status === "informational") {
+      throw new Error(
+        `[${check.key}] is scored: judge it "passed" or "failed", or "blocked" if you could not reach it.`
+      );
+    }
+    const page = await active.driver.context.activePage();
+    const query = cleanLocator(input.locator);
+    const found = page ? await focusEvidence(page, query) : null;
+    if (input.status === "passed" && !found) {
+      throw new Error(
+        query.text || query.selector ? `Not recorded: the locator ${JSON.stringify(query.text ?? query.selector)} is not visible on the current page. Go back to where you saw the evidence, or cite text that is on screen now.` : 'Not recorded: a passed verdict needs a locator, {"text": "..."} visible on the page or {"selector": "..."}.'
+      );
+    }
+    let screenshot;
+    if (page) {
+      try {
+        const png = await page.screenshot({ type: "png", timeout: 1e4 });
+        screenshot = `shots/${check.key}.png`;
+        await writeFileAtomic(join(active.dir, screenshot), png);
+        await this.saveFrame(png);
+      } catch {
+        screenshot = void 0;
+      }
+    }
+    run.results.push({
+      check: check.key,
+      status: input.status === "blocked" ? "error" : input.status,
+      evidence: input.evidence,
+      ...query.text || query.selector ? {
+        locator: {
+          ...query.text ? { text: query.text } : {},
+          ...query.selector ? { selector: query.selector } : {}
+        }
+      } : {},
+      ...screenshot ? { screenshot } : {},
+      at: now()
+    });
+    const statuses = new Map(run.results.map((r) => [r.check, r.status]));
+    const halted = resolveHaltedChecks({
+      checks: checklist.checks.map((c) => ({
+        id: c.key,
+        description: c.description,
+        onFailure: c.on_failure
+      })),
+      statuses
+    });
+    const skipped = halted.length ? halted : this.conditionSkips(statuses);
+    for (const s of skipped) {
+      run.results.push({ check: s.checkId, status: "skipped", evidence: s.reason, at: now() });
+    }
+    await this.save();
+    const recorded = `Recorded [${check.key}] as ${input.status}.`;
+    await this.log("evaluate_check", input, recorded);
+    const notes = skipped.map((s) => `[${s.checkId}] ${s.reason}`);
+    if (halted.length) notes.push("The run has stopped.");
+    return [recorded, ...notes, this.nextStep()].join("\n");
+  }
+  async finishRun(input) {
+    const active = this.requireActive();
+    const stopped = await this.stopRequested(active);
+    const { run, checklist } = active;
+    for (const s of this.conditionSkips(new Map(run.results.map((r) => [r.check, r.status])))) {
+      run.results.push({ check: s.checkId, status: "skipped", evidence: s.reason, at: now() });
+    }
+    for (const check of this.pending()) {
+      run.results.push({
+        check: check.key,
+        status: "error",
+        evidence: NOT_JUDGED,
+        at: now()
+      });
+    }
+    const score = scoreLocalRun(checklist, run.results);
+    run.score = {
+      score: score.score,
+      unit: score.scoreUnit,
+      outcome: score.outcome,
+      pass_threshold: score.passThreshold,
+      grade: score.grade
+    };
+    run.summary = input.summary;
+    run.status = stopped ? "stopped" : "completed";
+    run.finished_at = now();
+    await this.save();
+    await this.log("finish_run", input, `Finished: ${score.outcome}`);
+    const viewer = await this.openUi(`/runs/${run.id}`);
+    await this.endBrowser();
+    const line = (r) => `- [${r.check}] ${r.evidence}`;
+    const failed = run.results.filter((r) => r.status === "failed");
+    const blocked = run.results.filter((r) => r.status === "error");
+    const counts = describeRunScore(score, {
+      passedCount: run.results.filter((r) => r.status === "passed").length,
+      totalCount: checklist.checks.length
+    });
+    return [
+      `Run ${run.id} ${run.status}: ${score.outcome}. ${counts}. Self-judged: the actor recorded its own verdicts.`,
+      failed.length ? `Failed:
+${failed.map(line).join("\n")}` : "",
+      blocked.length ? `Not judged:
+${blocked.map(line).join("\n")}` : "",
+      `Report: ${viewer}`
+    ].filter(Boolean).join("\n\n");
+  }
+  /**
+   * start_run while this process still has a run open, as when the person
+   * interrupts the actor: resume carries on with it in the same browser.
+   */
+  async resumeActive(input) {
+    const active = this.requireActive();
+    const { run } = active;
+    if (!input.resume || run.checklist !== input.checklist) {
+      throw new Error(
+        `Run ${run.id} of ${run.checklist} is still going: call start_run with checklist "${run.checklist}" and resume to carry on with it, or finish_run to end it.`
+      );
+    }
+    active.stopped = false;
+    run.status = "running";
+    await this.clearStop(run.id);
+    await this.save();
+    await this.log("start_run", input, "Resumed");
+    const viewer = await this.openUi(`/runs/${run.id}`);
+    return [
+      `Run ${run.id} resumed. Watch it or stop it at ${viewer}`,
+      buildBrief({
+        actor: active.actor,
+        checklist: active.checklist,
+        url: run.url,
+        checks: this.pending(),
+        resumed: true
+      }),
+      "The browser is still open where the run left off: read the page before acting.",
+      this.nextStep()
+    ].join("\n\n");
+  }
+  /** On shutdown: an unfinished run is marked interrupted, so it can be resumed. */
+  async close() {
+    if (this.active) {
+      this.active.run.status = this.active.stopped ? "stopped" : "interrupted";
+      await this.save().catch(() => {
+      });
+      await this.endBrowser();
+    }
+    await this.ui?.close();
+    this.ui = null;
+  }
+  requireActive() {
+    if (!this.active) throw new Error("No run is going: call start_run first.");
+    return this.active;
+  }
+  /** Checks with no result yet, in run order. */
+  pending() {
+    const active = this.requireActive();
+    const judged = new Set(active.run.results.map((r) => r.check));
+    return active.checklist.checks.filter((c) => !judged.has(c.key));
+  }
+  conditionSkips(statuses) {
+    return resolveSkippedChecks({
+      checks: this.requireActive().checklist.checks.map((c) => ({
+        id: c.key,
+        description: c.description,
+        runCondition: c.run_condition
+      })),
+      statuses
+    });
+  }
+  nextStep() {
+    const pending = this.pending();
+    if (pending.length === 0)
+      return "Every check has a verdict: call finish_run with a short summary.";
+    const next = pending[0];
+    return `Next: [${next.key}] ${checkLabel(next)} ${next.description} (${pending.length} left).`;
+  }
+  /** The viewer's Stop writes the run id to `.live/stop`; the run notices on its next call. */
+  async stopRequested(active) {
+    if (active.stopped) return true;
+    const flag = await readFile(join(this.root, ".live", "stop"), "utf8").catch(() => "");
+    if (flag.trim() !== active.run.id) return false;
+    active.stopped = true;
+    active.run.status = "stopped";
+    await this.save();
+    await this.log("stop", {}, "Stopped from the viewer");
+    return true;
+  }
+  /** Runs left `running` by a process that is gone, or by this one before a restart. */
+  async markInterrupted() {
+    for (const entry of await readRuns(this.root)) {
+      if (!("run" in entry) || entry.run.status !== "running") continue;
+      if (entry.run.pid !== process.pid && isAlive(entry.run.pid)) continue;
+      await writeJsonAtomic(join(this.root, "runs", entry.id, "run.json"), {
+        ...entry.run,
+        status: "interrupted"
+      });
+    }
+  }
+  async endBrowser() {
+    const active = this.active;
+    if (!active) return;
+    this.active = null;
+    await active.driver.close().catch(() => {
+    });
+    if (active.tempProfile) await rm(active.tempProfile, { recursive: true, force: true });
+    await this.clearStop(active.run.id);
+  }
+  async clearStop(id) {
+    const stopFile = join(this.root, ".live", "stop");
+    const flag = await readFile(stopFile, "utf8").catch(() => "");
+    if (flag.trim() === id) await rm(stopFile, { force: true });
+  }
+  async save() {
+    const active = this.requireActive();
+    await writeJsonAtomic(join(active.dir, "run.json"), active.run);
+  }
+  async log(tool, input, text2) {
+    const active = this.requireActive();
+    await appendJsonl(join(active.dir, "activity.jsonl"), {
+      at: now(),
+      tool,
+      input,
+      text: text2.length > LOG_TEXT_CHARS ? `${text2.slice(0, LOG_TEXT_CHARS)}...` : text2
+    });
+  }
+  /** The viewer's live frame, best effort. ponytail: one per project, so two sessions running at once share it. */
+  async saveFrame(png) {
+    await writeFileAtomic(join(this.root, ".live", "latest.png"), png).catch(() => {
+    });
+  }
+};
+function scoreLocalRun(checklist, results) {
+  const scoring = newChecklistScoring({
+    scoreType: checklist.score_type,
+    scoreUnit: checklist.score_unit,
+    passThreshold: checklist.pass_threshold,
+    scoreBands: checklist.score_bands,
+    checks: checklist.checks.map((c) => ({ checkType: c.type, weight: c.weight }))
+  });
+  return scoreChecklistRun({
+    checks: checklist.checks.map((c) => ({
+      id: c.key,
+      checkType: c.type,
+      weight: c.weight ?? 1,
+      onFailure: c.on_failure
+    })),
+    results: results.map((r) => ({ checkId: r.check, status: r.status })),
+    passThreshold: scoring.pass_threshold,
+    scoreBands: scoring.score_bands,
+    scoreType: scoring.score_type,
+    scoreUnit: scoring.score_unit
+  });
+}
+
+// src/mcp.ts
+var reply = ({ text: text2, image: image2, isError }) => ({
+  content: [
+    { type: "text", text: text2 },
+    ...image2 ? [{ type: "image", data: image2, mimeType: "image/png" }] : []
+  ],
+  ...isError ? { isError: true } : {}
+});
+var queue = Promise.resolve();
+function attempt(work) {
+  const run = queue.then(async () => {
+    try {
+      const out = await work();
+      return reply(typeof out === "string" ? { text: out } : out);
+    } catch (err) {
+      return reply({ text: err.message, isError: true });
+    }
+  });
+  queue = run;
+  return run;
+}
+function shapeOf(spec) {
+  const required = new Set(spec.parameters.required ?? []);
+  return Object.fromEntries(
+    Object.entries(spec.parameters.properties).map(([key, raw]) => {
+      const prop = raw;
+      let schema = prop.enum ? z.enum(prop.enum) : prop.type === "number" ? z.number() : z.string();
+      if (prop.description) schema = schema.describe(prop.description);
+      return [key, required.has(key) ? schema : schema.optional()];
+    })
+  );
+}
+function createServer(session) {
+  const server = new McpServer({ name: "stuntdouble", version: PACKAGE.split("@")[1] });
+  for (const spec of DIRECT_TOOL_SPECS.filter((s) => s.name !== "done")) {
+    server.registerTool(
+      spec.name,
+      { description: spec.description, inputSchema: shapeOf(spec) },
+      (input) => attempt(() => session.browserTool(spec.name, input))
+    );
+  }
+  server.registerTool(
+    "start_run",
+    {
+      description: "Start a local run of a checklist from .stuntdouble/checklists/<checklist>.json: opens a fresh Chrome at the checklist's URL, and returns the viewer link, the actor's brief and the checks to judge. If a file is invalid, returns each field to fix. With resume, continues the run still open in this session, or else the newest interrupted or stopped run of that checklist, judging only the checks without a verdict.",
+      inputSchema: {
+        checklist: z.string().describe('The checklist slug, e.g. "checkout".'),
+        resume: z.boolean().optional().describe("Continue the last unfinished run instead.")
+      }
+    },
+    (input) => attempt(() => session.startRun(input))
+  );
+  server.registerTool(
+    "evaluate_check",
+    {
+      description: 'Record the verdict on one check, as soon as you have observed it. A passed verdict needs a locator for evidence visible on the page now; a failure may describe something missing. Use "informational" only for informational checks, and "blocked" when you could not reach what the check is about. Saves a screenshot of the evidence and returns the next check.',
+      inputSchema: {
+        check: z.string().describe('The check key, e.g. "guest-checkout".'),
+        status: z.enum(["passed", "failed", "informational", "blocked"]),
+        evidence: z.string().min(1).describe("What you observed, in a sentence or two, quoting the page where you can."),
+        locator: z.object({
+          text: z.string().optional().describe("Distinctive text visible on the page."),
+          selector: z.string().optional().describe("A CSS selector for the element.")
+        }).optional().describe("Where the evidence is on the page. Required for passed.")
+      }
+    },
+    (input) => attempt(() => session.evaluateCheck(input))
+  );
+  server.registerTool(
+    "finish_run",
+    {
+      description: "End the run: settles the checks left, scores it the way the cloud does, writes run.json, closes the browser and returns the outcome. Always call it, even when blocked or stopped.",
+      inputSchema: {
+        summary: z.string().min(1).describe("One or two sentences on what you found.")
+      }
+    },
+    (input) => attempt(() => session.finishRun(input))
+  );
+  server.registerTool(
+    "open_ui",
+    {
+      description: "The local viewer for this project: every run with its verdicts, screenshots and activity, and the checklists and actors. Returns a link to open in a browser."
+    },
+    () => attempt(() => session.openUi())
+  );
+  return server;
+}
+async function serveMcp() {
+  const session = new LocalSession({ project: projectDir() });
+  const server = createServer(session);
+  let closing;
+  const shutdown = () => closing ??= session.close().finally(() => process.exit(0));
+  process.stdin.on("close", shutdown);
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await server.connect(new StdioServerTransport());
+}
+export {
+  createServer,
+  serveMcp
+};
+//# sourceMappingURL=mcp-HXJQN2C7.js.map