@flrande/bak-extension 0.6.11 → 0.6.13

package/src/background.ts

@@ -1,19 +1,30 @@
-import type {
-  ConsoleEntry,
-  DebugDumpSection,
-  Locator,
-  NetworkEntry,
-  PageExecutionScope,
-  PageFetchResponse,
-  PageFrameResult,
-  PageFreshnessResult,
-  TableHandle,
-  TableSchema
-} from '@flrande/bak-protocol';
-import {
-  clearNetworkEntries,
-  dropNetworkCapture,
-  ensureNetworkDebugger,
+import type {
+  ConsoleEntry,
+  DebugDumpSection,
+  InspectFreshnessResult,
+  InspectLiveUpdatesResult,
+  InspectPageDataCandidateProbe,
+  InspectPageDataResult,
+  Locator,
+  NetworkEntry,
+  PageExecutionScope,
+  PageFetchResponse,
+  PageFrameResult,
+  PageFreshnessResult,
+  TableHandle,
+  TableSchema
+} from '@flrande/bak-protocol';
+import {
+  buildInspectPageDataResult,
+  buildPageDataProbe,
+  selectReplaySchemaMatch,
+  type InlineJsonInspectionSource,
+  type TableAnalysis
+} from './dynamic-data-tools.js';
+import {
+  clearNetworkEntries,
+  dropNetworkCapture,
+  ensureNetworkDebugger,
   exportHar,
   getNetworkEntry,
   latestNetworkTimestamp,
@@ -65,15 +76,19 @@ interface RuntimeErrorDetails {
   at: number;
 }
 
-interface PopupSessionBindingSummary {
-  id: string;
-  label: string;
-  tabCount: number;
-  activeTabId: number | null;
-  windowId: number | null;
-  groupId: number | null;
-  detached: boolean;
-}
+interface PopupSessionBindingSummary {
+  id: string;
+  label: string;
+  tabCount: number;
+  activeTabId: number | null;
+  activeTabTitle: string | null;
+  activeTabUrl: string | null;
+  windowId: number | null;
+  groupId: number | null;
+  detached: boolean;
+  lastBindingUpdateAt: number | null;
+  lastBindingUpdateReason: string | null;
+}
 
 interface PopupState {
   ok: true;
@@ -114,24 +129,48 @@ const CONTRACT_TIMESTAMP_CONTEXT_PATTERN =
   /\b(expiry|expiration|expires|option|contract|strike|maturity|dte|call|put|exercise)\b/i;
 const EVENT_TIMESTAMP_CONTEXT_PATTERN = /\b(earnings|event|report|dividend|split|meeting|fomc|release|filing)\b/i;
 
-interface TimestampEvidenceCandidate {
+interface TimestampEvidenceCandidate {
   value: string;
   source: 'visible' | 'inline' | 'page-data' | 'network';
   context?: string;
   path?: string;
   category?: 'data' | 'contract' | 'event' | 'unknown';
-}
-
-interface PageDataCandidateProbe {
-  name: string;
-  resolver: 'globalThis' | 'lexical';
-  sample: unknown;
-  timestamps: Array<{
-    path: string;
-    value: string;
-    category: 'data' | 'contract' | 'event' | 'unknown';
-  }>;
-}
+}
+
+interface PageInspectionState {
+  url?: string;
+  title?: string;
+  html?: string;
+  visibleText?: Array<{ chunkId: string; text: string; sourceTag: string }>;
+  suspiciousGlobals?: string[];
+  globalsPreview?: string[];
+  visibleTimestamps?: string[];
+  visibleTimestampCandidates?: Array<Record<string, unknown>>;
+  inlineTimestamps?: string[];
+  inlineTimestampCandidates?: Array<Record<string, unknown>>;
+  tables?: TableHandle[];
+  inlineJsonSources?: InlineJsonInspectionSource[];
+  cookies?: Array<{ name: string }>;
+  lastMutationAt?: number;
+  pageLoadedAt?: number;
+  scripts?: {
+    inlineCount: number;
+    suspectedDataVars: string[];
+  };
+  storage?: {
+    localStorageKeys: string[];
+    sessionStorageKeys: string[];
+  };
+  frames?: Array<{ framePath: string[]; url: string }>;
+  context?: {
+    framePath: string[];
+    shadowPath: string[];
+  };
+  timers?: {
+    timeouts: number;
+    intervals: number;
+  };
+}
 const REPLAY_FORBIDDEN_HEADER_NAMES = new Set([
   'accept-encoding',
   'authorization',
@@ -152,10 +191,11 @@ let nextReconnectAt: number | null = null;
 let reconnectAttempt = 0;
 let lastError: RuntimeErrorDetails | null = null;
 let manualDisconnect = false;
-let sessionBindingStateMutationQueue: Promise<void> = Promise.resolve();
-let preserveHumanFocusDepth = 0;
-let lastBindingUpdateAt: number | null = null;
-let lastBindingUpdateReason: string | null = null;
+let sessionBindingStateMutationQueue: Promise<void> = Promise.resolve();
+let preserveHumanFocusDepth = 0;
+let lastBindingUpdateAt: number | null = null;
+let lastBindingUpdateReason: string | null = null;
+const bindingUpdateMetadata = new Map<string, { at: number; reason: string }>();
 
 async function getConfig(): Promise<ExtensionConfig> {
   const stored = await chrome.storage.local.get([STORAGE_KEY_TOKEN, STORAGE_KEY_PORT, STORAGE_KEY_DEBUG_RICH_TEXT]);
@@ -308,31 +348,40 @@ async function listSessionBindingStates(): Promise<SessionBindingRecord[]> {
   return Object.values(await loadSessionBindingStateMap());
 }
 
-function summarizeSessionBindings(states: SessionBindingRecord[]): PopupState['sessionBindings'] {
-  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
-    } satisfies PopupSessionBindingSummary;
-  });
-  return {
-    count: items.length,
-    attachedCount: items.filter((item) => !item.detached).length,
+async function summarizeSessionBindings(states: SessionBindingRecord[]): Promise<PopupState['sessionBindings']> {
+  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
+      } satisfies PopupSessionBindingSummary;
+    })
+  );
+  return {
+    count: items.length,
+    attachedCount: items.filter((item) => !item.detached).length,
     detachedCount: items.filter((item) => item.detached).length,
     tabCount: items.reduce((sum, item) => sum + item.tabCount, 0),
     items
   };
 }
 
-async function buildPopupState(): Promise<PopupState> {
-  const config = await getConfig();
-  const sessionBindings = summarizeSessionBindings(await listSessionBindingStates());
+async function buildPopupState(): Promise<PopupState> {
+  const config = await getConfig();
+  const sessionBindings = await summarizeSessionBindings(await listSessionBindingStates());
   const reconnectRemainingMs = nextReconnectAt === null ? null : Math.max(0, nextReconnectAt - Date.now());
   let connectionState: PopupState['connectionState'];
   if (!config.token) {
@@ -395,16 +444,20 @@ function toSessionBindingEventBrowser(state: SessionBindingRecord | null): Recor
   };
 }
 
-function emitSessionBindingUpdated(
-  bindingId: string,
-  reason: string,
-  state: SessionBindingRecord | null,
-  extras: Record<string, unknown> = {}
-): void {
-  lastBindingUpdateAt = Date.now();
-  lastBindingUpdateReason = reason;
-  sendEvent('sessionBinding.updated', {
-    bindingId,
+function emitSessionBindingUpdated(
+  bindingId: string,
+  reason: string,
+  state: SessionBindingRecord | null,
+  extras: Record<string, unknown> = {}
+): void {
+  lastBindingUpdateAt = Date.now();
+  lastBindingUpdateReason = reason;
+  bindingUpdateMetadata.set(bindingId, {
+    at: lastBindingUpdateAt,
+    reason
+  });
+  sendEvent('sessionBinding.updated', {
+    bindingId,
     reason,
     browser: toSessionBindingEventBrowser(state),
     ...extras
@@ -1391,118 +1444,91 @@ function computeFreshnessAssessment(input: {
   return 'unknown';
 }
 
-async function collectPageInspection(tabId: number, params: Record<string, unknown> = {}): Promise<Record<string, unknown>> {
-  return (await forwardContentRpc(tabId, 'bak.internal.inspectState', params)) as Record<string, unknown>;
-}
-
-async function probePageDataCandidatesForTab(tabId: number, inspection: Record<string, unknown>): Promise<PageDataCandidateProbe[]> {
-  const candidateNames = [
-    ...(Array.isArray(inspection.suspiciousGlobals) ? inspection.suspiciousGlobals.map(String) : []),
-    ...(Array.isArray(inspection.globalsPreview) ? inspection.globalsPreview.map(String) : [])
-  ]
-    .filter((name, index, array) => /^[A-Za-z_$][\w$]*$/.test(name) && array.indexOf(name) === index)
-    .slice(0, 16);
+async function collectPageInspection(tabId: number, params: Record<string, unknown> = {}): Promise<PageInspectionState> {
+  return (await forwardContentRpc(tabId, 'bak.internal.inspectState', params)) as PageInspectionState;
+}
+
+async function probePageDataCandidatesForTab(tabId: number, inspection: PageInspectionState): Promise<InspectPageDataCandidateProbe[]> {
+  const candidateNames = [
+    ...(Array.isArray(inspection.suspiciousGlobals) ? inspection.suspiciousGlobals.map(String) : []),
+    ...(Array.isArray(inspection.globalsPreview) ? inspection.globalsPreview.map(String) : [])
+  ]
+    .filter((name, index, array) => /^[A-Za-z_$][\w$]*$/.test(name) && array.indexOf(name) === index)
+    .slice(0, 16);
   if (candidateNames.length === 0) {
     return [];
   }
 
-  const expr = `(() => {
-    const candidates = ${JSON.stringify(candidateNames)};
-    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') {
-          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;
-    };
-    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] };
-      }
-      return { resolver: 'lexical', value: globalThis.eval(name) };
+  const expr = `(() => {
+    const candidates = ${JSON.stringify(candidateNames)};
+    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 sampleValue = (value, depth = 0) => {
+      if (depth >= 2 || value == null || 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;
+    };
+    const readCandidate = (name) => {
+      if (name in globalThis) {
+        return { resolver: 'globalThis', value: globalThis[name] };
+      }
+      return { resolver: 'lexical', value: globalThis.eval(name) };
     };
     const results = [];
-    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
-        });
-      } catch {
-        // Ignore inaccessible candidates.
-      }
+    for (const name of candidates) {
+      try {
+        const resolved = readCandidate(name);
+        results.push({
+          name,
+          resolver: resolved.resolver,
+          sample: sampleValue(resolved.value)
+        });
+      } catch {
+        // Ignore inaccessible candidates.
+      }
     }
     return results;
   })()`;
-
-  try {
-    const evaluated = await executePageWorld<PageDataCandidateProbe[]>(tabId, 'eval', {
-      expr,
-      scope: 'current',
-      maxBytes: 64 * 1024
-    });
-    const frameResult = evaluated.result ?? evaluated.results?.find((candidate) => candidate.value || candidate.error);
-    return Array.isArray(frameResult?.value) ? frameResult.value : [];
-  } catch {
-    return [];
-  }
-}
+
+  try {
+    const evaluated = await executePageWorld<Array<{ name: string; resolver: 'globalThis' | 'lexical'; sample: unknown }>>(tabId, 'eval', {
+      expr,
+      scope: 'current',
+      maxBytes: 64 * 1024
+    });
+    const frameResult = evaluated.result ?? evaluated.results?.find((candidate) => candidate.value || candidate.error);
+    if (!Array.isArray(frameResult?.value)) {
+      return [];
+    }
+    return frameResult.value
+      .filter(
+        (candidate): candidate is { name: string; resolver: 'globalThis' | 'lexical'; sample: unknown } =>
+          typeof candidate === 'object' && candidate !== null && typeof candidate.name === 'string'
+      )
+      .map((candidate) => buildPageDataProbe(candidate.name, candidate.resolver, candidate.sample));
+  } catch {
+    return [];
+  }
+}
 
 async function buildFreshnessForTab(tabId: number, params: Record<string, unknown> = {}): Promise<PageFreshnessResult> {
   const inspection = await collectPageInspection(tabId, params);
@@ -1598,7 +1624,7 @@ async function buildFreshnessForTab(tabId: number, params: Record<string, unknow
   };
 }
 
-function summarizeNetworkCadence(entries: NetworkEntry[]): Record<string, unknown> {
+function summarizeNetworkCadence(entries: NetworkEntry[]): InspectLiveUpdatesResult['networkCadence'] {
   const relevant = entries
     .filter((entry) => entry.kind === 'fetch' || entry.kind === 'xhr')
     .slice()
@@ -1639,10 +1665,10 @@ function summarizeNetworkCadence(entries: NetworkEntry[]): Record<string, unknow
   };
 }
 
-function extractReplayRowsCandidate(json: unknown): { rows: unknown[]; source: string } | null {
-  if (Array.isArray(json)) {
-    return { rows: json, source: '$' };
-  }
+function extractReplayRowsCandidate(json: unknown): { rows: unknown[]; source: string } | null {
+  if (Array.isArray(json)) {
+    return { rows: json, source: '$' };
+  }
   if (typeof json !== 'object' || json === null) {
     return null;
   }
@@ -1652,71 +1678,77 @@ function extractReplayRowsCandidate(json: unknown): { rows: unknown[]; source: s
     if (Array.isArray(record[key])) {
       return { rows: record[key] as unknown[], source: `$.${key}` };
     }
-  }
-  return null;
-}
-
-async function enrichReplayWithSchema(tabId: number, response: PageFetchResponse): Promise<PageFetchResponse> {
-  const candidate = extractReplayRowsCandidate(response.json);
-  if (!candidate || candidate.rows.length === 0) {
-    return response;
-  }
-
-  const firstRow = candidate.rows[0];
-  const tablesResult = (await forwardContentRpc(tabId, 'table.list', {})) as { tables?: TableHandle[] };
-  const tables = Array.isArray(tablesResult.tables) ? tablesResult.tables : [];
-  if (tables.length === 0) {
-    return response;
-  }
-
-  const schemas: Array<{ table: TableHandle; schema: TableSchema }> = [];
-  for (const table of tables) {
-    const schemaResult = (await forwardContentRpc(tabId, 'table.schema', { table: table.id })) as {
-      table?: TableHandle;
-      schema?: TableSchema;
-    };
-    if (schemaResult.schema && Array.isArray(schemaResult.schema.columns)) {
-      schemas.push({ table: schemaResult.table ?? table, schema: schemaResult.schema });
-    }
-  }
-
-  if (schemas.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): row is unknown[] => Array.isArray(row))
-      .map((row) => {
-        const mapped: Record<string, unknown> = {};
-        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
-    };
-  }
-
-  if (typeof firstRow === 'object' && firstRow !== null) {
-    return {
-      ...response,
-      mappedRows: candidate.rows.filter((row): row is Record<string, unknown> => typeof row === 'object' && row !== null),
-      mappingSource: candidate.source
-    };
-  }
-
-  return response;
-}
+  }
+  return null;
+}
+
+async function collectTableAnalyses(tabId: number): Promise<TableAnalysis[]> {
+  const tablesResult = (await forwardContentRpc(tabId, 'table.list', {})) as { tables?: TableHandle[] };
+  const tables = Array.isArray(tablesResult.tables) ? tablesResult.tables : [];
+  const analyses: TableAnalysis[] = [];
+  for (const table of tables) {
+    const schemaResult = (await forwardContentRpc(tabId, 'table.schema', { table: table.id })) as {
+      table?: TableHandle;
+      schema?: TableSchema;
+    };
+    const rowsResult = (await forwardContentRpc(tabId, 'table.rows', {
+      table: table.id,
+      limit: 8
+    })) as {
+      table?: TableHandle;
+      rows?: Array<Record<string, unknown>>;
+    };
+    if (schemaResult.schema && Array.isArray(schemaResult.schema.columns)) {
+      analyses.push({
+        table: schemaResult.table ?? rowsResult.table ?? table,
+        schema: schemaResult.schema,
+        sampleRows: Array.isArray(rowsResult.rows) ? rowsResult.rows.slice(0, 8) : []
+      });
+    }
+  }
+  return analyses;
+}
+
+async function enrichReplayWithSchema(tabId: number, requestId: string, response: PageFetchResponse): Promise<PageFetchResponse> {
+  const candidate = extractReplayRowsCandidate(response.json);
+  if (!candidate || candidate.rows.length === 0) {
+    return response;
+  }
+
+  const tables = await collectTableAnalyses(tabId);
+  if (tables.length === 0) {
+    return response;
+  }
+
+  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,
+      table: matched.table,
+      schema: matched.schema,
+      mappedRows: matched.mappedRows,
+      mappingSource: matched.mappingSource
+    };
+  }
+
+  return response;
+}
 
 async function handleRequest(request: CliRequest): Promise<unknown> {
   const params = request.params ?? {};
@@ -2241,9 +2273,11 @@ async function handleRequest(request: CliRequest): Promise<unknown> {
         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': {
       return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
         const tab = await withTab(target);
@@ -2312,61 +2346,75 @@ async function handleRequest(request: CliRequest): Promise<unknown> {
         return filtered;
       });
     }
-    case 'inspect.pageData': {
-      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
-        const tab = await withTab(target);
-        await ensureNetworkDebugger(tab.id!).catch(() => undefined);
-        const inspection = await collectPageInspection(tab.id!, params);
-        const pageDataCandidates = await probePageDataCandidatesForTab(tab.id!, inspection);
-        const network = listNetworkEntries(tab.id!, { limit: 10 });
-        return {
-          suspiciousGlobals: inspection.suspiciousGlobals ?? [],
-          tables: inspection.tables ?? [],
-          visibleTimestamps: inspection.visibleTimestamps ?? [],
-          inlineTimestamps: inspection.inlineTimestamps ?? [],
-          pageDataCandidates,
-          recentNetwork: network,
-          recommendedNextSteps: [
-            'bak page extract --path table_data --resolver auto',
-            'bak network search --pattern table_data',
-            'bak page freshness'
-          ]
-        };
-      });
-    }
-    case 'inspect.liveUpdates': {
-      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
-        const tab = await withTab(target);
-        await ensureNetworkDebugger(tab.id!).catch(() => undefined);
-        const inspection = await collectPageInspection(tab.id!, params);
-        const network = listNetworkEntries(tab.id!, { limit: 25 });
-        return {
-          lastMutationAt: inspection.lastMutationAt ?? null,
-          timers: inspection.timers ?? { timeouts: 0, intervals: 0 },
-          networkCount: network.length,
-          networkCadence: summarizeNetworkCadence(network),
-          recentNetwork: network.slice(0, 10)
-        };
-      });
-    }
-    case 'inspect.freshness': {
-      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
-        const tab = await withTab(target);
-        const freshness = await buildFreshnessForTab(tab.id!, params);
-        return {
+    case 'inspect.pageData': {
+      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
+        const tab = await withTab(target);
+        await ensureNetworkDebugger(tab.id!).catch(() => undefined);
+        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 ?? [],
+          visibleTimestamps: inspection.visibleTimestamps ?? [],
+          inlineTimestamps: inspection.inlineTimestamps ?? [],
+          pageDataCandidates,
+          recentNetwork: network,
+          dataSources: enriched.dataSources,
+          sourceMappings: enriched.sourceMappings,
+          recommendedNextActions: enriched.recommendedNextActions,
+          recommendedNextSteps: [
+            ...recommendedNextSteps,
+            ...['bak page freshness'].filter((command) => !recommendedNextSteps.includes(command))
+          ]
+        } satisfies InspectPageDataResult;
+      });
+    }
+    case 'inspect.liveUpdates': {
+      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
+        const tab = await withTab(target);
+        await ensureNetworkDebugger(tab.id!).catch(() => undefined);
+        const inspection = await collectPageInspection(tab.id!, params);
+        const network = listNetworkEntries(tab.id!, { limit: 25 });
+        return {
+          lastMutationAt: inspection.lastMutationAt ?? null,
+          timers: inspection.timers ?? { timeouts: 0, intervals: 0 },
+          networkCount: network.length,
+          networkCadence: summarizeNetworkCadence(network),
+          recentNetwork: network.slice(0, 10)
+        } satisfies InspectLiveUpdatesResult;
+      });
+    }
+    case 'inspect.freshness': {
+      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
+        const tab = await withTab(target);
+        const freshness = await buildFreshnessForTab(tab.id!, params);
+        return {
           ...freshness,
           lagMs:
             typeof freshness.latestNetworkTimestamp === 'number' &&
             typeof (freshness.latestPageDataTimestamp ?? freshness.latestInlineDataTimestamp) === 'number'
               ? Math.max(
                   0,
-                  freshness.latestNetworkTimestamp -
-                    (freshness.latestPageDataTimestamp ?? freshness.latestInlineDataTimestamp ?? freshness.latestNetworkTimestamp)
-                )
-              : null
-        };
-      });
-    }
+                  freshness.latestNetworkTimestamp -
+                    (freshness.latestPageDataTimestamp ?? freshness.latestInlineDataTimestamp ?? freshness.latestNetworkTimestamp)
+                )
+              : null
+        } satisfies InspectFreshnessResult;
+      });
+    }
     case 'capture.snapshot': {
       return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
         const tab = await withTab(target);