@flrande/bak-extension 0.6.11 → 0.6.12

package/dist/background.global.js

@@ -1,5 +1,499 @@
 "use strict";
 (() => {
+  // 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 normalizeColumnName(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+  }
+  function normalizedComparableValue(value) {
+    if (value === null || value === void 0) {
+      return null;
+    }
+    if (typeof value === "object") {
+      return null;
+    }
+    const text = String(value).trim().toLowerCase();
+    return text.length > 0 ? text : null;
+  }
+  function compareNumbers(left, right) {
+    return left - right;
+  }
+  function latestTimestamp(timestamps) {
+    const values = timestamps.map((timestamp) => Date.parse(timestamp.value)).filter((value) => Number.isFinite(value));
+    return values.length > 0 ? Math.max(...values) : null;
+  }
+  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 toObjectRow(row, fallbackColumns = []) {
+    if (row && typeof row === "object" && !Array.isArray(row)) {
+      return row;
+    }
+    if (Array.isArray(row)) {
+      const mapped = {};
+      row.forEach((value, index) => {
+        mapped[fallbackColumns[index] ?? `Column ${index + 1}`] = value;
+      });
+      return mapped;
+    }
+    if (row === null || row === void 0) {
+      return null;
+    }
+    return { Value: row };
+  }
+  function sampleRowsFromValue(value, limit = 5) {
+    const rowsCandidate = extractStructuredRows(value);
+    if (!rowsCandidate) {
+      const singleRow = toObjectRow(value);
+      return singleRow ? [singleRow] : [];
+    }
+    const fallbackColumns = rowsCandidate.rowType === "array" ? Array.from({ length: Array.isArray(rowsCandidate.rows[0]) ? rowsCandidate.rows[0].length : 0 }, (_, index) => `Column ${index + 1}`) : [];
+    return rowsCandidate.rows.slice(0, limit).map((row) => toObjectRow(row, fallbackColumns)).filter((row) => row !== null);
+  }
+  function collectSampleValues(rows) {
+    const values = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      for (const value of Object.values(row)) {
+        const comparable = normalizedComparableValue(value);
+        if (comparable) {
+          values.add(comparable);
+        }
+        if (values.size >= 24) {
+          return values;
+        }
+      }
+    }
+    return values;
+  }
+  function buildSourceAnalysis(source, sample) {
+    const sampleRows = sampleRowsFromValue(sample);
+    return {
+      source,
+      sampleRows,
+      sampleValues: collectSampleValues(sampleRows),
+      schemaColumns: source.schemaHint?.columns?.map(normalizeColumnName).filter(Boolean) ?? []
+    };
+  }
+  function parseNetworkBody(entry) {
+    const preview = typeof entry.responseBodyPreview === "string" ? entry.responseBodyPreview.trim() : "";
+    if (!preview || entry.responseBodyTruncated === true || entry.binary === true) {
+      return null;
+    }
+    const contentType = typeof entry.contentType === "string" ? entry.contentType.toLowerCase() : "";
+    if (!contentType.includes("json") && !preview.startsWith("{") && !preview.startsWith("[")) {
+      return null;
+    }
+    try {
+      return JSON.parse(preview);
+    } catch {
+      return null;
+    }
+  }
+  function buildWindowSources(candidates) {
+    return candidates.map((candidate) => {
+      const source = {
+        sourceId: `windowGlobal:${candidate.name}`,
+        type: "windowGlobal",
+        label: candidate.name,
+        path: candidate.name,
+        sampleSize: candidate.sampleSize,
+        schemaHint: candidate.schemaHint,
+        lastObservedAt: candidate.lastObservedAt
+      };
+      return buildSourceAnalysis(source, candidate.sample);
+    });
+  }
+  function buildInlineJsonAnalyses(sources) {
+    return sources.map((sourceItem, index) => {
+      const source = {
+        sourceId: `inlineJson:${index + 1}:${sourceItem.path}`,
+        type: "inlineJson",
+        label: sourceItem.label,
+        path: sourceItem.path,
+        sampleSize: sourceItem.sampleSize,
+        schemaHint: sourceItem.schemaHint,
+        lastObservedAt: sourceItem.lastObservedAt
+      };
+      return buildSourceAnalysis(source, sourceItem.sample);
+    });
+  }
+  function buildNetworkAnalyses(entries) {
+    const analyses = [];
+    for (const entry of entries) {
+      const parsed = parseNetworkBody(entry);
+      if (parsed === null) {
+        continue;
+      }
+      const rowsCandidate = extractStructuredRows(parsed);
+      const schemaHint = inferSchemaHint(parsed);
+      const url = new URL(entry.url, "http://127.0.0.1");
+      const source = {
+        sourceId: `networkResponse:${entry.id}`,
+        type: "networkResponse",
+        label: `${entry.method} ${url.pathname}`,
+        path: rowsCandidate?.path ?? url.pathname,
+        sampleSize: estimateSampleSize(rowsCandidate?.rows ?? parsed),
+        schemaHint,
+        lastObservedAt: entry.ts
+      };
+      analyses.push(buildSourceAnalysis(source, rowsCandidate?.rows ?? parsed));
+    }
+    return analyses;
+  }
+  function scoreSourceMapping(table, source, now) {
+    const tableColumns = table.schema.columns.map((column) => column.label);
+    const normalizedTableColumns = new Map(tableColumns.map((label) => [normalizeColumnName(label), label]));
+    const matchedColumns = [...new Set(source.schemaColumns.filter((column) => normalizedTableColumns.has(column)).map((column) => normalizedTableColumns.get(column)))];
+    const basis = [];
+    if (matchedColumns.length > 0) {
+      basis.push({
+        type: "columnOverlap",
+        detail: `Column overlap on ${matchedColumns.join(", ")}`
+      });
+    }
+    const overlappingValues = [...table.sampleRows.flatMap((row) => Object.values(row))].map((value) => normalizedComparableValue(value)).filter((value) => value !== null).filter((value) => source.sampleValues.has(value));
+    const distinctOverlappingValues = [...new Set(overlappingValues)].slice(0, 5);
+    if (distinctOverlappingValues.length > 0) {
+      basis.push({
+        type: "sampleValueOverlap",
+        detail: `Shared sample values: ${distinctOverlappingValues.join(", ")}`
+      });
+    }
+    const explicitReferenceHit = table.table.name.toLowerCase().includes(source.source.label.toLowerCase()) || (table.table.selector ?? "").toLowerCase().includes(source.source.label.toLowerCase()) || source.source.label.toLowerCase().includes(table.table.name.toLowerCase());
+    if (explicitReferenceHit) {
+      basis.push({
+        type: "explicitReference",
+        detail: `Table label and source label both mention ${source.source.label}`
+      });
+    }
+    if (source.source.type === "networkResponse" && typeof source.source.lastObservedAt === "number" && Math.max(0, now - source.source.lastObservedAt) <= 9e4) {
+      basis.push({
+        type: "timeProximity",
+        detail: "Recent network response observed within the last 90 seconds"
+      });
+    }
+    if (basis.length === 0) {
+      return null;
+    }
+    const confidence = matchedColumns.length >= Math.max(2, Math.min(tableColumns.length, 3)) || matchedColumns.length > 0 && distinctOverlappingValues.length > 0 ? "high" : matchedColumns.length > 0 || distinctOverlappingValues.length > 0 ? "medium" : "low";
+    return {
+      tableId: table.table.id,
+      sourceId: source.source.sourceId,
+      confidence,
+      basis,
+      matchedColumns
+    };
+  }
+  function buildRecommendedNextActions(tables, mappings, sourceAnalyses) {
+    const recommendations = [];
+    const pushRecommendation = (item) => {
+      if (recommendations.some((existing) => existing.command === item.command)) {
+        return;
+      }
+      recommendations.push(item);
+    };
+    for (const table of tables) {
+      if (table.table.intelligence?.preferredExtractionMode === "scroll") {
+        pushRecommendation({
+          title: `Read all rows from ${table.table.id}`,
+          command: `bak table rows --table ${table.table.id} --all --max-rows 10000`,
+          note: "The table looks virtualized or lazy-loaded, so a scroll pass is preferred."
+        });
+      }
+    }
+    for (const mapping of mappings.filter((item) => item.confidence !== "low")) {
+      const source = sourceAnalyses.find((analysis) => analysis.source.sourceId === mapping.sourceId);
+      if (!source) {
+        continue;
+      }
+      if (source.source.type === "windowGlobal") {
+        pushRecommendation({
+          title: `Read ${source.source.label} directly from page data`,
+          command: `bak page extract --path "${source.source.path}" --resolver auto`,
+          note: `Mapped to ${mapping.tableId} with ${mapping.confidence} confidence.`
+        });
+        continue;
+      }
+      if (source.source.type === "networkResponse") {
+        const requestId = source.source.sourceId.replace(/^networkResponse:/, "");
+        pushRecommendation({
+          title: `Replay ${requestId} with table schema`,
+          command: `bak network replay --request-id ${requestId} --mode json --with-schema auto`,
+          note: `Recent response mapped to ${mapping.tableId} with ${mapping.confidence} confidence.`
+        });
+        continue;
+      }
+      pushRecommendation({
+        title: `Inspect ${source.source.label} inline JSON`,
+        command: "bak page freshness",
+        note: `Inline JSON source mapped to ${mapping.tableId}; use freshness or capture commands to inspect it further.`
+      });
+    }
+    if (recommendations.length === 0) {
+      pushRecommendation({
+        title: "Check data freshness",
+        command: "bak page freshness",
+        note: "No strong data-source mapping was found yet."
+      });
+    }
+    return recommendations.slice(0, 6);
+  }
+  function buildSourceMappingReport(input) {
+    const now = typeof input.now === "number" ? input.now : Date.now();
+    const windowAnalyses = buildWindowSources(input.windowSources);
+    const inlineAnalyses = buildInlineJsonAnalyses(input.inlineJsonSources);
+    const networkAnalyses = buildNetworkAnalyses(input.recentNetwork);
+    const sourceAnalyses = [...windowAnalyses, ...inlineAnalyses, ...networkAnalyses];
+    const sourceMappings = input.tables.flatMap((table) => sourceAnalyses.map((source) => scoreSourceMapping(table, source, now))).filter((mapping) => mapping !== null).sort((left, right) => {
+      const confidenceRank = { high: 0, medium: 1, low: 2 };
+      return confidenceRank[left.confidence] - confidenceRank[right.confidence] || left.tableId.localeCompare(right.tableId) || left.sourceId.localeCompare(right.sourceId);
+    });
+    return {
+      dataSources: sourceAnalyses.map((analysis) => analysis.source),
+      sourceMappings,
+      recommendedNextActions: buildRecommendedNextActions(input.tables, sourceMappings, sourceAnalyses),
+      sourceAnalyses
+    };
+  }
+  function mapObjectRowToSchema(row, schema) {
+    const normalizedKeys = new Map(Object.keys(row).map((key) => [normalizeColumnName(key), key]));
+    const mapped = {};
+    for (const column of schema.columns) {
+      const normalized = normalizeColumnName(column.label);
+      const sourceKey = normalizedKeys.get(normalized);
+      if (sourceKey) {
+        mapped[column.label] = row[sourceKey];
+      }
+    }
+    if (Object.keys(mapped).length > 0) {
+      return mapped;
+    }
+    return { ...row };
+  }
+  function selectReplaySchemaMatch(responseJson, tables, options = {}) {
+    const candidate = extractStructuredRows(responseJson);
+    if (!candidate || candidate.rows.length === 0 || tables.length === 0) {
+      return null;
+    }
+    const preferredTableId = options.preferredSourceId && options.mappings ? options.mappings.find((mapping) => mapping.sourceId === options.preferredSourceId && mapping.confidence !== "low")?.tableId : void 0;
+    const orderedTables = preferredTableId ? tables.slice().sort((left, right) => {
+      if (left.table.id === preferredTableId) {
+        return -1;
+      }
+      if (right.table.id === preferredTableId) {
+        return 1;
+      }
+      return left.table.id.localeCompare(right.table.id);
+    }) : tables;
+    const firstRow = candidate.rows[0];
+    if (Array.isArray(firstRow)) {
+      const matchingTable = orderedTables.find((table) => table.schema.columns.length === firstRow.length) ?? orderedTables.find((table) => table.schema.columns.length > 0) ?? null;
+      if (!matchingTable) {
+        return null;
+      }
+      return {
+        table: matchingTable.table,
+        schema: matchingTable.schema,
+        mappedRows: candidate.rows.filter((row) => Array.isArray(row)).map((row) => {
+          const mapped = {};
+          matchingTable.schema.columns.forEach((column, index) => {
+            mapped[column.label] = row[index];
+          });
+          return mapped;
+        }),
+        mappingSource: candidate.path
+      };
+    }
+    if (firstRow && typeof firstRow === "object") {
+      const rowObject = firstRow;
+      const rowKeys = new Set(Object.keys(rowObject).map(normalizeColumnName));
+      const matchingEntry = orderedTables.map((table) => ({
+        table,
+        score: table.schema.columns.filter((column) => rowKeys.has(normalizeColumnName(column.label))).length
+      })).sort((left, right) => compareNumbers(right.score, left.score))[0] ?? null;
+      if (!matchingEntry || matchingEntry.score <= 0) {
+        return null;
+      }
+      const matchingTable = matchingEntry.table;
+      return {
+        table: matchingTable.table,
+        schema: matchingTable.schema,
+        mappedRows: candidate.rows.filter((row) => typeof row === "object" && row !== null && !Array.isArray(row)).map((row) => mapObjectRowToSchema(row, matchingTable.schema)),
+        mappingSource: candidate.path
+      };
+    }
+    return null;
+  }
+  function buildInspectPageDataResult(input) {
+    const report = buildSourceMappingReport({
+      tables: input.tableAnalyses,
+      windowSources: input.pageDataCandidates,
+      inlineJsonSources: input.inlineJsonSources,
+      recentNetwork: input.recentNetwork,
+      now: input.now
+    });
+    return {
+      dataSources: report.dataSources,
+      sourceMappings: report.sourceMappings,
+      recommendedNextActions: report.recommendedNextActions
+    };
+  }
+  function buildPageDataProbe(name, resolver, sample) {
+    const timestamps = collectTimestampProbes(sample, name);
+    return {
+      name,
+      resolver,
+      sample: sampleValue(sample),
+      sampleSize: estimateSampleSize(sample),
+      schemaHint: inferSchemaHint(sample),
+      lastObservedAt: latestTimestamp(timestamps),
+      timestamps
+    };
+  }
+
   // src/privacy.ts
   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)?)";
