@phi-code-admin/phi-code 0.83.0 → 0.84.0

package/extensions/phi/chrome/browser-extension/snapshot_injected.js

@@ -0,0 +1,677 @@
+// Static MAIN-world snapshot implementation injected by the MV3 service worker.
+// Keep this file free of eval/new Function so `chrome_snapshot` works on strict-CSP pages.
+(() => {
+  function getPiChromeState() {
+    const state = window.__PI_CHROME_STATE__ || {
+      nextElementUid: 1,
+      elements: {},
+      console: [],
+      network: [],
+      nextRequestId: 1,
+      instrumentationInstalled: false,
+      lastSnapshotDigest: null,
+    };
+    window.__PI_CHROME_STATE__ = state;
+    return state;
+  }
+
+  function rememberElement(element) {
+    const state = getPiChromeState();
+    if (!element.__piChromeUid) element.__piChromeUid = "el-" + state.nextElementUid++;
+    state.elements[element.__piChromeUid] = element;
+    return element.__piChromeUid;
+  }
+
+  function isElementVisible(element) {
+    if (!element || !element.getBoundingClientRect) return false;
+    const style = getComputedStyle(element);
+    if (style.visibility === "hidden" || style.display === "none") return false;
+    const rect = element.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return false;
+    if (rect.bottom < 0 || rect.right < 0) return false;
+    if (rect.top > innerHeight || rect.left > innerWidth) return false;
+    return true;
+  }
+
+  function occluderAt(x, y, expected) {
+    const top = document.elementFromPoint(x, y);
+    if (!top || top === expected) return null;
+    if (expected && expected.contains(top)) return null;
+    if (top.contains(expected)) return null;
+    return {
+      tag: top.tagName.toLowerCase(),
+      id: top.id || undefined,
+      className: typeof top.className === "string" ? top.className : undefined,
+    };
+  }
+
+  function textOf(element, max) {
+    return (element?.innerText || element?.textContent || "").replace(/\s+/g, " ").trim().slice(0, max || 500);
+  }
+
+  function accessibleLabel(element) {
+    if (!element) return "";
+    const labelledBy = element.getAttribute("aria-labelledby");
+    if (labelledBy) {
+      const text = labelledBy.split(/\s+/).map((id) => document.getElementById(id)?.innerText || "").join(" ").trim();
+      if (text) return text;
+    }
+    const id = element.id;
+    if (id) {
+      try {
+        const label = document.querySelector(`label[for="${cssEscape(id)}"]`);
+        if (label?.innerText) return label.innerText;
+      } catch {}
+    }
+    const wrappingLabel = element.closest?.("label");
+    return (
+      element.getAttribute("aria-label") ||
+      element.getAttribute("title") ||
+      element.getAttribute("placeholder") ||
+      wrappingLabel?.innerText ||
+      element.innerText ||
+      element.textContent ||
+      ""
+    ).trim().replace(/\s+/g, " ").slice(0, 180);
+  }
+
+  function cssEscape(value) {
+    return (window.CSS && CSS.escape) ? CSS.escape(value) : String(value).replace(/[^a-zA-Z0-9_-]/g, "\\$&");
+  }
+
+  function roleOf(element) {
+    const explicit = element.getAttribute("role");
+    if (explicit) return explicit.toLowerCase();
+    const tag = element.tagName.toLowerCase();
+    const type = (element.getAttribute("type") || "").toLowerCase();
+    if (tag === "a" && element.href) return "link";
+    if (tag === "button" || type === "button" || type === "submit" || type === "reset") return "button";
+    if (tag === "textarea") return "textbox";
+    if (tag === "select") return "combobox";
+    if (tag === "input") {
+      if (["checkbox", "radio", "range", "search", "email", "password", "tel", "url", "number"].includes(type)) return type === "checkbox" || type === "radio" || type === "range" ? type : "textbox";
+      return "textbox";
+    }
+    if (element.isContentEditable) return "textbox";
+    if (tag.match(/^h[1-6]$/)) return "heading";
+    return tag;
+  }
+
+  function isSensitiveField(element) {
+    if (!element) return false;
+    const tag = element.tagName?.toLowerCase?.() || "";
+    if (!/^(input|textarea|select)$/.test(tag) && !element.isContentEditable) return false;
+    const type = (element.getAttribute("type") || "").toLowerCase();
+    if (["password"].includes(type)) return true;
+    const haystack = [
+      type,
+      element.getAttribute("name"),
+      element.id,
+      element.getAttribute("autocomplete"),
+      element.getAttribute("aria-label"),
+      element.getAttribute("placeholder"),
+      element.getAttribute("data-testid"),
+    ].filter(Boolean).join(" ").toLowerCase();
+    return /password|passwd|\bpwd\b|secret|token|bearer|api[-_ ]?key|access[-_ ]?key|auth[-_ ]?code|one[-_ ]?time|otp|2fa|mfa|verification[-_ ]?code|recovery[-_ ]?code|credit[-_ ]?card|card[-_ ]?number|cc-number|cc-csc|cvc|cvv|security[-_ ]?code|ssn|social[-_ ]?security/.test(haystack);
+  }
+
+  function installPiChromeInstrumentation() {
+    const state = getPiChromeState();
+    if (state.instrumentationInstalled) return;
+    state.instrumentationInstalled = true;
+    const pushConsole = (level, args) => {
+      state.console.push({
+        id: state.console.length + 1,
+        level,
+        timestamp: Date.now(),
+        url: location.href,
+        args: Array.from(args).map((arg) => {
+          try {
+            if (typeof arg === "string") return arg;
+            if (arg instanceof Error) return { name: arg.name, message: arg.message, stack: arg.stack };
+            return JSON.parse(JSON.stringify(arg));
+          } catch {
+            return String(arg);
+          }
+        }),
+      });
+      if (state.console.length > 500) state.console.splice(0, state.console.length - 500);
+    };
+    for (const level of ["debug", "log", "info", "warn", "error"]) {
+      const original = console[level];
+      if (typeof original !== "function" || original.__piChromeWrapped) continue;
+      const wrapped = function(...args) {
+        pushConsole(level, args);
+        return original.apply(this, args);
+      };
+      wrapped.__piChromeWrapped = true;
+      console[level] = wrapped;
+    }
+    window.addEventListener("error", (event) => pushConsole("pageerror", [event.message, event.filename + ":" + event.lineno + ":" + event.colno]));
+    window.addEventListener("unhandledrejection", (event) => pushConsole("unhandledrejection", [event.reason]));
+
+    const record = (entry) => {
+      state.network.push(entry);
+      if (state.network.length > 1000) state.network.splice(0, state.network.length - 1000);
+      return entry;
+    };
+    if (window.fetch && !window.fetch.__piChromeWrapped) {
+      const originalFetch = window.fetch.bind(window);
+      const wrappedFetch = async (...args) => {
+        const id = "req-" + state.nextRequestId++;
+        const startedAt = Date.now();
+        const input = args[0];
+        const init = args[1] || {};
+        const url = typeof input === "string" ? input : input?.url;
+        const method = (init.method || input?.method || "GET").toUpperCase();
+        const entry = record({ id, type: "fetch", method, url: String(url || ""), startedAt, pageUrl: location.href, status: "pending" });
+        try {
+          const response = await originalFetch(...args);
+          entry.status = response.status;
+          entry.statusText = response.statusText;
+          entry.ok = response.ok;
+          entry.responseUrl = response.url;
+          entry.durationMs = Date.now() - startedAt;
+          entry.responseHeaders = Array.from(response.headers.entries());
+          entry.responseBodyOmitted = "response body capture is disabled by default";
+          return response;
+        } catch (error) {
+          entry.error = error?.message || String(error);
+          entry.durationMs = Date.now() - startedAt;
+          throw error;
+        }
+      };
+      wrappedFetch.__piChromeWrapped = true;
+      window.fetch = wrappedFetch;
+    }
+    if (window.XMLHttpRequest && !XMLHttpRequest.prototype.open.__piChromeWrapped) {
+      const originalOpen = XMLHttpRequest.prototype.open;
+      const originalSend = XMLHttpRequest.prototype.send;
+      XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+        this.__piChromeRequest = { method: String(method || "GET").toUpperCase(), url: String(url || "") };
+        return originalOpen.call(this, method, url, ...rest);
+      };
+      XMLHttpRequest.prototype.open.__piChromeWrapped = true;
+      XMLHttpRequest.prototype.send = function(body) {
+        const id = "req-" + state.nextRequestId++;
+        const startedAt = Date.now();
+        const info = this.__piChromeRequest || {};
+        const entry = record({ id, type: "xhr", method: info.method || "GET", url: info.url || "", startedAt, pageUrl: location.href, status: "pending" });
+        this.addEventListener("loadend", () => {
+          entry.status = this.status;
+          entry.statusText = this.statusText;
+          entry.responseUrl = this.responseURL;
+          entry.durationMs = Date.now() - startedAt;
+          try { entry.responseHeadersText = this.getAllResponseHeaders(); } catch {}
+          entry.responseBodyOmitted = "response body capture is disabled by default";
+        });
+        this.addEventListener("error", () => { entry.error = "XMLHttpRequest error"; entry.durationMs = Date.now() - startedAt; });
+        return originalSend.call(this, body);
+      };
+    }
+  }
+
+  function hashString(text) {
+    let h = 0;
+    for (let i = 0; i < text.length; i++) h = (h * 31 + text.charCodeAt(i)) | 0;
+    return h;
+  }
+
+  function selectorFor(element) {
+    const unique = (selector) => {
+      try { return document.querySelectorAll(selector).length === 1; } catch { return false; }
+    };
+    if (element.id && unique("#" + cssEscape(element.id))) return "#" + cssEscape(element.id);
+    const attr = ["aria-label", "name", "placeholder", "data-testid", "role"].find((name) => element.getAttribute(name));
+    if (attr) {
+      const candidate = element.tagName.toLowerCase() + "[" + attr + "=" + JSON.stringify(element.getAttribute(attr)) + "]";
+      if (unique(candidate)) return candidate;
+    }
+    const parts = [];
+    let current = element;
+    while (current && current.nodeType === Node.ELEMENT_NODE && parts.length < 5) {
+      let part = current.tagName.toLowerCase();
+      if (current.classList.length > 0) part += "." + Array.from(current.classList).slice(0, 2).map(cssEscape).join(".");
+      const siblings = Array.from(current.parentElement?.children ?? []).filter((sibling) => sibling.tagName === current.tagName);
+      if (siblings.length > 1) part += ":nth-of-type(" + (siblings.indexOf(current) + 1) + ")";
+      parts.unshift(part);
+      const candidate = parts.join(" > ");
+      if (unique(candidate)) return candidate;
+      current = current.parentElement;
+    }
+    return parts.join(" > ");
+  }
+
+  function directHeadingText(element) {
+    const labelledBy = element.getAttribute?.("aria-labelledby");
+    if (labelledBy) {
+      const text = labelledBy.split(/\s+/).map((id) => document.getElementById(id)?.innerText || "").join(" ").replace(/\s+/g, " ").trim();
+      if (text) return text.slice(0, 180);
+    }
+    const aria = element.getAttribute?.("aria-label");
+    if (aria) return aria.trim().slice(0, 180);
+    const heading = Array.from(element.querySelectorAll?.("h1,h2,h3,h4,[role='heading']") || []).find(isElementVisible);
+    if (heading) return textOf(heading, 180);
+    return "";
+  }
+
+  function meaningfulContainerFor(element) {
+    let current = element.parentElement;
+    let fallback = current;
+    let depth = 0;
+    while (current && current !== document.body && depth++ < 8) {
+      if (!isElementVisible(current)) { current = current.parentElement; continue; }
+      const tag = current.tagName.toLowerCase();
+      const role = (current.getAttribute("role") || "").toLowerCase();
+      const cls = typeof current.className === "string" ? current.className : "";
+      const id = current.id || "";
+      const named = Boolean(current.getAttribute("aria-label") || current.getAttribute("aria-labelledby") || directHeadingText(current));
+      const semantic = /^(form|dialog|section|article|nav|header|main|aside|footer|li|tr|td|fieldset)$/.test(tag) ||
+        /^(dialog|alertdialog|region|group|listitem|row|cell|tabpanel|menu|toolbar|navigation|main|banner|contentinfo|complementary)$/.test(role);
+      const classHint = /card|panel|pane|modal|dialog|section|content|container|toolbar|menu|list|item|row|cell|header|footer|sidebar|drawer|popover|dropdown/i.test(`${id} ${cls}`);
+      const rect = current.getBoundingClientRect();
+      const childActions = current.querySelectorAll?.('a, button, input, textarea, select, [role="button"], [role="link"], [tabindex]:not([tabindex="-1"])').length || 0;
+      if ((semantic || classHint || named) && rect.width > 20 && rect.height > 20 && childActions <= 80) return current;
+      if (!fallback && rect.width > 20 && rect.height > 20) fallback = current;
+      current = current.parentElement;
+    }
+    return fallback || document.body;
+  }
+
+  function contextForElement(element) {
+    const container = meaningfulContainerFor(element);
+    if (!container || container === document.body || container === element) return undefined;
+    return {
+      uid: rememberElement(container),
+      tag: container.tagName.toLowerCase(),
+      role: roleOf(container),
+      label: directHeadingText(container) || accessibleLabel(container) || textOf(container, 140),
+      rect: rectSummary(container),
+    };
+  }
+
+  function summarizeElement(element, index) {
+    const rect = element.getBoundingClientRect();
+    const style = getComputedStyle(element);
+    const cx = rect.left + rect.width / 2;
+    const cy = rect.top + rect.height / 2;
+    const occluded = occluderAt(cx, cy, element);
+    const role = roleOf(element);
+    const disabled = Boolean(element.disabled || element.getAttribute("aria-disabled") === "true");
+    const rawValue = "value" in element && typeof element.value === "string" ? element.value : undefined;
+    const sensitive = isSensitiveField(element);
+    const value = rawValue && !sensitive ? rawValue.slice(0, 120) : undefined;
+    const checked = "checked" in element ? Boolean(element.checked) : undefined;
+    return {
+      index,
+      uid: rememberElement(element),
+      tag: element.tagName.toLowerCase(),
+      role,
+      selector: selectorFor(element),
+      label: accessibleLabel(element),
+      href: element.href || undefined,
+      type: element.getAttribute("type") || undefined,
+      value: value || undefined,
+      hasValue: rawValue ? rawValue.length > 0 : undefined,
+      valueLength: rawValue && sensitive ? rawValue.length : undefined,
+      valueRedacted: sensitive && rawValue ? true : undefined,
+      checked,
+      disabled,
+      inert: Boolean(element.closest?.("[inert]")),
+      pointerEvents: style.pointerEvents,
+      occluded: occluded || undefined,
+      context: contextForElement(element),
+      rect: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
+    };
+  }
+
+  function isInViewport(element) {
+    const rect = element.getBoundingClientRect();
+    return rect.bottom >= 0 && rect.right >= 0 && rect.top <= innerHeight && rect.left <= innerWidth;
+  }
+
+  function formSummaries() {
+    const fields = Array.from(document.querySelectorAll('input, textarea, select, [contenteditable="true"]'))
+      .filter(isElementVisible)
+      .slice(0, 80)
+      .map((element, index) => ({
+        ...summarizeElement(element, index),
+        required: Boolean(element.required || element.getAttribute("aria-required") === "true"),
+        invalid: Boolean(element.matches?.(":invalid") || element.getAttribute("aria-invalid") === "true"),
+        autocomplete: element.getAttribute("autocomplete") || undefined,
+      }));
+    const submits = Array.from(document.querySelectorAll('button, input[type="submit"], [role="button"]'))
+      .filter(isElementVisible)
+      .filter((element) => /submit|save|continue|next|send|sign in|log in|create|update|done/i.test(accessibleLabel(element) + " " + (element.getAttribute("type") || "")))
+      .slice(0, 30)
+      .map((element, index) => summarizeElement(element, index));
+    return { fields, submits };
+  }
+
+  function pageMap() {
+    const landmarkSelectors = [
+      ["header", 'header, [role="banner"]'],
+      ["nav", 'nav, [role="navigation"]'],
+      ["main", 'main, [role="main"]'],
+      ["aside", 'aside, [role="complementary"]'],
+      ["footer", 'footer, [role="contentinfo"]'],
+      ["dialog", 'dialog, [role="dialog"], [aria-modal="true"]'],
+      ["form", "form"],
+    ];
+    const regions = [];
+    for (const [kind, selector] of landmarkSelectors) {
+      for (const element of Array.from(document.querySelectorAll(selector)).filter(isElementVisible).slice(0, 12)) {
+        const headings = Array.from(element.querySelectorAll("h1,h2,h3,[role='heading']")).filter(isElementVisible).slice(0, 6).map((h) => textOf(h, 120));
+        const actions = Array.from(element.querySelectorAll('a, button, input, textarea, select, [role="button"], [role="link"], [tabindex]:not([tabindex="-1"])')).filter(isElementVisible).slice(0, 8).map((a) => {
+          const summary = summarizeElement(a, 0);
+          return { uid: summary.uid, role: summary.role, label: summary.label || summary.selector, disabled: summary.disabled || undefined };
+        });
+        regions.push({ kind, uid: rememberElement(element), label: accessibleLabel(element) || headings[0] || textOf(element, 100), headings, actions });
+      }
+    }
+    const headings = Array.from(document.querySelectorAll("h1,h2,h3,[role='heading']")).filter(isElementVisible).slice(0, 30).map((element) => ({
+      uid: rememberElement(element),
+      level: Number(element.tagName?.slice(1)) || Number(element.getAttribute("aria-level")) || undefined,
+      text: textOf(element, 180),
+    }));
+    return { regions, headings };
+  }
+
+  function layoutSections(elements, forms) {
+    const byUid = new Map();
+    const addToSection = (summary, kind) => {
+      const source = getPiChromeState().elements[summary.uid];
+      const container = source ? meaningfulContainerFor(source) : null;
+      if (!container || container === document.body) return;
+      const uid = rememberElement(container);
+      let section = byUid.get(uid);
+      if (!section) {
+        const rect = rectSummary(container);
+        section = {
+          uid,
+          tag: container.tagName.toLowerCase(),
+          role: roleOf(container),
+          label: directHeadingText(container) || accessibleLabel(container) || textOf(container, 160),
+          text: textOf(container, 260),
+          rect,
+          actions: [],
+          fields: [],
+        };
+        byUid.set(uid, section);
+      }
+      const item = { uid: summary.uid, role: summary.role, label: summary.label || summary.selector, disabled: summary.disabled || undefined };
+      if (kind === "field") section.fields.push(item);
+      else section.actions.push(item);
+    };
+    for (const el of (elements || []).slice(0, 80)) addToSection(el, ["textbox", "checkbox", "radio", "combobox"].includes(el.role) ? "field" : "action");
+    for (const field of (forms?.fields || []).slice(0, 80)) addToSection(field, "field");
+    const sections = Array.from(byUid.values())
+      .filter((section) => section.actions.length || section.fields.length)
+      .sort((a, b) => a.rect.y - b.rect.y || a.rect.x - b.rect.x)
+      .slice(0, 18);
+    for (const section of sections) {
+      section.actions = section.actions.slice(0, 10);
+      section.fields = section.fields.slice(0, 10);
+    }
+    return sections;
+  }
+
+  function tokenScore(haystack, query) {
+    if (!query) return 0;
+    const hay = String(haystack || "").toLowerCase();
+    const tokens = String(query).toLowerCase().split(/\W+/).filter(Boolean);
+    if (!tokens.length) return 0;
+    let score = 0;
+    for (const token of tokens) {
+      if (hay.includes(token)) score += token.length <= 2 ? 1 : 3;
+    }
+    if (hay.includes(String(query).toLowerCase())) score += 8;
+    return score;
+  }
+
+  function queryMatches(query, elements, map) {
+    if (!query) return [];
+    const candidates = [];
+    for (const element of elements) {
+      const hay = [element.role, element.label, element.selector, element.type, element.href].filter(Boolean).join(" ");
+      const score = tokenScore(hay, query);
+      if (score > 0) candidates.push({ score, kind: "element", ...element });
+    }
+    const textNodes = [];
+    for (const block of Array.from(document.querySelectorAll("h1,h2,h3,h4,p,li,td,th,label,summary,[role='alert']")).filter(isElementVisible).slice(0, 300)) {
+      const text = textOf(block, 300);
+      const score = tokenScore(text, query);
+      if (score > 0) textNodes.push({ score, kind: "text", uid: rememberElement(block), tag: block.tagName.toLowerCase(), role: roleOf(block), text, rect: rectSummary(block) });
+    }
+    for (const region of map.regions || []) {
+      const score = tokenScore([region.kind, region.label, ...(region.headings || [])].join(" "), query);
+      if (score > 0) candidates.push({ score, kind: "region", ...region });
+    }
+    return candidates.concat(textNodes).sort((a, b) => b.score - a.score).slice(0, 20);
+  }
+
+  function rectSummary(element) {
+    const rect = element.getBoundingClientRect();
+    return { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) };
+  }
+
+  function activeElementSummary() {
+    const el = document.activeElement;
+    if (!el || el === document.body || el === document.documentElement) return null;
+    return summarizeElement(el, 0);
+  }
+
+  function modalSummary() {
+    const selectors = 'dialog[open], [role="dialog"], [aria-modal="true"], [role="alertdialog"]';
+    const modal = Array.from(document.querySelectorAll(selectors)).find(isElementVisible);
+    if (!modal) return null;
+    return { uid: rememberElement(modal), tag: modal.tagName.toLowerCase(), role: roleOf(modal), label: accessibleLabel(modal) || textOf(modal, 180), rect: rectSummary(modal) };
+  }
+
+  function digestFor(snapshot) {
+    return {
+      url: snapshot.url,
+      title: snapshot.title,
+      textHash: hashString(snapshot.text || ""),
+      focusedUid: snapshot.focused?.uid || null,
+      modalUid: snapshot.modal?.uid || null,
+      labels: (snapshot.elements || []).slice(0, 50).map((el) => ({ uid: el.uid, role: el.role, label: el.label, disabled: el.disabled, value: el.value, checked: el.checked })),
+    };
+  }
+
+  function diffSnapshot(previous, current) {
+    if (!previous) return { firstSnapshot: true };
+    const changes = [];
+    if (previous.url !== current.url) changes.push({ kind: "url", before: previous.url, after: current.url });
+    if (previous.title !== current.title) changes.push({ kind: "title", before: previous.title, after: current.title });
+    if (previous.textHash !== current.textHash) changes.push({ kind: "textChanged" });
+    if (previous.focusedUid !== current.focusedUid) changes.push({ kind: "focus", before: previous.focusedUid, after: current.focusedUid });
+    if (previous.modalUid !== current.modalUid) changes.push({ kind: "modal", before: previous.modalUid, after: current.modalUid });
+    const prevByUid = new Map((previous.labels || []).map((x) => [x.uid, x]));
+    const curByUid = new Map((current.labels || []).map((x) => [x.uid, x]));
+    const added = [];
+    const removed = [];
+    const updated = [];
+    for (const cur of current.labels || []) {
+      const prev = prevByUid.get(cur.uid);
+      if (!prev) added.push(cur);
+      else if (prev.label !== cur.label || prev.disabled !== cur.disabled || prev.value !== cur.value || prev.checked !== cur.checked) updated.push({ uid: cur.uid, before: prev, after: cur });
+    }
+    for (const prev of previous.labels || []) {
+      if (!curByUid.has(prev.uid)) removed.push(prev);
+    }
+    return { changes, added: added.slice(0, 12), removed: removed.slice(0, 12), updated: updated.slice(0, 12) };
+  }
+
+  function visibleTextSnippets(maxChars) {
+    const snippets = [];
+    const blocks = Array.from(document.querySelectorAll("h1,h2,h3,h4,p,li,td,th,label,summary,[role='alert']")).filter(isElementVisible);
+    let used = 0;
+    for (const block of blocks) {
+      if (!isInViewport(block) && snippets.length > 12) continue;
+      const text = textOf(block, 500);
+      if (!text || snippets.some((s) => s.text === text)) continue;
+      const next = { uid: rememberElement(block), tag: block.tagName.toLowerCase(), text, rect: rectSummary(block) };
+      snippets.push(next);
+      used += text.length;
+      if (used >= maxChars || snippets.length >= 40) break;
+    }
+    return snippets;
+  }
+
+  function snapshotPage(maxElements, containingText, roleFilter, nearUid, mode, query, maxTextChars) {
+    installPiChromeInstrumentation();
+    mode = ["auto", "interactive", "forms", "pageMap", "text", "changes", "full"].includes(mode) ? mode : "auto";
+    const fullTextLimit = Number(maxTextChars || (mode === "full" ? 30000 : mode === "text" ? 18000 : 6000));
+    let candidates = Array.from(document.querySelectorAll('a, button, input, textarea, select, summary, [role="button"], [role="link"], [role="menuitem"], [role="tab"], [role="checkbox"], [contenteditable="true"], [tabindex]:not([tabindex="-1"])'));
+    if (containingText) {
+      const needle = String(containingText).toLowerCase();
+      candidates = candidates.filter((element) => accessibleLabel(element).toLowerCase().includes(needle));
+    }
+    if (roleFilter) {
+      const wanted = String(roleFilter).toLowerCase();
+      candidates = candidates.filter((element) => roleOf(element) === wanted || element.tagName.toLowerCase() === wanted);
+    }
+    let near;
+    if (nearUid) near = getPiChromeState().elements[nearUid];
+    if (near) {
+      const nearRect = near.getBoundingClientRect();
+      const cx = nearRect.left + nearRect.width / 2;
+      const cy = nearRect.top + nearRect.height / 2;
+      candidates.sort((a, b) => {
+        const ra = a.getBoundingClientRect();
+        const rb = b.getBoundingClientRect();
+        const da = Math.hypot(ra.left + ra.width / 2 - cx, ra.top + ra.height / 2 - cy);
+        const db = Math.hypot(rb.left + rb.width / 2 - cx, rb.top + rb.height / 2 - cy);
+        return da - db;
+      });
+    } else {
+      candidates.sort((a, b) => {
+        const ar = a.getBoundingClientRect();
+        const br = b.getBoundingClientRect();
+        const avis = isInViewport(a) ? 0 : 1;
+        const bvis = isInViewport(b) ? 0 : 1;
+        return avis - bvis || ar.top - br.top || ar.left - br.left;
+      });
+    }
+    const visibleCandidates = candidates.filter(isElementVisible);
+    const elements = visibleCandidates.slice(0, maxElements).map((element, index) => summarizeElement(element, index));
+    const queryElements = query
+      ? visibleCandidates.slice(0, Math.max(maxElements, 500)).map((element, index) => summarizeElement(element, index))
+      : elements;
+    const map = pageMap();
+    const forms = formSummaries();
+    const layout = layoutSections(elements, forms);
+    const focused = activeElementSummary();
+    const modal = modalSummary();
+    const bodyText = document.body ? document.body.innerText.replace(/\s+\n/g, "\n").trim() : "";
+    const text = bodyText.slice(0, fullTextLimit);
+    const snapshot = {
+      title: document.title,
+      url: location.href,
+      mode,
+      query: query || undefined,
+      viewport: { width: innerWidth, height: innerHeight, scrollX, scrollY },
+      summary: {
+        visibleText: textOf(document.body, 500),
+        visibleInteractiveCount: elements.filter((el) => el.rect.y >= 0 && el.rect.y <= innerHeight).length,
+        totalInteractiveSampled: elements.length,
+        totalInteractiveVisible: visibleCandidates.length,
+        focused: focused ? { uid: focused.uid, role: focused.role, label: focused.label } : undefined,
+        modal: modal ? { uid: modal.uid, label: modal.label } : undefined,
+        hints: [],
+      },
+      focused: focused || undefined,
+      modal: modal || undefined,
+      text,
+      textTruncated: bodyText.length > text.length,
+      textSnippets: visibleTextSnippets(mode === "text" ? 12000 : 3000),
+      elements,
+      forms,
+      layout,
+      pageMap: map,
+      matches: queryMatches(query, queryElements, map),
+      filter: { containingText: containingText || undefined, roleFilter: roleFilter || undefined, nearUid: nearUid || undefined },
+    };
+    if (snapshot.modal) snapshot.summary.hints.push("A modal/dialog is visible; interact with it before the underlying page.");
+    const disabledImportant = elements.find((el) => el.disabled && /submit|save|merge|continue|next|send|approve|login|sign in/i.test(el.label || ""));
+    if (disabledImportant) snapshot.summary.hints.push(`${disabledImportant.uid} '${disabledImportant.label}' is disabled.`);
+    const occluded = elements.find((el) => el.occluded);
+    if (occluded) snapshot.summary.hints.push(`${occluded.uid} '${occluded.label || occluded.role}' appears occluded by ${occluded.occluded.tag}.`);
+
+    const state = getPiChromeState();
+    const currentDigest = digestFor(snapshot);
+    snapshot.diff = diffSnapshot(state.lastSnapshotDigest, currentDigest);
+    state.lastSnapshotDigest = currentDigest;
+
+    if (mode === "interactive") {
+      delete snapshot.text;
+      delete snapshot.textSnippets;
+      delete snapshot.pageMap;
+    } else if (mode === "forms") {
+      delete snapshot.text;
+      delete snapshot.textSnippets;
+      snapshot.elements = elements.filter((el) => ["textbox", "checkbox", "radio", "combobox", "button"].includes(el.role));
+    } else if (mode === "pageMap") {
+      delete snapshot.text;
+      delete snapshot.textSnippets;
+      snapshot.elements = elements.slice(0, 20);
+    } else if (mode === "changes") {
+      delete snapshot.text;
+      delete snapshot.textSnippets;
+      delete snapshot.elements;
+      delete snapshot.forms;
+      delete snapshot.layout;
+      delete snapshot.pageMap;
+    } else if (mode === "text") {
+      snapshot.elements = elements.slice(0, 20);
+    } else if (mode !== "full") {
+      snapshot.elements = elements.slice(0, Math.min(maxElements, 40));
+      snapshot.text = text.slice(0, Math.min(text.length, 6000));
+    }
+    return snapshot;
+  }
+
+  function inspectTarget(uid, selector, shouldScrollIntoView) {
+    installPiChromeInstrumentation();
+    const state = getPiChromeState();
+    let element = null;
+    if (uid) element = state.elements[uid];
+    if (!element && selector) element = document.querySelector(selector);
+    if (!element || !element.isConnected) throw new Error(uid ? `No live element for uid: ${uid}. Take a fresh chrome_snapshot.` : `No element matches selector: ${selector}`);
+    if (shouldScrollIntoView) element.scrollIntoView?.({ block: "center", inline: "center", behavior: "instant" });
+    const summary = summarizeElement(element, 0);
+    const ancestors = [];
+    let current = element.parentElement;
+    while (current && current !== document.body && ancestors.length < 6) {
+      ancestors.push({ uid: rememberElement(current), tag: current.tagName.toLowerCase(), role: roleOf(current), label: accessibleLabel(current) || textOf(current, 100), selector: selectorFor(current) });
+      current = current.parentElement;
+    }
+    const container = element.closest?.('form, dialog, [role="dialog"], [aria-modal="true"], section, article, main, aside') || element.parentElement || document.body;
+    const nearbyText = Array.from(container.querySelectorAll("h1,h2,h3,h4,p,li,label,[role='alert']"))
+      .filter(isElementVisible)
+      .slice(0, 24)
+      .map((node) => ({ uid: rememberElement(node), tag: node.tagName.toLowerCase(), text: textOf(node, 240), rect: rectSummary(node) }))
+      .filter((entry) => entry.text);
+    const nearbyActions = Array.from(container.querySelectorAll('a, button, input, textarea, select, [role="button"], [role="link"], [tabindex]:not([tabindex="-1"])'))
+      .filter(isElementVisible)
+      .slice(0, 30)
+      .map((node, index) => summarizeElement(node, index));
+    const form = element.closest?.("form");
+    const formContext = form ? {
+      uid: rememberElement(form),
+      label: accessibleLabel(form) || textOf(form, 160),
+      fields: Array.from(form.querySelectorAll('input, textarea, select, [contenteditable="true"]')).filter(isElementVisible).slice(0, 30).map((node, index) => summarizeElement(node, index)),
+      actions: Array.from(form.querySelectorAll('button, input[type="submit"], [role="button"]')).filter(isElementVisible).slice(0, 12).map((node, index) => summarizeElement(node, index)),
+    } : undefined;
+    const rect = element.getBoundingClientRect();
+    const center = { x: Math.round(rect.left + rect.width / 2), y: Math.round(rect.top + rect.height / 2) };
+    const clickSuggestion = summary.disabled || summary.inert || summary.pointerEvents === "none"
+      ? undefined
+      : { uid: summary.uid, x: center.x, y: center.y };
+    return { target: summary, ancestors, nearbyText, nearbyActions, formContext, clickSuggestion };
+  }
+
+  globalThis.__piChromeSnapshotPage = snapshotPage;
+  globalThis.__piChromeInspectTarget = inspectTarget;
+})();