@flrande/bak-extension 0.6.11 → 0.6.12

package/dist/content.global.js

@@ -30,6 +30,215 @@
     };
   }
 
+  // src/dynamic-data-tools.ts
+  var DATA_PATTERN = /\b(updated|update|updatedat|asof|timestamp|generated|generatedat|refresh|freshness|latest|last|quote|trade|price|flow|market|time|snapshot|signal)\b/i;
+  var CONTRACT_PATTERN = /\b(expiry|expiration|expires|option|contract|strike|maturity|dte|call|put|exercise)\b/i;
+  var EVENT_PATTERN = /\b(earnings|event|report|dividend|split|meeting|fomc|release|filing)\b/i;
+  var ROW_CANDIDATE_KEYS = ["data", "rows", "results", "items", "records", "entries"];
+  function sampleValue(value, depth = 0) {
+    if (depth >= 2 || value === null || value === void 0 || typeof value !== "object") {
+      if (typeof value === "string") {
+        return value.length > 160 ? value.slice(0, 160) : value;
+      }
+      if (typeof value === "function") {
+        return "[Function]";
+      }
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.slice(0, 3).map((item) => sampleValue(item, depth + 1));
+    }
+    const sampled = {};
+    for (const key of Object.keys(value).slice(0, 8)) {
+      try {
+        sampled[key] = sampleValue(value[key], depth + 1);
+      } catch {
+        sampled[key] = "[Unreadable]";
+      }
+    }
+    return sampled;
+  }
+  function estimateSampleSize(value) {
+    if (Array.isArray(value)) {
+      return value.length;
+    }
+    if (value && typeof value === "object") {
+      return Object.keys(value).length;
+    }
+    return null;
+  }
+  function classifyTimestamp(path, value, now = Date.now()) {
+    const normalized = path.toLowerCase();
+    if (DATA_PATTERN.test(normalized)) {
+      return "data";
+    }
+    if (CONTRACT_PATTERN.test(normalized)) {
+      return "contract";
+    }
+    if (EVENT_PATTERN.test(normalized)) {
+      return "event";
+    }
+    const parsed = Date.parse(value.trim());
+    return Number.isFinite(parsed) && parsed > now + 36 * 60 * 60 * 1e3 ? "contract" : "unknown";
+  }
+  function collectTimestampProbes(value, path, options = {}) {
+    const collected = [];
+    const now = typeof options.now === "number" ? options.now : Date.now();
+    const limit = typeof options.limit === "number" ? Math.max(1, Math.floor(options.limit)) : 16;
+    const visit = (candidate, candidatePath, depth) => {
+      if (collected.length >= limit) {
+        return;
+      }
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        const parsed = Date.parse(candidate.trim());
+        if (Number.isFinite(parsed)) {
+          collected.push({
+            path: candidatePath,
+            value: candidate,
+            category: classifyTimestamp(candidatePath, candidate, now)
+          });
+        }
+        return;
+      }
+      if (depth >= 3 || candidate === null || candidate === void 0) {
+        return;
+      }
+      if (Array.isArray(candidate)) {
+        candidate.slice(0, 3).forEach((entry, index) => visit(entry, `${candidatePath}[${index}]`, depth + 1));
+        return;
+      }
+      if (typeof candidate === "object") {
+        Object.keys(candidate).slice(0, 8).forEach((key) => {
+          try {
+            visit(candidate[key], candidatePath ? `${candidatePath}.${key}` : key, depth + 1);
+          } catch {
+          }
+        });
+      }
+    };
+    visit(value, path, 0);
+    return collected;
+  }
+  function inferSchemaHint(value) {
+    const rowsCandidate = extractStructuredRows(value);
+    if (rowsCandidate) {
+      if (rowsCandidate.rowType === "object") {
+        const firstRecord = rowsCandidate.rows.find(
+          (row) => typeof row === "object" && row !== null && !Array.isArray(row)
+        );
+        return {
+          kind: "rows-object",
+          columns: firstRecord ? Object.keys(firstRecord).slice(0, 12) : []
+        };
+      }
+      if (rowsCandidate.rowType === "array") {
+        const firstRow = rowsCandidate.rows.find((row) => Array.isArray(row));
+        return {
+          kind: "rows-array",
+          columns: firstRow ? firstRow.map((_, index) => `Column ${index + 1}`) : []
+        };
+      }
+    }
+    if (Array.isArray(value)) {
+      return { kind: "array" };
+    }
+    if (value && typeof value === "object") {
+      return {
+        kind: "object",
+        columns: Object.keys(value).slice(0, 12)
+      };
+    }
+    if (value === null || value === void 0) {
+      return null;
+    }
+    return { kind: "scalar" };
+  }
+  function extractStructuredRows(value, path = "$") {
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return { rows: value, path, rowType: "object" };
+      }
+      const first = value.find((item) => item !== null && item !== void 0);
+      if (Array.isArray(first)) {
+        return { rows: value, path, rowType: "array" };
+      }
+      if (first && typeof first === "object") {
+        return { rows: value, path, rowType: "object" };
+      }
+      return { rows: value, path, rowType: "scalar" };
+    }
+    if (!value || typeof value !== "object") {
+      return null;
+    }
+    const record = value;
+    for (const key of ROW_CANDIDATE_KEYS) {
+      if (Array.isArray(record[key])) {
+        return extractStructuredRows(record[key], `${path}.${key}`);
+      }
+    }
+    return null;
+  }
+  function buildTableIntelligence(input) {
+    const signals = [];
+    const visibleRowCount = Math.max(0, Math.floor(input.visibleRowCount));
+    const estimatedTotalRows = typeof input.estimatedTotalRows === "number" && Number.isFinite(input.estimatedTotalRows) && input.estimatedTotalRows > 0 ? Math.max(visibleRowCount, Math.floor(input.estimatedTotalRows)) : void 0;
+    const maxObservedRowIndex = typeof input.maxObservedRowIndex === "number" && Number.isFinite(input.maxObservedRowIndex) ? Math.max(0, Math.floor(input.maxObservedRowIndex)) : void 0;
+    const minObservedRowIndex = typeof input.minObservedRowIndex === "number" && Number.isFinite(input.minObservedRowIndex) ? Math.max(0, Math.floor(input.minObservedRowIndex)) : void 0;
+    if (input.knownGridKind) {
+      signals.push({
+        code: "known-grid-kind",
+        detail: `Detected ${input.kind} container semantics`
+      });
+    }
+    if (input.hasScrollContainer) {
+      signals.push({
+        code: "scroll-container",
+        detail: "Scrollable container detected for the table region"
+      });
+    }
+    if (input.hasTranslatedRows) {
+      signals.push({
+        code: "row-transform-offsets",
+        detail: "Row transform offsets indicate viewport-based row reuse"
+      });
+    }
+    if (maxObservedRowIndex !== void 0 && maxObservedRowIndex > visibleRowCount) {
+      signals.push({
+        code: "row-index-gap",
+        detail: `Observed row indexes reach ${maxObservedRowIndex} while only ${visibleRowCount} rows are mounted`
+      });
+    }
+    if (estimatedTotalRows !== void 0 && estimatedTotalRows > visibleRowCount) {
+      signals.push({
+        code: "dom-rows-less-than-expected",
+        detail: `Estimated ${estimatedTotalRows} rows with ${visibleRowCount} currently mounted`
+      });
+    }
+    const virtualized = input.hasTranslatedRows || input.hasScrollContainer && (estimatedTotalRows !== void 0 && estimatedTotalRows > visibleRowCount || maxObservedRowIndex !== void 0 && maxObservedRowIndex > visibleRowCount + 1);
+    const lazyLoaded = input.hasScrollContainer && !virtualized && estimatedTotalRows !== void 0 && estimatedTotalRows > visibleRowCount;
+    const preferredExtractionMode = input.kind === "html" || input.kind === "dataTables" ? "dataSource" : input.hasScrollContainer ? "scroll" : "visibleOnly";
+    const completeness = preferredExtractionMode === "dataSource" ? "complete" : estimatedTotalRows !== void 0 && estimatedTotalRows > visibleRowCount ? "partial" : minObservedRowIndex !== void 0 && minObservedRowIndex > 1 ? "partial" : "unknown";
+    return {
+      virtualized,
+      lazyLoaded,
+      preferredExtractionMode,
+      estimatedTotalRows,
+      completeness,
+      signals
+    };
+  }
+  function buildExtractionMetadata(mode, rows, intelligence, warnings = [], options = {}) {
+    const estimatedTotalRows = intelligence?.estimatedTotalRows;
+    const complete = options.limitApplied ? false : mode === "dataSource" ? true : options.reachedEnd === true ? true : intelligence?.completeness === "complete";
+    return {
+      mode,
+      complete: complete === true,
+      observedRows: rows.length,
+      estimatedTotalRows,
+      warnings
+    };
+  }
+
   // src/privacy.ts
   var MAX_SAFE_TEXT_LENGTH = 120;
   var MAX_DEBUG_TEXT_LENGTH = 320;
