@flrande/bak-extension 0.5.0 → 0.6.1

package/dist/content.global.js

@@ -33,11 +33,24 @@
   // src/privacy.ts
   var MAX_SAFE_TEXT_LENGTH = 120;
   var MAX_DEBUG_TEXT_LENGTH = 320;
+  var REDACTION_MARKER = "[REDACTED]";
   var EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
   var LONG_DIGIT_PATTERN = /(?:\d[ -]?){13,19}/g;
   var OTP_PATTERN = /^\d{4,8}$/;
   var SECRET_QUERY_PARAM_PATTERN = /(token|secret|password|passwd|otp|code|session|auth)=/i;
   var HIGH_ENTROPY_TOKEN_PATTERN = /^(?=.*\d)(?=.*[a-zA-Z])[A-Za-z0-9~!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?`]{16,}$/;
+  var TRANSPORT_SECRET_KEY_SOURCE = "(?:api[_-]?key|authorization|auth|cookie|csrf(?:token)?|nonce|password|passwd|secret|session(?:id)?|token|xsrf(?:token)?)";
+  var TRANSPORT_SECRET_PAIR_PATTERN = new RegExp(`((?:^|[?&;,\\s])${TRANSPORT_SECRET_KEY_SOURCE}=)[^&\\r\\n"'>]*`, "gi");
+  var JSON_SECRET_VALUE_PATTERN = new RegExp(
+    `((?:"|')${TRANSPORT_SECRET_KEY_SOURCE}(?:"|')\\s*:\\s*)(?:"[^"]*"|'[^']*'|true|false|null|-?\\d+(?:\\.\\d+)?)`,
+    "gi"
+  );
+  var ASSIGNMENT_SECRET_VALUE_PATTERN = new RegExp(
+    `((?:^|[\\s,{;])${TRANSPORT_SECRET_KEY_SOURCE}\\s*[:=]\\s*)([^,&;}"'\\r\\n]+)`,
+    "gi"
+  );
+  var AUTHORIZATION_VALUE_PATTERN = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+\b/gi;
+  var SENSITIVE_ATTRIBUTE_PATTERN = /(?:api[_-]?key|authorization|auth|cookie|csrf|nonce|password|passwd|secret|session|token|xsrf)/i;
   var INPUT_TEXT_ENTRY_TYPES = /* @__PURE__ */ new Set([
     "text",
     "search",
@@ -73,11 +86,31 @@
     if (OTP_PATTERN.test(output)) {
       return "[REDACTED:otp]";
     }
-    if (HIGH_ENTROPY_TOKEN_PATTERN.test(output) && !output.includes(" ")) {
+    if (HIGH_ENTROPY_TOKEN_PATTERN.test(output) && !/[ =&:]/.test(output) && !output.includes("[REDACTED")) {
       return "[REDACTED:secret]";
     }
     return output;
   }
+  function redactTransportSecrets(text) {
+    let output = text;
+    output = output.replace(AUTHORIZATION_VALUE_PATTERN, "$1 [REDACTED]");
+    output = output.replace(TRANSPORT_SECRET_PAIR_PATTERN, "$1[REDACTED]");
+    output = output.replace(JSON_SECRET_VALUE_PATTERN, '$1"[REDACTED]"');
+    output = output.replace(ASSIGNMENT_SECRET_VALUE_PATTERN, "$1[REDACTED]");
+    if (HIGH_ENTROPY_TOKEN_PATTERN.test(output) && !/[ =&:]/.test(output) && !output.includes("[REDACTED")) {
+      return "[REDACTED:secret]";
+    }
+    return output;
+  }
+  function redactAttributeValue(name, value) {
+    if (!value) {
+      return value;
+    }
+    if (name === "value") {
+      return REDACTION_MARKER;
+    }
+    return redactTransportText(value);
+  }
   function redactElementText(raw, options = {}) {
     if (!raw) {
       return "";
@@ -89,6 +122,44 @@
     const redacted = redactByPattern(normalized);
     return clamp(redacted, options);
   }
+  function redactTransportText(raw) {
+    if (!raw) {
+      return "";
+    }
+    return redactTransportSecrets(String(raw));
+  }
+  function redactHtmlSnapshot(root) {
+    if (!root || !("cloneNode" in root)) {
+      return "";
+    }
+    const clone = root.cloneNode(true);
+    const elements = [clone, ...Array.from(clone.querySelectorAll("*"))];
+    for (const element of elements) {
+      const tagName = element.tagName.toLowerCase();
+      if (tagName === "script" && !element.getAttribute("src")) {
+        element.textContent = "[REDACTED:script]";
+      }
+      if (tagName === "textarea" && (element.textContent ?? "").trim().length > 0) {
+        element.textContent = REDACTION_MARKER;
+      }
+      for (const attribute of Array.from(element.attributes)) {
+        const name = attribute.name;
+        const value = attribute.value;
+        const shouldRedactValue = name === "value" && (tagName === "input" || tagName === "textarea" || tagName === "option") || SENSITIVE_ATTRIBUTE_PATTERN.test(name);
+        if (shouldRedactValue) {
+          element.setAttribute(name, redactAttributeValue(name, value));
+          continue;
+        }
+        if (name === "href" || name === "src" || name === "action" || name === "content" || name.startsWith("data-")) {
+          const redacted = redactAttributeValue(name, value);
+          if (redacted !== value) {
+            element.setAttribute(name, redacted);
+          }
+        }
+      }
+    }
+    return "outerHTML" in clone ? clone.outerHTML : "";
+  }
   function isTextEntryField(candidates) {
     const tag = candidates.tag.toLowerCase();
     const role = (candidates.role ?? "").toLowerCase();
@@ -163,6 +234,9 @@
   var longTaskCount = 0;
   var longTaskDurationMs = 0;
   var performanceBaselineMs = 0;
+  var pageLoadedAt = Math.round(performance.timeOrigin || Date.now());
+  var lastMutationAt = Date.now();
+  var DISCOVERY_GLOBAL_PATTERN = /(data|table|json|state|store|market|quote|flow|row|timestamp|snapshot|book|signal)/i;
   function isHtmlElement(node) {
     if (!node) {
       return false;
@@ -710,6 +784,28 @@
     }
     return collected;
   }
+  function evaluateXPath(root, expression) {
+    try {
+      const ownerDocument = isDocumentNode(root) ? root : root.ownerDocument ?? document;
+      const iterator = ownerDocument.evaluate(
+        expression,
+        root,
+        null,
+        XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
+        null
+      );
+      const matches = [];
+      for (let index = 0; index < iterator.snapshotLength; index += 1) {
+        const node = iterator.snapshotItem(index);
+        if (isHtmlElement(node)) {
+          matches.push(node);
+        }
+      }
+      return matches;
+    } catch {
+      return [];
+    }
+  }
   function resolveFrameDocument(framePath) {
     let currentDocument = document;
     for (const selector of framePath) {
@@ -782,6 +878,7 @@
       const eid = buildEid(element);
       const selectors = {
         css: toCssSelector(element),
+        xpath: null,
         text: text || name ? (text || name).slice(0, 80) : null,
         aria: role && name ? `${role}:${name.slice(0, 80)}` : null
       };
@@ -793,6 +890,8 @@
         role,
         name,
         text,
+        visible: isElementVisible(element),
+        enabled: !(element.disabled || element.getAttribute("aria-disabled") === "true"),
         bbox: {
           x: rect.x,
           y: rect.y,
@@ -903,6 +1002,13 @@
         currentRoot = found.shadowRoot;
       }
     }
+    if (locator.xpath) {
+      const matches = evaluateXPath(root, locator.xpath).filter((item) => isElementVisible(item));
+      const found = indexedCandidate(matches, locator);
+      if (found) {
+        return found;
+      }
+    }
     if (locator.name) {
       const fallback = indexedCandidate(
         interactive.filter((element) => inferName(element).toLowerCase().includes(locator.name.toLowerCase())),
@@ -914,6 +1020,61 @@
     }
     return null;
   }
+  function matchedElementsForLocator(locator) {
+    if (!locator) {
+      return [];
+    }
+    const rootResult = resolveRootForLocator(locator);
+    if (!rootResult.ok) {
+      return [];
+    }
+    const root = rootResult.root;
+    const interactive = getInteractiveElements(root, locator.shadow !== "none");
+    if (locator.css) {
+      const parts = splitShadowSelector(locator.css);
+      let currentRoot = root;
+      for (let index = 0; index < parts.length; index += 1) {
+        const selector = parts[index];
+        const found = locator.shadow === "none" ? querySelectorInTree(currentRoot, selector) : querySelectorAcrossOpenShadow(currentRoot, selector);
+        if (!found) {
+          return [];
+        }
+        if (index === parts.length - 1) {
+          return (locator.shadow === "none" ? Array.from(currentRoot.querySelectorAll(selector)) : querySelectorAllAcrossOpenShadow(currentRoot, selector)).filter((item) => isElementVisible(item));
+        }
+        if (!found.shadowRoot) {
+          return [];
+        }
+        currentRoot = found.shadowRoot;
+      }
+    }
+    if (locator.xpath) {
+      return evaluateXPath(root, locator.xpath).filter((item) => isElementVisible(item));
+    }
+    if (locator.role || locator.name || locator.text) {
+      return interactive.filter((element) => {
+        if (locator.role && inferRole(element).toLowerCase() !== locator.role.toLowerCase()) {
+          return false;
+        }
+        if (locator.name && !inferName(element).toLowerCase().includes(locator.name.toLowerCase())) {
+          return false;
+        }
+        if (locator.text) {
+          const text = (element.innerText || element.textContent || "").toLowerCase();
+          if (!text.includes(locator.text.toLowerCase())) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+    if (locator.eid) {
+      collectElements({}, locator);
+      const fromCache = elementCache.get(locator.eid);
+      return fromCache ? [fromCache] : [];
+    }
+    return [];
+  }
   function ensureOverlayRoot() {
     let root = document.getElementById("bak-overlay-root");
     if (!root) {
@@ -1387,6 +1548,30 @@
       return true;
     }).slice(-limit).reverse();
   }
+  function filterNetworkEntrySections(entry, include) {
+    if (!Array.isArray(include)) {
+      return entry;
+    }
+    const sections = new Set(
+      include.map(String).filter((section) => section === "request" || section === "response")
+    );
+    if (sections.size === 0 || sections.size === 2) {
+      return entry;
+    }
+    const clone = { ...entry };
+    if (!sections.has("request")) {
+      delete clone.requestHeaders;
+      delete clone.requestBodyPreview;
+      delete clone.requestBodyTruncated;
+    }
+    if (!sections.has("response")) {
+      delete clone.responseHeaders;
+      delete clone.responseBodyPreview;
+      delete clone.responseBodyTruncated;
+      delete clone.binary;
+    }
+    return clone;
+  }
   async function waitForNetwork(params) {
     const timeoutMs = typeof params.timeoutMs === "number" ? Math.max(1, params.timeoutMs) : 5e3;
     const sinceTs = typeof params.sinceTs === "number" ? params.sinceTs : Date.now() - timeoutMs;
@@ -1400,6 +1585,619 @@
     }
     throw { code: "E_TIMEOUT", message: "network.waitFor timeout" };
   }
+  function trackMutations() {
+    const observer = new MutationObserver(() => {
+      lastMutationAt = Date.now();
+    });
+    const root = document.documentElement ?? document.body;
+    if (!root) {
+      return;
+    }
+    observer.observe(root, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      characterData: true
+    });
+  }
+  function currentContextSnapshot() {
+    return {
+      tabId: null,
+      framePath: [...contextState.framePath],
+      shadowPath: [...contextState.shadowPath]
+    };
+  }
+  function timestampCandidateMatchesFromText(text, patterns) {
+    const regexes = (patterns ?? [
+      String.raw`\b20\d{2}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b`,
+      String.raw`\b20\d{2}-\d{2}-\d{2}\b`,
+      String.raw`\b20\d{2}\/\d{2}\/\d{2}\b`
+    ]).map((pattern) => new RegExp(pattern, "gi"));
+    const collected = /* @__PURE__ */ new Map();
+    for (const regex of regexes) {
+      for (const match of text.matchAll(regex)) {
+        const value = match[0];
+        if (!value) {
+          continue;
+        }
+        const index = match.index ?? text.indexOf(value);
+        const start = Math.max(0, index - 28);
+        const end = Math.min(text.length, index + value.length + 28);
+        const context = text.slice(start, end).replace(/\s+/g, " ").trim();
+        const key = `${value}::${context}`;
+        if (!collected.has(key)) {
+          collected.set(key, { value, context });
+        }
+      }
+    }
+    return [...collected.values()];
+  }
+  function listInlineScripts() {
+    return Array.from(document.scripts).filter((script) => !script.src).map((script) => {
+      const content = script.textContent ?? "";
+      const suspectedVars = [...content.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g)].map((match) => match[1] ?? "").filter((candidate) => DISCOVERY_GLOBAL_PATTERN.test(candidate));
+      return { content, suspectedVars };
+    });
+  }
+  function cookieMetadata() {
+    return document.cookie.split(";").map((item) => item.trim()).filter(Boolean).map((item) => ({ name: item.split("=")[0] ?? "" })).filter((item) => item.name.length > 0);
+  }
+  function storageMetadata() {
+    return {
+      localStorageKeys: Object.keys(localStorage),
+      sessionStorageKeys: Object.keys(sessionStorage)
+    };
+  }
+  function collectFrames(baseDocument = document, framePath = []) {
+    const frames = [];
+    const frameNodes = Array.from(baseDocument.querySelectorAll("iframe,frame"));
+    for (const frame of frameNodes) {
+      if (!isFrameElement(frame)) {
+        continue;
+      }
+      const selector = frame.id ? `#${frame.id}` : `${frame.tagName.toLowerCase()}:nth-of-type(${frameNodes.indexOf(frame) + 1})`;
+      try {
+        const childDocument = frame.contentDocument;
+        if (!childDocument) {
+          continue;
+        }
+        const nextPath = [...framePath, selector];
+        frames.push({
+          framePath: nextPath,
+          url: childDocument.location.href
+        });
+        frames.push(...collectFrames(childDocument, nextPath));
+      } catch {
+        continue;
+      }
+    }
+    return frames;
+  }
+  function buildTableId(kind, index) {
+    return `${kind}:${index + 1}`;
+  }
+  function describeTables() {
+    const rootResult = resolveRootForLocator();
+    if (!rootResult.ok) {
+      return [];
+    }
+    const root = rootResult.root;
+    const tables = [];
+    const htmlTables = Array.from(root.querySelectorAll("table"));
+    for (const [index, table] of htmlTables.entries()) {
+      tables.push({
+        id: buildTableId(table.closest(".dataTables_wrapper") ? "dataTables" : "html", index),
+        name: (table.getAttribute("aria-label") || table.getAttribute("data-testid") || table.id || `table-${index + 1}`).trim(),
+        kind: table.closest(".dataTables_wrapper") ? "dataTables" : "html",
+        selector: table.id ? `#${table.id}` : void 0,
+        rowCount: table.querySelectorAll("tbody tr").length || table.querySelectorAll("tr").length,
+        columnCount: table.querySelectorAll("thead th").length || table.querySelectorAll("tr:first-child th, tr:first-child td").length
+      });
+    }
+    const gridRoots = Array.from(root.querySelectorAll('[role="grid"], [role="table"], .ag-root, .ag-root-wrapper'));
+    for (const [index, grid] of gridRoots.entries()) {
+      const kind = grid.className.includes("ag-") ? "ag-grid" : "aria-grid";
+      tables.push({
+        id: buildTableId(kind, index),
+        name: (grid.getAttribute("aria-label") || grid.getAttribute("data-testid") || grid.id || `grid-${index + 1}`).trim(),
+        kind,
+        selector: grid.id ? `#${grid.id}` : void 0,
+        rowCount: grid.querySelectorAll('[role="row"]').length,
+        columnCount: grid.querySelectorAll('[role="columnheader"]').length
+      });
+    }
+    return tables;
+  }
+  function resolveTable(handleId) {
+    const tables = describeTables();
+    const handle = tables.find((candidate) => candidate.id === handleId);
+    if (!handle) {
+      return null;
+    }
+    const rootResult = resolveRootForLocator();
+    if (!rootResult.ok) {
+      return null;
+    }
+    const root = rootResult.root;
+    if (!handle.selector) {
+      if (handle.kind === "html" || handle.kind === "dataTables") {
+        const index2 = Number(handle.id.split(":")[1] ?? "1") - 1;
+        return { table: handle, element: root.querySelectorAll("table")[index2] ?? null };
+      }
+      const candidates = root.querySelectorAll('[role="grid"], [role="table"], .ag-root, .ag-root-wrapper');
+      const index = Number(handle.id.split(":")[1] ?? "1") - 1;
+      return { table: handle, element: candidates[index] ?? null };
+    }
+    return { table: handle, element: root.querySelector(handle.selector) };
+  }
+  function htmlTableSchema(table) {
+    const headers = Array.from(table.querySelectorAll("thead th"));
+    if (headers.length > 0) {
+      return headers.map((cell, index) => ({
+        key: `col_${index + 1}`,
+        label: (cell.textContent ?? "").trim() || `Column ${index + 1}`
+      }));
+    }
+    const firstRow = table.querySelector("tr");
+    return Array.from(firstRow?.querySelectorAll("th,td") ?? []).map((cell, index) => ({
+      key: `col_${index + 1}`,
+      label: (cell.textContent ?? "").trim() || `Column ${index + 1}`
+    }));
+  }
+  function htmlTableRows(table, limit) {
+    const columns = htmlTableSchema(table);
+    const rowNodes = Array.from(table.querySelectorAll("tbody tr")).length > 0 ? Array.from(table.querySelectorAll("tbody tr")) : Array.from(table.querySelectorAll("tr")).slice(1);
+    return rowNodes.slice(0, limit).map((row) => {
+      const record = {};
+      Array.from(row.querySelectorAll("th,td")).forEach((cell, index) => {
+        const key = columns[index]?.label ?? `Column ${index + 1}`;
+        record[key] = (cell.textContent ?? "").trim();
+      });
+      return record;
+    });
+  }
+  function gridSchema(grid) {
+    return Array.from(grid.querySelectorAll('[role="columnheader"]')).map((cell, index) => ({
+      key: `col_${index + 1}`,
+      label: (cell.textContent ?? "").trim() || `Column ${index + 1}`
+    }));
+  }
+  function gridRows(grid, limit) {
+    const columns = gridSchema(grid);
+    return Array.from(grid.querySelectorAll('[role="row"]')).slice(0, limit).map((row) => {
+      const record = {};
+      Array.from(row.querySelectorAll('[role="gridcell"], [role="cell"], [role="columnheader"]')).forEach((cell, index) => {
+        const key = columns[index]?.label ?? `Column ${index + 1}`;
+        record[key] = (cell.textContent ?? "").trim();
+      });
+      return record;
+    }).filter((row) => Object.values(row).some((value) => String(value).trim().length > 0));
+  }
+  function runPageWorldRequest(action, payload) {
+    const requestId = `bak_page_world_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+    return new Promise((resolve, reject) => {
+      const timeoutMs = typeof payload.timeoutMs === "number" && Number.isFinite(payload.timeoutMs) && payload.timeoutMs > 0 ? Math.max(1e3, Math.floor(payload.timeoutMs) + 1e3) : 15e3;
+      const responseNode = document.createElement("div");
+      responseNode.setAttribute("data-bak-page-world-response", requestId);
+      responseNode.hidden = true;
+      (document.documentElement ?? document.head ?? document.body).appendChild(responseNode);
+      const cleanup = () => {
+        clearTimeout(timer);
+        observer.disconnect();
+        responseNode.remove();
+      };
+      const tryResolveFromNode = () => {
+        if (responseNode.getAttribute("data-ready") !== "1") {
+          return;
+        }
+        const payloadText = responseNode.getAttribute("data-payload");
+        const detail = payloadText ? JSON.parse(payloadText) : null;
+        if (!detail) {
+          cleanup();
+          reject(failAction("E_EXECUTION", `${action} returned no detail`));
+          return;
+        }
+        cleanup();
+        if (detail.ok) {
+          resolve(detail.result);
+          return;
+        }
+        reject(detail.error ?? failAction("E_EXECUTION", `${action} failed`));
+      };
+      const observer = new MutationObserver(() => {
+        try {
+          tryResolveFromNode();
+        } catch (error) {
+          cleanup();
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      });
+      observer.observe(responseNode, {
+        attributes: true,
+        childList: true,
+        characterData: true,
+        subtree: true
+      });
+      const timer = window.setTimeout(() => {
+        cleanup();
+        reject(failAction("E_TIMEOUT", `${action} timed out`));
+      }, timeoutMs);
+      const injector = document.createElement("script");
+      injector.textContent = `
+(() => {
+  const requestId = ${JSON.stringify(requestId)};
+  const action = ${JSON.stringify(action)};
+  const payload = ${JSON.stringify(payload)};
+  const responseNode = document.querySelector('div[data-bak-page-world-response="' + requestId + '"]');
+  const emit = (detail) => {
+    if (!responseNode) {
+      return;
+    }
+    responseNode.setAttribute('data-payload', JSON.stringify(detail));
+    responseNode.setAttribute('data-ready', '1');
+  };
+  const serializeValue = (value, maxBytes) => {
+    let cloned;
+    try {
+      cloned = typeof structuredClone === 'function' ? structuredClone(value) : JSON.parse(JSON.stringify(value));
+    } catch (error) {
+      throw { code: 'E_NOT_SERIALIZABLE', message: error instanceof Error ? error.message : String(error) };
+    }
+    const json = JSON.stringify(cloned);
+    if (typeof maxBytes === 'number' && maxBytes > 0 && json.length > maxBytes) {
+      throw { code: 'E_BODY_TOO_LARGE', message: 'serialized value exceeds max-bytes', details: { bytes: json.length, maxBytes } };
+    }
+    return { value: cloned, bytes: json.length };
+  };
+  const resolveFrameWindow = (framePath) => {
+    let currentWindow = window;
+    let currentDocument = document;
+    for (const selector of framePath || []) {
+      const frame = currentDocument.querySelector(selector);
+      if (!frame || !('contentWindow' in frame)) {
+        throw { code: 'E_NOT_FOUND', message: 'frame not found: ' + selector };
+      }
+      const nextWindow = frame.contentWindow;
+      if (!nextWindow) {
+        throw { code: 'E_NOT_READY', message: 'frame window unavailable: ' + selector };
+      }
+      try {
+        currentDocument = nextWindow.document;
+      } catch {
+        throw { code: 'E_CROSS_ORIGIN_BLOCKED', message: 'cross-origin frame is not accessible: ' + selector };
+      }
+      currentWindow = nextWindow;
+    }
+    return currentWindow;
+  };
+  const collectFrames = (rootWindow, framePath) => {
+    const collected = [{
+      url: rootWindow.location.href,
+      framePath,
+      targetWindow: rootWindow
+    }];
+    const frames = Array.from(rootWindow.document.querySelectorAll('iframe,frame'));
+    frames.forEach((frame, index) => {
+      const selector = frame.id ? '#' + frame.id : frame.tagName.toLowerCase() + ':nth-of-type(' + (index + 1) + ')';
+      try {
+        if (!frame.contentWindow || !frame.contentWindow.document) {
+          return;
+        }
+        collected.push(...collectFrames(frame.contentWindow, [...framePath, selector]));
+      } catch {
+        // Skip cross-origin frames.
+      }
+    });
+    return collected;
+  };
+  const parsePath = (path) => {
+    if (typeof path !== 'string' || !path.trim()) {
+      throw { code: 'E_INVALID_PARAMS', message: 'path is required' };
+    }
+    const normalized = path.replace(/^globalThis\\.?/, '').replace(/^window\\.?/, '').trim();
+    if (!normalized) {
+      return [];
+    }
+    const segments = [];
+    let index = 0;
+    while (index < normalized.length) {
+      if (normalized[index] === '.') {
+        index += 1;
+        continue;
+      }
+      if (normalized[index] === '[') {
+        const bracket = normalized.slice(index).match(/^\\[(\\d+)\\]/);
+        if (!bracket) {
+          throw { code: 'E_INVALID_PARAMS', message: 'Only numeric bracket paths are supported' };
+        }
+        segments.push(Number(bracket[1]));
+        index += bracket[0].length;
+        continue;
+      }
+      const identifier = normalized.slice(index).match(/^[A-Za-z_$][\\w$]*/);
+      if (!identifier) {
+        throw { code: 'E_INVALID_PARAMS', message: 'Unsupported path token near: ' + normalized.slice(index, index + 16) };
+      }
+      segments.push(identifier[0]);
+      index += identifier[0].length;
+    }
+    return segments;
+  };
+  const buildPathExpression = (path) => {
+    const segments = parsePath(path);
+    return segments
+      .map((segment, index) => {
+        if (typeof segment === 'number') {
+          return '[' + segment + ']';
+        }
+        if (index === 0) {
+          return segment;
+        }
+        return '.' + segment;
+      })
+      .join('');
+  };
+  const readPath = (targetWindow, path) => {
+    const segments = parsePath(path);
+    let current = targetWindow;
+    for (const segment of segments) {
+      if (current == null || !(segment in current)) {
+        throw { code: 'E_NOT_FOUND', message: 'path not found: ' + path };
+      }
+      current = current[segment];
+    }
+    return current;
+  };
+  const resolveExtractValue = (targetWindow, path, resolver) => {
+    const strategy = resolver === 'globalThis' || resolver === 'lexical' ? resolver : 'auto';
+    const lexicalExpression = buildPathExpression(path);
+    const readLexical = () => {
+      try {
+        return targetWindow.eval(lexicalExpression);
+      } catch (error) {
+        if (error instanceof ReferenceError) {
+          throw { code: 'E_NOT_FOUND', message: 'path not found: ' + path };
+        }
+        throw error;
+      }
+    };
+    if (strategy === 'globalThis') {
+      return { resolver: 'globalThis', value: readPath(targetWindow, path) };
+    }
+    if (strategy === 'lexical') {
+      return { resolver: 'lexical', value: readLexical() };
+    }
+    try {
+      return { resolver: 'globalThis', value: readPath(targetWindow, path) };
+    } catch (error) {
+      if (!error || typeof error !== 'object' || error.code !== 'E_NOT_FOUND') {
+        throw error;
+      }
+    }
+    return { resolver: 'lexical', value: readLexical() };
+  };
+  const buildScopeTargets = () => {
+    if (payload.scope === 'main') {
+      return [{
+        url: window.location.href,
+        framePath: [],
+        targetWindow: window
+      }];
+    }
+    if (payload.scope === 'all-frames') {
+      return collectFrames(window, []);
+    }
+    return [{
+      url: resolveFrameWindow(payload.framePath || []).location.href,
+      framePath: payload.framePath || [],
+      targetWindow: resolveFrameWindow(payload.framePath || [])
+    }];
+  };
+  const toResult = async (target) => {
+    if (action === 'globals') {
+      const keys = Object.keys(target.targetWindow).filter((key) => ${DISCOVERY_GLOBAL_PATTERN}.test(key)).slice(0, 50);
+      return { url: target.url, framePath: target.framePath, value: keys };
+    }
+    if (action === 'eval') {
+      const serialized = serializeValue(target.targetWindow.eval(payload.expr), payload.maxBytes);
+      return { url: target.url, framePath: target.framePath, value: serialized.value, bytes: serialized.bytes };
+    }
+    if (action === 'extract') {
+      const extracted = resolveExtractValue(target.targetWindow, payload.path, payload.resolver);
+      const serialized = serializeValue(extracted.value, payload.maxBytes);
+      return { url: target.url, framePath: target.framePath, value: serialized.value, bytes: serialized.bytes, resolver: extracted.resolver };
+    }
+    if (action === 'fetch') {
+      const headers = { ...(payload.headers || {}) };
+      if (payload.contentType && !headers['Content-Type']) {
+        headers['Content-Type'] = payload.contentType;
+      }
+      const controller = typeof AbortController === 'function' ? new AbortController() : null;
+      const timeoutId =
+        controller && typeof payload.timeoutMs === 'number' && payload.timeoutMs > 0
+          ? window.setTimeout(() => controller.abort(new Error('fetch timeout')), payload.timeoutMs)
+          : null;
+      let response;
+      try {
+        response = await target.targetWindow.fetch(payload.url, {
+          method: payload.method || 'GET',
+          headers,
+          body: typeof payload.body === 'string' ? payload.body : undefined,
+          signal: controller ? controller.signal : undefined
+        });
+      } finally {
+        if (timeoutId !== null) {
+          window.clearTimeout(timeoutId);
+        }
+      }
+      const headerMap = {};
+      response.headers.forEach((value, key) => {
+        headerMap[key] = value;
+      });
+      const bodyText = await response.text();
+      const encoder = typeof TextEncoder === 'function' ? new TextEncoder() : null;
+      const decoder = typeof TextDecoder === 'function' ? new TextDecoder() : null;
+      const previewLimit = typeof payload.maxBytes === 'number' && payload.maxBytes > 0 ? payload.maxBytes : 8192;
+      const encodedBody = encoder ? encoder.encode(bodyText) : null;
+      const bodyBytes = encodedBody ? encodedBody.byteLength : bodyText.length;
+      const truncated = bodyBytes > previewLimit;
+      const finalBodyText =
+        encodedBody && decoder
+          ? decoder.decode(encodedBody.subarray(0, Math.min(encodedBody.byteLength, previewLimit)))
+          : truncated
+            ? bodyText.slice(0, previewLimit)
+            : bodyText;
+      if (payload.mode === 'json' && truncated) {
+        throw {
+          code: 'E_BODY_TOO_LARGE',
+          message: 'JSON response exceeds max-bytes',
+          details: {
+            bytes: bodyBytes,
+            maxBytes: previewLimit
+          }
+        };
+      }
+      const result = {
+        url: response.url,
+        status: response.status,
+        ok: response.ok,
+        headers: headerMap,
+        contentType: response.headers.get('content-type') || undefined,
+        bodyText: payload.mode === 'json' ? undefined : finalBodyText,
+        json: payload.mode === 'json' && bodyText ? JSON.parse(bodyText) : undefined,
+        bytes: bodyBytes,
+        truncated
+      };
+      return { url: target.url, framePath: target.framePath, value: result };
+    }
+    throw { code: 'E_NOT_FOUND', message: 'Unsupported page-world action: ' + action };
+  };
+  Promise.resolve()
+    .then(async () => {
+      const targets = buildScopeTargets();
+      const results = [];
+      for (const target of targets) {
+        try {
+          results.push(await toResult(target));
+        } catch (error) {
+          results.push({
+            url: target.url,
+            framePath: target.framePath,
+            error: typeof error === 'object' && error !== null && 'code' in error
+              ? error
+              : { code: 'E_EXECUTION', message: error instanceof Error ? error.message : String(error) }
+          });
+        }
+      }
+      if (payload.scope === 'all-frames') {
+        emit({ ok: true, result: { scope: payload.scope, results } });
+        return;
+      }
+      emit({ ok: true, result: { scope: payload.scope || 'current', result: results[0] } });
+    })
+    .catch((error) => {
+      emit({
+        ok: false,
+        error: typeof error === 'object' && error !== null && 'code' in error
+          ? error
+          : { code: 'E_EXECUTION', message: error instanceof Error ? error.message : String(error) }
+      });
+    });
+})();
+`;
+      (document.documentElement ?? document.head ?? document.body).appendChild(injector);
+      injector.remove();
+    });
+  }
+  function resolveScope(params) {
+    const scope = typeof params.scope === "string" ? params.scope : "current";
+    return scope === "main" || scope === "all-frames" ? scope : "current";
+  }
+  function pageWorldFramePath() {
+    return [...contextState.framePath];
+  }
+  function pageEval(expr, params) {
+    return runPageWorldRequest("eval", {
+      expr,
+      scope: resolveScope(params),
+      maxBytes: typeof params.maxBytes === "number" ? params.maxBytes : void 0,
+      framePath: pageWorldFramePath()
+    });
+  }
+  function pageExtract(path, params) {
+    return runPageWorldRequest("extract", {
+      path,
+      resolver: typeof params.resolver === "string" ? params.resolver : void 0,
+      scope: resolveScope(params),
+      maxBytes: typeof params.maxBytes === "number" ? params.maxBytes : void 0,
+      framePath: pageWorldFramePath()
+    });
+  }
+  function pageFetch(params) {
+    return runPageWorldRequest("fetch", {
+      url: String(params.url ?? ""),
+      method: typeof params.method === "string" ? params.method : "GET",
+      headers: typeof params.headers === "object" && params.headers !== null ? params.headers : void 0,
+      body: typeof params.body === "string" ? params.body : void 0,
+      contentType: typeof params.contentType === "string" ? params.contentType : void 0,
+      mode: params.mode === "json" ? "json" : "raw",
+      maxBytes: typeof params.maxBytes === "number" ? params.maxBytes : void 0,
+      timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : void 0,
+      scope: resolveScope(params),
+      framePath: pageWorldFramePath()
+    });
+  }
+  async function globalsPreview() {
+    return Object.keys(window).filter((key) => DISCOVERY_GLOBAL_PATTERN.test(key)).slice(0, 50);
+  }
+  async function collectInspectionState(params = {}) {
+    const rootResult = resolveRootForLocator();
+    if (!rootResult.ok) {
+      throw rootResult.error;
+    }
+    const root = rootResult.root;
+    const metadata = documentMetadata(root, document);
+    const visibleText = pageTextChunks(root, 40, 320);
+    const combinedText = visibleText.map((chunk) => chunk.text).join("\n");
+    const scripts = listInlineScripts();
+    const visibleTimestampCandidates = timestampCandidateMatchesFromText(
+      combinedText,
+      Array.isArray(params.patterns) ? params.patterns.map(String) : void 0
+    );
+    const inlineTimestampCandidates = timestampCandidateMatchesFromText(
+      scripts.map((script) => script.content).join("\n"),
+      Array.isArray(params.patterns) ? params.patterns.map(String) : void 0
+    );
+    const previewGlobals = await globalsPreview();
+    const suspiciousGlobals = [...new Set(scripts.flatMap((script) => script.suspectedVars))].slice(0, 50);
+    return {
+      url: metadata.url,
+      title: metadata.title,
+      html: redactHtmlSnapshot(document.documentElement),
+      visibleText,
+      visibleTimestamps: visibleTimestampCandidates.map((candidate) => candidate.value),
+      visibleTimestampCandidates,
+      inlineTimestamps: inlineTimestampCandidates.map((candidate) => candidate.value),
+      inlineTimestampCandidates,
+      suspiciousGlobals,
+      globalsPreview: previewGlobals,
+      scripts: {
+        inlineCount: scripts.length,
+        suspectedDataVars: suspiciousGlobals
+      },
+      storage: storageMetadata(),
+      cookies: cookieMetadata(),
+      frames: collectFrames(),
+      tables: describeTables(),
+      timers: {
+        timeouts: 0,
+        intervals: 0
+      },
+      pageLoadedAt,
+      lastMutationAt,
+      context: currentContextSnapshot()
+    };
+  }
   function performDoubleClick(target, point) {
     performClick(target, point);
     performClick(target, point);
@@ -1667,6 +2465,12 @@
           )
         };
       }
+      case "page.eval":
+        return await pageEval(String(params.expr ?? ""), params);
+      case "page.extract":
+        return await pageExtract(String(params.path ?? ""), params);
+      case "page.fetch":
+        return await pageFetch(params);
       case "page.dom": {
         const rootResult = resolveRootForLocator();
         if (!rootResult.ok) {
@@ -1818,6 +2622,7 @@
         if (!target) {
           throw notFoundForLocator(params.locator, "element.get target not found");
         }
+        const matches = matchedElementsForLocator(params.locator);
         const elements = collectElements({}, params.locator);
         const eid = buildEid(target);
         const element = elements.find((item) => item.eid === eid);
@@ -1830,6 +2635,10 @@
         }
         return {
           element,
+          matchedCount: matches.length,
+          visible: isElementVisible(target),
+          enabled: !(target.disabled || target.getAttribute("aria-disabled") === "true"),
+          textPreview: (target.innerText || target.textContent || "").replace(/\s+/g, " ").trim().slice(0, 160),
           value: isEditable(target) ? target.value : target.isContentEditable ? target.textContent ?? "" : void 0,
           checked: isInputElement(target) ? target.checked : void 0,
           attributes
@@ -2063,7 +2872,7 @@
         if (!found) {
           throw { code: "E_NOT_FOUND", message: `network entry not found: ${id}` };
         }
-        return { entry: found };
+        return { entry: filterNetworkEntrySections(found, params.include) };
       }
       case "network.waitFor":
         return { entry: await waitForNetwork(params) };
@@ -2071,6 +2880,34 @@
         networkEntries.length = 0;
         performanceBaselineMs = performance.now();
         return { ok: true };
+      case "table.list":
+        return { tables: describeTables() };
+      case "table.schema": {
+        const resolved = resolveTable(String(params.table ?? ""));
+        if (!resolved || !(resolved.element instanceof Element)) {
+          throw { code: "E_NOT_FOUND", message: `table not found: ${String(params.table ?? "")}` };
+        }
+        const schema = resolved.element instanceof HTMLTableElement ? { columns: htmlTableSchema(resolved.element) } : { columns: gridSchema(resolved.element) };
+        return {
+          table: resolved.table,
+          schema
+        };
+      }
+      case "table.rows":
+      case "table.export": {
+        const resolved = resolveTable(String(params.table ?? ""));
+        if (!resolved || !(resolved.element instanceof Element)) {
+          throw { code: "E_NOT_FOUND", message: `table not found: ${String(params.table ?? "")}` };
+        }
+        const requestedLimit = params.all === true ? typeof params.maxRows === "number" ? Math.max(1, Math.floor(params.maxRows)) : 1e4 : typeof params.limit === "number" ? Math.max(1, Math.floor(params.limit)) : 100;
+        const extractionMode = resolved.table.kind === "html" || resolved.table.kind === "dataTables" ? "dataSource" : "visibleOnly";
+        const rows = resolved.element instanceof HTMLTableElement ? htmlTableRows(resolved.element, requestedLimit) : gridRows(resolved.element, requestedLimit);
+        return {
+          table: resolved.table,
+          extractionMode,
+          rows
+        };
+      }
       case "debug.dumpState": {
         const consoleLimit = typeof params.consoleLimit === "number" ? Math.max(1, Math.floor(params.consoleLimit)) : 80;
         const networkLimit = typeof params.networkLimit === "number" ? Math.max(1, Math.floor(params.networkLimit)) : 80;
@@ -2080,6 +2917,7 @@
           throw rootResult.error;
         }
         const metadata = documentMetadata(rootResult.root, document);
+        const inspection = await collectInspectionState(params);
         return {
           url: metadata.url,
           title: metadata.title,
@@ -2098,9 +2936,19 @@
           },
           console: consoleEntries.slice(-consoleLimit),
           network: filterNetworkEntries({ limit: networkLimit }),
-          accessibility: includeAccessibility ? pageAccessibility(rootResult.root, 200) : void 0
+          accessibility: includeAccessibility ? pageAccessibility(rootResult.root, 200) : void 0,
+          scripts: inspection.scripts,
+          globalsPreview: inspection.globalsPreview,
+          storage: inspection.storage,
+          frames: inspection.frames,
+          networkSummary: {
+            total: filterNetworkEntries({ limit: networkLimit }).length,
+            recent: filterNetworkEntries({ limit: Math.min(networkLimit, 10) })
+          }
         };
       }
+      case "bak.internal.inspectState":
+        return await collectInspectionState(params);
       default:
         throw { code: "E_NOT_FOUND", message: `Unsupported content RPC method: ${method}` };
     }
@@ -2153,4 +3001,5 @@
     return false;
   });
   ensureOverlayRoot();
+  trackMutations();
 })();