@@ -62,7 +556,7 @@
   // package.json
   var package_default = {
     name: "@flrande/bak-extension",
-    version: "0.6.11",
+    version: "0.6.12",
     type: "module",
     scripts: {
       build: "tsup src/background.ts src/content.ts src/popup.ts --format iife --out-dir dist --clean && node scripts/copy-assets.mjs",
@@ -1414,6 +1908,7 @@
   var preserveHumanFocusDepth = 0;
   var lastBindingUpdateAt = null;
   var lastBindingUpdateReason = null;
+  var bindingUpdateMetadata = /* @__PURE__ */ new Map();
   async function getConfig() {
     const stored = await chrome.storage.local.get([STORAGE_KEY_TOKEN, STORAGE_KEY_PORT, STORAGE_KEY_DEBUG_RICH_TEXT]);
     return {
@@ -1546,19 +2041,27 @@
   async function listSessionBindingStates() {
     return Object.values(await loadSessionBindingStateMap());
   }
-  function summarizeSessionBindings(states) {
-    const items = states.map((state) => {
-      const detached = state.windowId === null || state.tabIds.length === 0;
-      return {
-        id: state.id,
-        label: state.label,
-        tabCount: state.tabIds.length,
-        activeTabId: state.activeTabId,
-        windowId: state.windowId,
-        groupId: state.groupId,
-        detached
-      };
-    });
+  async function summarizeSessionBindings(states) {
+    const items = await Promise.all(
+      states.map(async (state) => {
+        const detached = state.windowId === null || state.tabIds.length === 0;
+        const activeTab = typeof state.activeTabId === "number" ? await sessionBindingBrowser.getTab(state.activeTabId) : null;
+        const bindingUpdate = bindingUpdateMetadata.get(state.id);
+        return {
+          id: state.id,
+          label: state.label,
+          tabCount: state.tabIds.length,
+          activeTabId: state.activeTabId,
+          activeTabTitle: activeTab?.title ?? null,
+          activeTabUrl: activeTab?.url ?? null,
+          windowId: state.windowId,
+          groupId: state.groupId,
+          detached,
+          lastBindingUpdateAt: bindingUpdate?.at ?? null,
+          lastBindingUpdateReason: bindingUpdate?.reason ?? null
+        };
+      })
+    );
     return {
       count: items.length,
       attachedCount: items.filter((item) => !item.detached).length,
@@ -1569,7 +2072,7 @@
   }
   async function buildPopupState() {
     const config = await getConfig();
-    const sessionBindings = summarizeSessionBindings(await listSessionBindingStates());
+    const sessionBindings = await summarizeSessionBindings(await listSessionBindingStates());
     const reconnectRemainingMs = nextReconnectAt === null ? null : Math.max(0, nextReconnectAt - Date.now());
     let connectionState;
     if (!config.token) {
@@ -1630,6 +2133,10 @@
   function emitSessionBindingUpdated(bindingId, reason, state, extras = {}) {
     lastBindingUpdateAt = Date.now();
     lastBindingUpdateReason = reason;
+    bindingUpdateMetadata.set(bindingId, {
+      at: lastBindingUpdateAt,
+      reason
+    });
     sendEvent("sessionBinding.updated", {
       bindingId,
       reason,
@@ -2482,15 +2989,6 @@
     const dataPattern = /\\b(updated|update|updatedat|asof|timestamp|generated|generatedat|refresh|latest|last|quote|trade|price|flow|market|time|snapshot|signal)\\b/i;
     const contractPattern = /\\b(expiry|expiration|expires|option|contract|strike|maturity|dte|call|put|exercise)\\b/i;
     const eventPattern = /\\b(earnings|event|report|dividend|split|meeting|fomc|release|filing)\\b/i;
-    const isTimestampString = (value) => typeof value === 'string' && value.trim().length > 0 && !Number.isNaN(Date.parse(value.trim()));
-    const classify = (path, value) => {
-      const normalized = String(path || '').toLowerCase();
-      if (dataPattern.test(normalized)) return 'data';
-      if (contractPattern.test(normalized)) return 'contract';
-      if (eventPattern.test(normalized)) return 'event';
-      const parsed = Date.parse(String(value || '').trim());
-      return Number.isFinite(parsed) && parsed > Date.now() + 36 * 60 * 60 * 1000 ? 'contract' : 'unknown';
-    };
     const sampleValue = (value, depth = 0) => {
       if (depth >= 2 || value == null || typeof value !== 'object') {
         if (typeof value === 'string') {
@@ -2514,29 +3012,6 @@
       }
       return sampled;
     };
-    const collectTimestamps = (value, path, depth, collected) => {
-      if (collected.length >= 16) return;
-      if (isTimestampString(value)) {
-        collected.push({ path, value: String(value), category: classify(path, value) });
-        return;
-      }
-      if (depth >= 3) return;
-      if (Array.isArray(value)) {
-        value.slice(0, 3).forEach((item, index) => collectTimestamps(item, path + '[' + index + ']', depth + 1, collected));
-        return;
-      }
-      if (value && typeof value === 'object') {
-        Object.keys(value)
-          .slice(0, 8)
-          .forEach((key) => {
-            try {
-              collectTimestamps(value[key], path ? path + '.' + key : key, depth + 1, collected);
-            } catch {
-              // Ignore unreadable nested properties.
-            }
-          });
-      }
-    };
     const readCandidate = (name) => {
       if (name in globalThis) {
         return { resolver: 'globalThis', value: globalThis[name] };
@@ -2547,13 +3022,10 @@
     for (const name of candidates) {
       try {
         const resolved = readCandidate(name);
-        const timestamps = [];
-        collectTimestamps(resolved.value, name, 0, timestamps);
         results.push({
           name,
           resolver: resolved.resolver,
-          sample: sampleValue(resolved.value),
-          timestamps
+          sample: sampleValue(resolved.value)
         });
       } catch {
         // Ignore inaccessible candidates.
@@ -2568,7 +3040,12 @@
         maxBytes: 64 * 1024
       });
       const frameResult = evaluated.result ?? evaluated.results?.find((candidate) => candidate.value || candidate.error);
-      return Array.isArray(frameResult?.value) ? frameResult.value : [];
+      if (!Array.isArray(frameResult?.value)) {
+        return [];
+      }
+      return frameResult.value.filter(
+        (candidate) => typeof candidate === "object" && candidate !== null && typeof candidate.name === "string"
+      ).map((candidate) => buildPageDataProbe(candidate.name, candidate.resolver, candidate.sample));
     } catch {
       return [];
     }
@@ -2692,52 +3169,59 @@
     }
     return null;
   }
-  async function enrichReplayWithSchema(tabId, response) {
-    const candidate = extractReplayRowsCandidate(response.json);
-    if (!candidate || candidate.rows.length === 0) {
-      return response;
-    }
-    const firstRow = candidate.rows[0];
+  async function collectTableAnalyses(tabId) {
     const tablesResult = await forwardContentRpc(tabId, "table.list", {});
     const tables = Array.isArray(tablesResult.tables) ? tablesResult.tables : [];
-    if (tables.length === 0) {
-      return response;
-    }
-    const schemas = [];
+    const analyses = [];
     for (const table of tables) {
       const schemaResult = await forwardContentRpc(tabId, "table.schema", { table: table.id });
+      const rowsResult = await forwardContentRpc(tabId, "table.rows", {
+        table: table.id,
+        limit: 8
+      });
       if (schemaResult.schema && Array.isArray(schemaResult.schema.columns)) {
-        schemas.push({ table: schemaResult.table ?? table, schema: schemaResult.schema });
+        analyses.push({
+          table: schemaResult.table ?? rowsResult.table ?? table,
+          schema: schemaResult.schema,
+          sampleRows: Array.isArray(rowsResult.rows) ? rowsResult.rows.slice(0, 8) : []
+        });
       }
     }
-    if (schemas.length === 0) {
+    return analyses;
+  }
+  async function enrichReplayWithSchema(tabId, requestId, response) {
+    const candidate = extractReplayRowsCandidate(response.json);
+    if (!candidate || candidate.rows.length === 0) {
       return response;
     }
-    if (Array.isArray(firstRow)) {
-      const matchingSchema = schemas.find(({ schema }) => schema.columns.length === firstRow.length) ?? schemas[0];
-      if (!matchingSchema) {
-        return response;
-      }
-      const mappedRows = candidate.rows.filter((row) => Array.isArray(row)).map((row) => {
-        const mapped = {};
-        matchingSchema.schema.columns.forEach((column, index) => {
-          mapped[column.label] = row[index];
-        });
-        return mapped;
-      });
-      return {
-        ...response,
-        table: matchingSchema.table,
-        schema: matchingSchema.schema,
-        mappedRows,
-        mappingSource: candidate.source
-      };
+    const tables = await collectTableAnalyses(tabId);
+    if (tables.length === 0) {
+      return response;
     }
-    if (typeof firstRow === "object" && firstRow !== null) {
+    const inspection = await collectPageInspection(tabId, {});
+    const pageDataCandidates = await probePageDataCandidatesForTab(tabId, inspection);
+    const recentNetwork = listNetworkEntries(tabId, { limit: 25 });
+    const pageDataReport = buildInspectPageDataResult({
+      suspiciousGlobals: inspection.suspiciousGlobals ?? [],
+      tables: inspection.tables ?? [],
+      visibleTimestamps: inspection.visibleTimestamps ?? [],
+      inlineTimestamps: inspection.inlineTimestamps ?? [],
+      pageDataCandidates,
+      recentNetwork,
+      tableAnalyses: tables,
+      inlineJsonSources: Array.isArray(inspection.inlineJsonSources) ? inspection.inlineJsonSources : []
+    });
+    const matched = selectReplaySchemaMatch(response.json, tables, {
+      preferredSourceId: `networkResponse:${requestId}`,
+      mappings: pageDataReport.sourceMappings
+    });
+    if (matched) {
       return {
         ...response,
-        mappedRows: candidate.rows.filter((row) => typeof row === "object" && row !== null),
-        mappingSource: candidate.source
+        table: matched.table,
+        schema: matched.schema,
+        mappedRows: matched.mappedRows,
+        mappingSource: matched.mappingSource
       };
     }
     return response;
@@ -3255,7 +3739,7 @@
           if (!first) {
             throw toError("E_EXECUTION", "network replay returned no response payload");
           }
-          return params.withSchema === "auto" && params.mode === "json" ? await enrichReplayWithSchema(tab.id, first) : first;
+          return params.withSchema === "auto" && params.mode === "json" ? await enrichReplayWithSchema(tab.id, String(params.id ?? ""), first) : first;
         });
       }
       case "page.freshness": {
@@ -3333,6 +3817,18 @@
           const inspection = await collectPageInspection(tab.id, params);
           const pageDataCandidates = await probePageDataCandidatesForTab(tab.id, inspection);
           const network = listNetworkEntries(tab.id, { limit: 10 });
+          const tableAnalyses = await collectTableAnalyses(tab.id);
+          const enriched = buildInspectPageDataResult({
+            suspiciousGlobals: inspection.suspiciousGlobals ?? [],
+            tables: inspection.tables ?? [],
+            visibleTimestamps: inspection.visibleTimestamps ?? [],
+            inlineTimestamps: inspection.inlineTimestamps ?? [],
+            pageDataCandidates,
+            recentNetwork: network,
+            tableAnalyses,
+            inlineJsonSources: Array.isArray(inspection.inlineJsonSources) ? inspection.inlineJsonSources : []
+          });
+          const recommendedNextSteps = enriched.recommendedNextActions.map((action) => action.command);
           return {
             suspiciousGlobals: inspection.suspiciousGlobals ?? [],
             tables: inspection.tables ?? [],
@@ -3340,10 +3836,12 @@
             inlineTimestamps: inspection.inlineTimestamps ?? [],
             pageDataCandidates,
             recentNetwork: network,
+            dataSources: enriched.dataSources,
+            sourceMappings: enriched.sourceMappings,
+            recommendedNextActions: enriched.recommendedNextActions,
             recommendedNextSteps: [
-              "bak page extract --path table_data --resolver auto",
-              "bak network search --pattern table_data",
-              "bak page freshness"
+              ...recommendedNextSteps,
+              ...["bak page freshness"].filter((command) => !recommendedNextSteps.includes(command))
             ]
           };
         });