@@ -1676,6 +1885,111 @@
   function buildTableId(kind, index) {
     return `${kind}:${index + 1}`;
   }
+  function gridRowNodes(grid) {
+    return Array.from(grid.querySelectorAll('[role="row"]')).filter(
+      (row) => row.querySelector('[role="gridcell"], [role="cell"]') !== null
+    );
+  }
+  function tableSchemaFromElement(element) {
+    return element instanceof HTMLTableElement ? htmlTableSchema(element) : gridSchema(element);
+  }
+  function tableRowsFromElement(element, limit) {
+    return element instanceof HTMLTableElement ? htmlTableRows(element, limit) : gridRows(element, limit);
+  }
+  function findScrollableTableContainer(element) {
+    const explicitCandidate = isHtmlElement(element) && (element.matches("[data-bak-scroll-root], [data-virtual-scroll]") ? element : null) || ("querySelector" in element ? element.querySelector("[data-bak-scroll-root], [data-virtual-scroll]") ?? null : null);
+    if (explicitCandidate) {
+      return explicitCandidate;
+    }
+    const candidates = [];
+    if (isHtmlElement(element)) {
+      candidates.push(element);
+    }
+    if ("querySelectorAll" in element) {
+      candidates.push(...Array.from(element.querySelectorAll('[role="rowgroup"], *')));
+    }
+    let current = element.parentElement;
+    while (current && candidates.length < 80) {
+      candidates.push(current);
+      current = current.parentElement;
+    }
+    const uniqueCandidates = [...new Set(candidates)];
+    return uniqueCandidates.find((candidate) => {
+      const style = getComputedStyle(candidate);
+      return (style.overflowY === "auto" || style.overflowY === "scroll") && candidate.scrollHeight > candidate.clientHeight + 4 && candidate.clientHeight > 0;
+    }) ?? null;
+  }
+  function observedRowIndexes(rows) {
+    return rows.map((row) => {
+      const raw = row.getAttribute("aria-rowindex") || row.getAttribute("data-row-index") || row.dataset.rowIndex;
+      const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+    }).filter((value) => value !== null);
+  }
+  function inferEstimatedTotalRows(element, rows, scrollContainer) {
+    const attrCandidates = [
+      element.getAttribute("aria-rowcount"),
+      (scrollContainer ?? void 0)?.getAttribute("aria-rowcount"),
+      element.getAttribute("data-total-rows"),
+      (scrollContainer ?? void 0)?.getAttribute("data-total-rows")
+    ].filter((candidate) => typeof candidate === "string" && candidate.trim().length > 0).map((candidate) => Number.parseInt(candidate, 10)).filter((candidate) => Number.isFinite(candidate) && candidate > 0);
+    if (attrCandidates.length > 0) {
+      return Math.max(...attrCandidates);
+    }
+    const indexes = observedRowIndexes(rows);
+    if (indexes.length > 0) {
+      return Math.max(...indexes);
+    }
+    const rowHeight = rows[0]?.getBoundingClientRect().height ?? 0;
+    if (scrollContainer && rowHeight > 0) {
+      const estimate = Math.round(scrollContainer.scrollHeight / rowHeight);
+      if (estimate > rows.length) {
+        return estimate;
+      }
+    }
+    return void 0;
+  }
+  function tableIntelligenceForElement(table, element) {
+    if (element instanceof HTMLTableElement) {
+      return buildTableIntelligence({
+        kind: table.kind,
+        visibleRowCount: htmlTableRows(element, Number.MAX_SAFE_INTEGER).length,
+        rowCount: table.rowCount,
+        estimatedTotalRows: table.rowCount,
+        hasScrollContainer: false,
+        hasTranslatedRows: false,
+        knownGridKind: false
+      });
+    }
+    const rows = gridRowNodes(element);
+    const scrollContainer = findScrollableTableContainer(element);
+    const rowIndexes = observedRowIndexes(rows);
+    const estimatedTotalRows = inferEstimatedTotalRows(element, rows, scrollContainer);
+    const hasTranslatedRows = rows.some((row) => {
+      const style = row.style.transform || getComputedStyle(row).transform;
+      return typeof style === "string" && style !== "" && style !== "none";
+    });
+    return buildTableIntelligence({
+      kind: table.kind,
+      visibleRowCount: rows.length,
+      rowCount: table.rowCount,
+      estimatedTotalRows,
+      hasScrollContainer: scrollContainer !== null,
+      hasTranslatedRows,
+      maxObservedRowIndex: rowIndexes.length > 0 ? Math.max(...rowIndexes) : void 0,
+      minObservedRowIndex: rowIndexes.length > 0 ? Math.min(...rowIndexes) : void 0,
+      knownGridKind: table.kind !== "aria-grid"
+    });
+  }
+  function withTableIntelligence(table, element) {
+    if (!(element instanceof Element)) {
+      return table;
+    }
+    return {
+      ...table,
+      intelligence: tableIntelligenceForElement(table, element)
+    };
+  }
   function describeTables() {
     const rootResult = resolveRootForLocator();
     if (!rootResult.ok) {
@@ -1685,26 +1999,28 @@
     const tables = [];
     const htmlTables = Array.from(root.querySelectorAll("table"));
     for (const [index, table] of htmlTables.entries()) {
-      tables.push({
+      const handle = {
         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
-      });
+      };
+      tables.push(withTableIntelligence(handle, table));
     }
     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({
+      const handle = {
         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,
+        rowCount: gridRowNodes(grid).length,
         columnCount: grid.querySelectorAll('[role="columnheader"]').length
-      });
+      };
+      tables.push(withTableIntelligence(handle, grid));
     }
     return tables;
   }
@@ -1764,15 +2080,171 @@
   }
   function gridRows(grid, limit) {
     const columns = gridSchema(grid);
-    return Array.from(grid.querySelectorAll('[role="row"]')).slice(0, limit).map((row) => {
+    return gridRowNodes(grid).slice(0, limit).map((row) => {
       const record = {};
-      Array.from(row.querySelectorAll('[role="gridcell"], [role="cell"], [role="columnheader"]')).forEach((cell, index) => {
+      Array.from(row.querySelectorAll('[role="gridcell"], [role="cell"]')).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 rowSignature(row) {
+    return JSON.stringify(
+      Object.entries(row).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => [key, value === void 0 ? null : value])
+    );
+  }
+  function mergeUniqueRows(target, rows, limit) {
+    let added = 0;
+    for (const row of rows) {
+      const signature = rowSignature(row);
+      if (target.has(signature)) {
+        continue;
+      }
+      target.set(signature, row);
+      added += 1;
+      if (target.size >= limit) {
+        break;
+      }
+    }
+    return added;
+  }
+  function waitForPaint(frames = 2) {
+    return new Promise((resolve) => {
+      const schedule = (remaining) => {
+        if (remaining <= 0) {
+          window.setTimeout(() => resolve(), 24);
+          return;
+        }
+        requestAnimationFrame(() => schedule(remaining - 1));
+      };
+      schedule(frames);
+    });
+  }
+  function currentTableWindowSignature(element) {
+    const rowIndexes = observedRowIndexes(gridRowNodes(element));
+    if (rowIndexes.length > 0) {
+      return `indexes:${rowIndexes.join(",")}`;
+    }
+    const visibleRows = tableRowsFromElement(element, 24);
+    return `rows:${visibleRows.map((row) => rowSignature(row)).join("|")}`;
+  }
+  async function waitForTableWindowChange(element, previousSignature, timeoutMs = 200) {
+    const start = Date.now();
+    let currentSignature = previousSignature;
+    while (Date.now() - start < timeoutMs) {
+      await waitForPaint(1);
+      currentSignature = currentTableWindowSignature(element);
+      if (currentSignature !== previousSignature) {
+        return currentSignature;
+      }
+      await new Promise((resolve) => window.setTimeout(resolve, 16));
+    }
+    return currentSignature;
+  }
+  async function scrollExtractRows(element, limit, intelligence) {
+    const scrollContainer = findScrollableTableContainer(element);
+    if (!scrollContainer) {
+      const rows2 = tableRowsFromElement(element, limit);
+      return {
+        rows: rows2,
+        extractionMode: "visibleOnly",
+        extraction: buildExtractionMetadata("visibleOnly", rows2, intelligence, [
+          "Fell back to visible rows because no scroll container was detected."
+        ])
+      };
+    }
+    const originalScrollTop = scrollContainer.scrollTop;
+    const collected = /* @__PURE__ */ new Map();
+    const seenRowIndexes = /* @__PURE__ */ new Set();
+    let stagnantPasses = 0;
+    let reachedEnd = false;
+    let limitApplied = false;
+    const rowHeight = gridRowNodes(element)[0]?.getBoundingClientRect().height ?? 0;
+    const step = Math.max(80, Math.round(scrollContainer.clientHeight * 0.8), rowHeight > 0 ? Math.round(rowHeight * 4) : 0);
+    const initialMaxScrollTop = Math.max(0, scrollContainer.scrollHeight - scrollContainer.clientHeight);
+    const maxIterations = Math.max(8, Math.min(80, Math.ceil(initialMaxScrollTop / Math.max(step, 1)) + 6, limit * 2));
+    try {
+      scrollContainer.scrollTop = 0;
+      scrollContainer.dispatchEvent(new Event("scroll"));
+      await waitForPaint();
+      let currentWindowSignature = currentTableWindowSignature(element);
+      for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+        const currentRows = tableRowsFromElement(element, limit);
+        const added = mergeUniqueRows(collected, currentRows, limit);
+        observedRowIndexes(gridRowNodes(element)).forEach((rowIndex) => {
+          seenRowIndexes.add(rowIndex);
+        });
+        const estimatedTotalRows = intelligence?.estimatedTotalRows;
+        if (typeof estimatedTotalRows === "number" && (collected.size >= estimatedTotalRows || seenRowIndexes.size >= estimatedTotalRows)) {
+          reachedEnd = true;
+          break;
+        }
+        if (collected.size >= limit) {
+          limitApplied = true;
+          break;
+        }
+        if (added === 0) {
+          stagnantPasses += 1;
+        } else {
+          stagnantPasses = 0;
+        }
+        const maxScrollTop = Math.max(0, scrollContainer.scrollHeight - scrollContainer.clientHeight);
+        if (scrollContainer.scrollTop >= maxScrollTop - 2) {
+          reachedEnd = true;
+          if (stagnantPasses >= 1) {
+            break;
+          }
+        }
+        if (stagnantPasses >= 2) {
+          break;
+        }
+        const nextScrollTop = Math.min(maxScrollTop, scrollContainer.scrollTop + step);
+        if (nextScrollTop === scrollContainer.scrollTop) {
+          reachedEnd = true;
+          break;
+        }
+        scrollContainer.scrollTop = nextScrollTop;
+        scrollContainer.dispatchEvent(new Event("scroll"));
+        currentWindowSignature = await waitForTableWindowChange(element, currentWindowSignature);
+      }
+      if (!reachedEnd) {
+        const maxScrollTop = Math.max(0, scrollContainer.scrollHeight - scrollContainer.clientHeight);
+        if (scrollContainer.scrollTop < maxScrollTop) {
+          const previousWindowSignature = currentTableWindowSignature(element);
+          scrollContainer.scrollTop = maxScrollTop;
+          scrollContainer.dispatchEvent(new Event("scroll"));
+          await waitForTableWindowChange(element, previousWindowSignature);
+          mergeUniqueRows(collected, tableRowsFromElement(element, limit), limit);
+          observedRowIndexes(gridRowNodes(element)).forEach((rowIndex) => {
+            seenRowIndexes.add(rowIndex);
+          });
+        }
+      }
+    } finally {
+      scrollContainer.scrollTop = originalScrollTop;
+      await waitForPaint();
+    }
+    const rows = [...collected.values()].slice(0, limit);
+    if (typeof intelligence?.estimatedTotalRows === "number" && (rows.length >= intelligence.estimatedTotalRows || seenRowIndexes.size >= intelligence.estimatedTotalRows)) {
+      reachedEnd = true;
+    }
+    const warnings = [];
+    if (limitApplied) {
+      warnings.push("Stopped after reaching maxRows before confirming the end of the table.");
+    }
+    if (!reachedEnd && (intelligence?.estimatedTotalRows ?? rows.length) > rows.length) {
+      warnings.push("Could not confirm the end of scrollable content; result may be partial.");
+    }
+    return {
+      rows,
+      extractionMode: "scroll",
+      extraction: buildExtractionMetadata("scroll", rows, intelligence, warnings, {
+        reachedEnd,
+        limitApplied
+      })
+    };
+  }
   function runPageWorldRequest(action, payload) {
     const requestId = `bak_page_world_${Date.now()}_${Math.random().toString(16).slice(2)}`;
     return new Promise((resolve, reject) => {
@@ -2150,6 +2622,31 @@
   async function globalsPreview() {
     return Object.keys(window).filter((key) => DISCOVERY_GLOBAL_PATTERN.test(key)).slice(0, 50);
   }
+  function collectInlineJsonSources(root) {
+    const scripts = Array.from(root.querySelectorAll('script[type="application/json"], script[type="application/ld+json"]'));
+    return scripts.map((script, index) => {
+      const raw = script.textContent?.trim() ?? "";
+      if (!raw) {
+        return null;
+      }
+      try {
+        const parsed = JSON.parse(raw);
+        const path = script.id ? `#${script.id}` : `inline-json:${index + 1}`;
+        const timestamps = collectTimestampProbes(parsed, path);
+        return {
+          label: script.id || script.getAttribute("data-testid") || script.type || `inline-json-${index + 1}`,
+          path,
+          sample: sampleValue(parsed),
+          sampleSize: estimateSampleSize(parsed),
+          schemaHint: inferSchemaHint(parsed),
+          lastObservedAt: timestamps.length > 0 ? Math.max(...timestamps.map((item) => Date.parse(item.value)).filter(Number.isFinite)) : null,
+          timestamps
+        };
+      } catch {
+        return null;
+      }
+    }).filter((item) => item !== null);
+  }
   async function collectInspectionState(params = {}) {
     const rootResult = resolveRootForLocator();
     if (!rootResult.ok) {
@@ -2170,6 +2667,7 @@
     );
     const previewGlobals = await globalsPreview();
     const suspiciousGlobals = [...new Set(scripts.flatMap((script) => script.suspectedVars))].slice(0, 50);
+    const inlineJsonSources = collectInlineJsonSources(root);
     return {
       url: metadata.url,
       title: metadata.title,
@@ -2188,6 +2686,7 @@
       storage: storageMetadata(),
       cookies: cookieMetadata(),
       frames: collectFrames(),
+      inlineJsonSources,
       tables: describeTables(),
       timers: {
         timeouts: 0,
@@ -2887,9 +3386,10 @@
         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) };
+        const table = withTableIntelligence(resolved.table, resolved.element);
+        const schema = { columns: tableSchemaFromElement(resolved.element) };
         return {
-          table: resolved.table,
+          table,
           schema
         };
       }
@@ -2900,11 +3400,29 @@
           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);
+        const table = withTableIntelligence(resolved.table, resolved.element);
+        let rows = tableRowsFromElement(resolved.element, requestedLimit);
+        let extractionMode = table.intelligence?.preferredExtractionMode ?? (resolved.element instanceof HTMLTableElement ? "dataSource" : "visibleOnly");
+        let extraction = buildExtractionMetadata(
+          extractionMode,
+          rows,
+          table.intelligence,
+          params.all === true && extractionMode === "visibleOnly" ? ["Only visible rows could be read from this table region."] : [],
+          {
+            reachedEnd: extractionMode === "dataSource",
+            limitApplied: params.all === true && rows.length >= requestedLimit
+          }
+        );
+        if (params.all === true && extractionMode === "scroll") {
+          const scrolled = await scrollExtractRows(resolved.element, requestedLimit, table.intelligence);
+          rows = scrolled.rows;
+          extractionMode = scrolled.extractionMode;
+          extraction = scrolled.extraction;
+        }
         return {
-          table: resolved.table,
+          table,
           extractionMode,
+          extraction,
           rows
         };
       }

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "manifest_version": 3,
   "name": "Browser Agent Kit",
-  "version": "0.6.11",
+  "version": "0.6.12",
   "action": {
     "default_popup": "popup.html"
   },