@flrande/bak-extension 0.6.15 → 0.6.16

package/src/background.ts

@@ -25,18 +25,18 @@ import {
   clearNetworkEntries,
   dropNetworkCapture,
   ensureNetworkDebugger,
-  exportHar,
-  getNetworkEntry,
-  latestNetworkTimestamp,
-  listNetworkEntries,
-  recentNetworkSampleIds,
-  searchNetworkEntries,
-  waitForNetworkEntry
+  exportHar,
+  getNetworkEntry,
+  getReplayableNetworkRequest,
+  latestNetworkTimestamp,
+  listNetworkEntries,
+  recentNetworkSampleIds,
+  searchNetworkEntries,
+  waitForNetworkEntry
 } from './network-debugger.js';
 import { isSupportedAutomationUrl } from './url-policy.js';
 import { computeReconnectDelayMs } from './reconnect.js';
 import { resolveSessionBindingStateMap, STORAGE_KEY_SESSION_BINDINGS } from './session-binding-storage.js';
-import { containsRedactionMarker } from './privacy.js';
 import {
   type SessionBindingBrowser,
   type SessionBindingColor,
@@ -838,10 +838,18 @@ async function withTab(target: { tabId?: number; bindingId?: string } = {}, opti
   return validate(tab);
 }
 
-async function captureAlignedTabScreenshot(tab: chrome.tabs.Tab): Promise<string> {
-  if (typeof tab.id !== 'number' || typeof tab.windowId !== 'number') {
-    throw toError('E_NOT_FOUND', 'Tab screenshot requires tab id and window id');
-  }
+async function captureAlignedTabScreenshot(tab: chrome.tabs.Tab): Promise<{
+  captureStatus: 'complete' | 'degraded' | 'skipped';
+  imageData?: string;
+  captureError?: {
+    code?: string;
+    message: string;
+    details?: Record<string, unknown>;
+  };
+}> {
+  if (typeof tab.id !== 'number' || typeof tab.windowId !== 'number') {
+    throw toError('E_NOT_FOUND', 'Tab screenshot requires tab id and window id');
+  }
 
   const activeTabs = await chrome.tabs.query({ windowId: tab.windowId, active: true });
   const activeTab = activeTabs[0];
@@ -851,13 +859,24 @@ async function captureAlignedTabScreenshot(tab: chrome.tabs.Tab): Promise<string
     await chrome.tabs.update(tab.id, { active: true });
     await new Promise((resolve) => setTimeout(resolve, 80));
   }
-
-  try {
-    return await chrome.tabs.captureVisibleTab(tab.windowId, { format: 'png' });
-  } finally {
-    if (shouldSwitch && typeof activeTab?.id === 'number') {
-      try {
-        await chrome.tabs.update(activeTab.id, { active: true });
+
+  try {
+    return {
+      captureStatus: 'complete',
+      imageData: await chrome.tabs.captureVisibleTab(tab.windowId, { format: 'png' })
+    };
+  } catch (error) {
+    return {
+      captureStatus: 'degraded',
+      captureError: {
+        code: 'E_CAPTURE_FAILED',
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  } finally {
+    if (shouldSwitch && typeof activeTab?.id === 'number') {
+      try {
+        await chrome.tabs.update(activeTab.id, { active: true });
       } catch {
         // Ignore restore errors if the original tab no longer exists.
       }
@@ -1012,10 +1031,10 @@ async function executePageWorld<T>(
     target,
     world: 'MAIN',
     args: [
-      {
-        action,
-        scope,
-        framePath,
+      {
+        action,
+        scope,
+        framePath,
         expr: typeof params.expr === 'string' ? params.expr : '',
         path: typeof params.path === 'string' ? params.path : '',
         resolver: typeof params.resolver === 'string' ? params.resolver : undefined,
@@ -1023,13 +1042,15 @@ async function executePageWorld<T>(
         method: typeof params.method === 'string' ? params.method : 'GET',
         headers: typeof params.headers === 'object' && params.headers !== null ? params.headers : undefined,
         body: typeof params.body === 'string' ? params.body : undefined,
-        contentType: typeof params.contentType === 'string' ? params.contentType : undefined,
-        mode: params.mode === 'json' ? 'json' : 'raw',
-        maxBytes: typeof params.maxBytes === 'number' ? params.maxBytes : undefined,
-        timeoutMs: typeof params.timeoutMs === 'number' ? params.timeoutMs : undefined
-      }
-    ],
-    func: async (payload) => {
+        contentType: typeof params.contentType === 'string' ? params.contentType : undefined,
+        mode: params.mode === 'json' ? 'json' : 'raw',
+        maxBytes: typeof params.maxBytes === 'number' ? params.maxBytes : undefined,
+        timeoutMs: typeof params.timeoutMs === 'number' ? params.timeoutMs : undefined,
+        fullResponse: params.fullResponse === true,
+        auth: params.auth === 'manual' || params.auth === 'off' ? params.auth : 'auto'
+      }
+    ],
+    func: async (payload) => {
       const serializeValue = (value: unknown, maxBytes?: number) => {
         let cloned: unknown;
         try {
@@ -1129,10 +1150,10 @@ async function executePageWorld<T>(
         return current;
       };
 
-      const resolveExtractValue = (
-        targetWindow: Window & { eval: (expr: string) => unknown },
-        path: string,
-        resolver: unknown
+      const resolveExtractValue = (
+        targetWindow: Window & { eval: (expr: string) => unknown },
+        path: string,
+        resolver: unknown
       ): { resolver: 'globalThis' | 'lexical'; value: unknown } => {
         const strategy = resolver === 'globalThis' || resolver === 'lexical' ? resolver : 'auto';
         const lexicalExpression = buildPathExpression(path);
@@ -1159,11 +1180,82 @@ async function executePageWorld<T>(
             throw error;
           }
         }
-        return { resolver: 'lexical', value: readLexical() };
-      };
-
-      try {
-        const targetWindow = payload.scope === 'main' ? window : payload.scope === 'current' ? resolveFrameWindow(payload.framePath ?? []) : window;
+        return { resolver: 'lexical', value: readLexical() };
+      };
+
+      const findHeaderName = (headers: Record<string, string>, name: string): string | undefined =>
+        Object.keys(headers).find((key) => key.toLowerCase() === name.toLowerCase());
+
+      const findCookieValue = (cookieString: string, name: string): string | undefined => {
+        const targetName = `${name}=`;
+        for (const segment of cookieString.split(';')) {
+          const trimmed = segment.trim();
+          if (trimmed.toLowerCase().startsWith(targetName.toLowerCase())) {
+            return trimmed.slice(targetName.length);
+          }
+        }
+        return undefined;
+      };
+
+      const buildJsonSummary = (
+        value: unknown
+      ): { schema?: { columns: Array<{ key: string; label: string }> }; mappedRows?: Array<Record<string, unknown>> } => {
+        const rowsCandidate = (() => {
+          if (Array.isArray(value)) {
+            return value;
+          }
+          if (typeof value !== 'object' || value === null) {
+            return null;
+          }
+          const record = value as Record<string, unknown>;
+          for (const key of ['data', 'rows', 'results', 'items']) {
+            if (Array.isArray(record[key])) {
+              return record[key] as unknown[];
+            }
+          }
+          return null;
+        })();
+        if (Array.isArray(rowsCandidate) && rowsCandidate.length > 0) {
+          const objectRows = rowsCandidate
+            .filter((row): row is Record<string, unknown> => typeof row === 'object' && row !== null && !Array.isArray(row))
+            .slice(0, 25);
+          if (objectRows.length > 0) {
+            const columns = [...new Set(objectRows.flatMap((row) => Object.keys(row)))].slice(0, 20);
+            return {
+              schema: {
+                columns: columns.map((label, index) => ({
+                  key: `col_${index + 1}`,
+                  label
+                }))
+              },
+              mappedRows: objectRows.map((row) => {
+                const mapped: Record<string, unknown> = {};
+                for (const column of columns) {
+                  mapped[column] = row[column];
+                }
+                return mapped;
+              })
+            };
+          }
+        }
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+          const columns = Object.keys(value as Record<string, unknown>).slice(0, 20);
+          if (columns.length > 0) {
+            return {
+              schema: {
+                columns: columns.map((label, index) => ({
+                  key: `col_${index + 1}`,
+                  label
+                }))
+              }
+            };
+          }
+        }
+        return {};
+      };
+
+      try {
+        const targetWindow = payload.scope === 'main' ? window : payload.scope === 'current' ? resolveFrameWindow(payload.framePath ?? []) : window;
         if (payload.action === 'eval') {
           const evaluator = (targetWindow as Window & { eval: (expr: string) => unknown }).eval;
           const serialized = serializeValue(evaluator(payload.expr), payload.maxBytes);
@@ -1179,14 +1271,53 @@ async function executePageWorld<T>(
             bytes: serialized.bytes,
             resolver: extracted.resolver
           };
-        }
-        if (payload.action === 'fetch') {
-          const headers = { ...(payload.headers ?? {}) } as Record<string, string>;
-          if (payload.contentType && !headers['Content-Type']) {
-            headers['Content-Type'] = payload.contentType;
-          }
-          const controller = typeof AbortController === 'function' ? new AbortController() : null;
-          const timeoutId =
+        }
+        if (payload.action === 'fetch') {
+          const headers = { ...(payload.headers ?? {}) } as Record<string, string>;
+          if (payload.contentType && !findHeaderName(headers, 'Content-Type')) {
+            headers['Content-Type'] = payload.contentType;
+          }
+          const fullResponse = payload.fullResponse === true;
+          const authApplied: string[] = [];
+          const authSources = new Set<string>();
+          const requestUrl = new URL(payload.url, targetWindow.location.href);
+          const sameOrigin = requestUrl.origin === targetWindow.location.origin;
+          const authMode = payload.auth === 'manual' || payload.auth === 'off' ? payload.auth : 'auto';
+          const maybeApplyHeader = (name: string, value: string | undefined, source: string): void => {
+            if (!value || findHeaderName(headers, name)) {
+              return;
+            }
+            headers[name] = value;
+            authApplied.push(name);
+            authSources.add(source);
+          };
+          if (sameOrigin && authMode === 'auto') {
+            const xsrfCookie = findCookieValue(targetWindow.document.cookie ?? '', 'XSRF-TOKEN');
+            if (xsrfCookie) {
+              maybeApplyHeader('X-XSRF-TOKEN', decodeURIComponent(xsrfCookie), 'cookie:XSRF-TOKEN');
+            }
+            const metaTokens = [
+              {
+                selector: 'meta[name="xsrf-token"], meta[name="x-xsrf-token"]',
+                header: 'X-XSRF-TOKEN',
+                source: 'meta:xsrf-token'
+              },
+              {
+                selector: 'meta[name="csrf-token"], meta[name="csrf_token"], meta[name="_csrf"]',
+                header: 'X-CSRF-TOKEN',
+                source: 'meta:csrf-token'
+              }
+            ];
+            for (const token of metaTokens) {
+              const meta = targetWindow.document.querySelector<HTMLMetaElement>(token.selector);
+              const content = meta?.content?.trim();
+              if (content) {
+                maybeApplyHeader(token.header, content, token.source);
+              }
+            }
+          }
+          const controller = typeof AbortController === 'function' ? new AbortController() : null;
+          const timeoutId =
             controller && typeof payload.timeoutMs === 'number' && payload.timeoutMs > 0
               ? window.setTimeout(() => controller.abort(), payload.timeoutMs)
               : null;
@@ -1211,43 +1342,56 @@ async function executePageWorld<T>(
           return {
             url: targetWindow.location.href,
             framePath: payload.scope === 'current' ? payload.framePath ?? [] : [],
-            value: (() => {
-              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;
-              if (payload.mode === 'json' && truncated) {
-                throw {
-                  code: 'E_BODY_TOO_LARGE',
-                  message: 'JSON response exceeds max-bytes',
-                  details: {
-                    bytes: bodyBytes,
-                    maxBytes: previewLimit
-                  }
-                };
-              }
-              const previewText =
-                encodedBody && decoder
-                  ? decoder.decode(encodedBody.subarray(0, Math.min(encodedBody.byteLength, previewLimit)))
-                  : truncated
-                    ? bodyText.slice(0, previewLimit)
-                    : bodyText;
-              return {
-                url: response.url,
-                status: response.status,
-                ok: response.ok,
-                headers: headerMap,
-                contentType: response.headers.get('content-type') ?? undefined,
-                bodyText: payload.mode === 'json' ? undefined : previewText,
-                json: payload.mode === 'json' && bodyText ? JSON.parse(bodyText) : undefined,
-                bytes: bodyBytes,
-                truncated
-              };
-            })()
-          };
-        }
+            value: (() => {
+              const encoder = typeof TextEncoder === 'function' ? new TextEncoder() : null;
+              const decoder = typeof TextDecoder === 'function' ? new TextDecoder() : null;
+              const previewLimit = !fullResponse && 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 = !fullResponse && bodyBytes > previewLimit;
+              const previewText =
+                fullResponse
+                  ? bodyText
+                  : encodedBody && decoder
+                  ? decoder.decode(encodedBody.subarray(0, Math.min(encodedBody.byteLength, previewLimit)))
+                  : truncated
+                    ? bodyText.slice(0, previewLimit)
+                    : bodyText;
+              const result: Record<string, unknown> = {
+                url: response.url,
+                status: response.status,
+                ok: response.ok,
+                headers: headerMap,
+                contentType: response.headers.get('content-type') ?? undefined,
+                bytes: bodyBytes,
+                truncated,
+                authApplied: authApplied.length > 0 ? authApplied : undefined,
+                authSources: authSources.size > 0 ? [...authSources] : undefined
+              };
+              if (payload.mode === 'json') {
+                const parsedJson = bodyText ? JSON.parse(bodyText) : undefined;
+                const summary = buildJsonSummary(parsedJson);
+                if (fullResponse || !truncated) {
+                  result.json = parsedJson;
+                } else {
+                  result.degradedReason = 'response body exceeded max-bytes and was summarized';
+                }
+                if (summary.schema) {
+                  result.schema = summary.schema;
+                }
+                if (summary.mappedRows) {
+                  result.mappedRows = summary.mappedRows;
+                }
+              } else {
+                result.bodyText = previewText;
+                if (truncated) {
+                  result.degradedReason = 'response body exceeded max-bytes and was truncated';
+                }
+              }
+              return result;
+            })()
+          };
+        }
         throw { code: 'E_NOT_FOUND', message: `Unsupported page world action: ${payload.action}` };
       } catch (error) {
         return {
@@ -1327,23 +1471,20 @@ function filterNetworkEntrySections(entry: NetworkEntry, include: unknown): Netw
   return clone;
 }
 
-function replayHeadersFromEntry(entry: NetworkEntry): Record<string, string> | undefined {
-  if (!entry.requestHeaders) {
-    return undefined;
-  }
-  const headers: Record<string, string> = {};
-  for (const [name, value] of Object.entries(entry.requestHeaders)) {
-    const normalizedName = name.toLowerCase();
-    if (REPLAY_FORBIDDEN_HEADER_NAMES.has(normalizedName) || normalizedName.startsWith('sec-')) {
-      continue;
-    }
-    if (containsRedactionMarker(value)) {
-      continue;
-    }
-    headers[name] = value;
-  }
-  return Object.keys(headers).length > 0 ? headers : undefined;
-}
+function replayHeadersFromRequestHeaders(requestHeaders: Record<string, string> | undefined): Record<string, string> | undefined {
+  if (!requestHeaders) {
+    return undefined;
+  }
+  const headers: Record<string, string> = {};
+  for (const [name, value] of Object.entries(requestHeaders)) {
+    const normalizedName = name.toLowerCase();
+    if (REPLAY_FORBIDDEN_HEADER_NAMES.has(normalizedName) || normalizedName.startsWith('sec-')) {
+      continue;
+    }
+    headers[name] = value;
+  }
+  return Object.keys(headers).length > 0 ? headers : undefined;
+}
 
 function collectTimestampMatchesFromText(text: string, source: TimestampEvidenceCandidate['source'], patterns?: string[]): TimestampEvidenceCandidate[] {
   const regexes = (
@@ -1461,7 +1602,7 @@ function latestTimestampFromCandidates(
   return latest;
 }
 
-function computeFreshnessAssessment(input: {
+function computeFreshnessAssessment(input: {
   latestInlineDataTimestamp: number | null;
   latestPageDataTimestamp: number | null;
   latestNetworkDataTimestamp: number | null;
@@ -1498,10 +1639,79 @@ function computeFreshnessAssessment(input: {
     .filter((value): value is number => typeof value === 'number');
   if (staleSignals.length > 0 && staleSignals.every((value) => now - value > input.staleWindowMs)) {
     return 'stale';
-  }
-  return 'unknown';
-}
-
+  }
+  return 'unknown';
+}
+
+function freshnessCategoryPriority(category: PageFreshnessResult['evidence']['classifiedTimestamps'][number]['category']): number {
+  switch (category) {
+    case 'data':
+      return 0;
+    case 'unknown':
+      return 1;
+    case 'event':
+      return 2;
+    case 'contract':
+      return 3;
+    default:
+      return 4;
+  }
+}
+
+function freshnessSourcePriority(source: PageFreshnessResult['evidence']['classifiedTimestamps'][number]['source']): number {
+  switch (source) {
+    case 'network':
+      return 0;
+    case 'page-data':
+      return 1;
+    case 'visible':
+      return 2;
+    case 'inline':
+      return 3;
+    default:
+      return 4;
+  }
+}
+
+function rankFreshnessEvidence(
+  candidates: PageFreshnessResult['evidence']['classifiedTimestamps'],
+  now = Date.now()
+): PageFreshnessResult['evidence']['classifiedTimestamps'] {
+  return candidates
+    .slice()
+    .sort((left, right) => {
+      const byCategory = freshnessCategoryPriority(left.category) - freshnessCategoryPriority(right.category);
+      if (byCategory !== 0) {
+        return byCategory;
+      }
+      const bySource = freshnessSourcePriority(left.source) - freshnessSourcePriority(right.source);
+      if (bySource !== 0) {
+        return bySource;
+      }
+      const leftTimestamp = parseTimestampCandidate(left.value, now) ?? Number.NEGATIVE_INFINITY;
+      const rightTimestamp = parseTimestampCandidate(right.value, now) ?? Number.NEGATIVE_INFINITY;
+      if (leftTimestamp !== rightTimestamp) {
+        return rightTimestamp - leftTimestamp;
+      }
+      return left.value.localeCompare(right.value);
+    });
+}
+
+function deriveFreshnessConfidence(
+  primary: PageFreshnessResult['evidence']['classifiedTimestamps'][number] | null
+): PageFreshnessResult['confidence'] {
+  if (!primary) {
+    return 'low';
+  }
+  if (primary.category === 'data' && (primary.source === 'network' || primary.source === 'page-data')) {
+    return 'high';
+  }
+  if (primary.category === 'data') {
+    return 'medium';
+  }
+  return 'low';
+}
+
 async function collectPageInspection(tabId: number, params: Record<string, unknown> = {}): Promise<PageInspectionState> {
   return (await forwardContentRpc(tabId, 'bak.internal.inspectState', params)) as PageInspectionState;
 }
@@ -1647,24 +1857,32 @@ async function buildFreshnessForTab(tabId: number, params: Record<string, unknow
     now
   );
   const latestInlineDataTimestamp = latestTimestampFromCandidates(inlineCandidates, now);
-  const latestPageDataTimestamp = latestTimestampFromCandidates(pageDataCandidates, now);
-  const latestNetworkDataTimestamp = latestTimestampFromCandidates(networkCandidates, now);
-  const domVisibleTimestamp = latestTimestampFromCandidates(visibleCandidates, now);
-  const latestNetworkTs = latestNetworkTimestamp(tabId);
-  const lastMutationAt = typeof inspection.lastMutationAt === 'number' ? inspection.lastMutationAt : null;
-  const allCandidates = [...visibleCandidates, ...inlineCandidates, ...pageDataCandidates, ...networkCandidates];
-  return {
-    pageLoadedAt: typeof inspection.pageLoadedAt === 'number' ? inspection.pageLoadedAt : null,
-    lastMutationAt,
-    latestNetworkTimestamp: latestNetworkTs,
-    latestInlineDataTimestamp,
-    latestPageDataTimestamp,
-    latestNetworkDataTimestamp,
-    domVisibleTimestamp,
-    assessment: computeFreshnessAssessment({
-      latestInlineDataTimestamp,
-      latestPageDataTimestamp,
-      latestNetworkDataTimestamp,
+  const latestPageDataTimestamp = latestTimestampFromCandidates(pageDataCandidates, now);
+  const latestNetworkDataTimestamp = latestTimestampFromCandidates(networkCandidates, now);
+  const domVisibleTimestamp = latestTimestampFromCandidates(visibleCandidates, now);
+  const latestNetworkTs = latestNetworkTimestamp(tabId);
+  const lastMutationAt = typeof inspection.lastMutationAt === 'number' ? inspection.lastMutationAt : null;
+  const allCandidates = rankFreshnessEvidence([...visibleCandidates, ...inlineCandidates, ...pageDataCandidates, ...networkCandidates], now);
+  const primaryEvidence =
+    allCandidates.find((candidate) => parseTimestampCandidate(candidate.value, now) !== null) ?? null;
+  const primaryTimestamp = primaryEvidence ? parseTimestampCandidate(primaryEvidence.value, now) : null;
+  return {
+    pageLoadedAt: typeof inspection.pageLoadedAt === 'number' ? inspection.pageLoadedAt : null,
+    lastMutationAt,
+    latestNetworkTimestamp: latestNetworkTs,
+    latestInlineDataTimestamp,
+    latestPageDataTimestamp,
+    latestNetworkDataTimestamp,
+    domVisibleTimestamp,
+    primaryTimestamp,
+    primaryCategory: primaryEvidence?.category ?? null,
+    primarySource: primaryEvidence?.source ?? null,
+    confidence: deriveFreshnessConfidence(primaryEvidence),
+    suppressedEvidenceCount: Math.max(0, allCandidates.length - (primaryEvidence ? 1 : 0)),
+    assessment: computeFreshnessAssessment({
+      latestInlineDataTimestamp,
+      latestPageDataTimestamp,
+      latestNetworkDataTimestamp,
       latestNetworkTimestamp: latestNetworkTs,
       domVisibleTimestamp,
       lastMutationAt,
@@ -1673,10 +1891,10 @@ async function buildFreshnessForTab(tabId: number, params: Record<string, unknow
     }),
     evidence: {
       visibleTimestamps: visibleCandidates.map((candidate) => candidate.value),
-      inlineTimestamps: inlineCandidates.map((candidate) => candidate.value),
-      pageDataTimestamps: pageDataCandidates.map((candidate) => candidate.value),
-      networkDataTimestamps: networkCandidates.map((candidate) => candidate.value),
-      classifiedTimestamps: allCandidates,
+      inlineTimestamps: inlineCandidates.map((candidate) => candidate.value),
+      pageDataTimestamps: pageDataCandidates.map((candidate) => candidate.value),
+      networkDataTimestamps: networkCandidates.map((candidate) => candidate.value),
+      classifiedTimestamps: allCandidates,
       networkSampleIds: recentNetworkSampleIds(tabId)
     }
   };
@@ -2109,32 +2327,37 @@ async function handleRequest(request: CliRequest): Promise<unknown> {
         return await executePageWorld(tab.id!, 'extract', params);
       });
     }
-    case 'page.fetch': {
-      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
-        const tab = await withTab(target);
-        return await executePageWorld<PageFetchResponse>(tab.id!, 'fetch', params);
-      });
-    }
-    case 'page.snapshot': {
-      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
-        const tab = await withTab(target);
-        if (typeof tab.id !== 'number' || typeof tab.windowId !== 'number') {
-          throw toError('E_NOT_FOUND', 'Tab missing id');
-        }
-        const includeBase64 = params.includeBase64 !== false;
-        const config = await getConfig();
-        const elements = await sendToContent<{ elements: unknown[] }>(tab.id, {
-          type: 'bak.collectElements',
-          debugRichText: config.debugRichText
-        });
-        const imageData = await captureAlignedTabScreenshot(tab);
-        return {
-          imageBase64: includeBase64 ? imageData.replace(/^data:image\/png;base64,/, '') : '',
-          elements: elements.elements,
-          tabId: tab.id,
-          url: tab.url ?? ''
-        };
-      });
+    case 'page.fetch': {
+      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
+        const tab = await withTab(target);
+        return await executePageWorld<PageFetchResponse>(tab.id!, 'fetch', params);
+      });
+    }
+    case 'page.snapshot': {
+      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
+        const tab = await withTab(target);
+        if (typeof tab.id !== 'number' || typeof tab.windowId !== 'number') {
+          throw toError('E_NOT_FOUND', 'Tab missing id');
+        }
+        const includeBase64 = params.includeBase64 !== false;
+        const config = await getConfig();
+        const elements = await sendToContent<{ elements: unknown[] }>(tab.id, {
+          type: 'bak.collectElements',
+          debugRichText: config.debugRichText
+        });
+        const screenshot = params.capture === false ? { captureStatus: 'skipped' as const } : await captureAlignedTabScreenshot(tab);
+        return {
+          captureStatus: screenshot.captureStatus,
+          captureError: screenshot.captureError,
+          imageBase64:
+            includeBase64 && typeof screenshot.imageData === 'string'
+              ? screenshot.imageData.replace(/^data:image\/png;base64,/, '')
+              : undefined,
+          elements: elements.elements,
+          tabId: tab.id,
+          url: tab.url ?? ''
+        };
+      });
     }
     case 'element.click': {
       return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
@@ -2249,19 +2472,13 @@ async function handleRequest(request: CliRequest): Promise<unknown> {
         }
       });
     }
-    case 'network.search': {
-      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
-        const tab = await withTab(target);
-        await ensureTabNetworkCapture(tab.id!);
-        return {
-          entries: searchNetworkEntries(
-            tab.id!,
-            String(params.pattern ?? ''),
-            typeof params.limit === 'number' ? params.limit : 50
-          )
-        };
-      });
-    }
+    case 'network.search': {
+      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
+        const tab = await withTab(target);
+        await ensureTabNetworkCapture(tab.id!);
+        return searchNetworkEntries(tab.id!, String(params.pattern ?? ''), typeof params.limit === 'number' ? params.limit : 50);
+      });
+    }
     case 'network.waitFor': {
       return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
         const tab = await withTab(target);
@@ -2289,48 +2506,52 @@ async function handleRequest(request: CliRequest): Promise<unknown> {
         return { ok: true };
       });
     }
-    case 'network.replay': {
-      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
-        const tab = await withTab(target);
-        await ensureTabNetworkCapture(tab.id!);
-        const entry = getNetworkEntry(tab.id!, String(params.id ?? ''));
-        if (!entry) {
-          throw toError('E_NOT_FOUND', `network entry not found: ${String(params.id ?? '')}`);
-        }
-        if (entry.requestBodyTruncated === true) {
-          throw toError('E_BODY_TOO_LARGE', 'captured request body was truncated and cannot be replayed safely', {
-            requestId: entry.id,
-            requestBytes: entry.requestBytes
-          });
-        }
-        if (containsRedactionMarker(entry.requestBodyPreview)) {
-          throw toError('E_EXECUTION', 'captured request body was redacted and cannot be replayed safely', {
-            requestId: entry.id
-          });
-        }
-        const replayed = await executePageWorld<PageFetchResponse>(tab.id!, 'fetch', {
-          url: entry.url,
-          method: entry.method,
-          headers: replayHeadersFromEntry(entry),
-          body: entry.requestBodyPreview,
-          contentType: (() => {
-            const requestHeaders = entry.requestHeaders ?? {};
-            const contentTypeHeader = Object.keys(requestHeaders).find((name) => name.toLowerCase() === 'content-type');
-            return contentTypeHeader ? requestHeaders[contentTypeHeader] : undefined;
-          })(),
-          mode: params.mode,
-          timeoutMs: params.timeoutMs,
-          maxBytes: params.maxBytes,
-          scope: 'current'
-        });
-        const frameResult = replayed.result ?? replayed.results?.find((candidate) => candidate.value || candidate.error);
-        if (frameResult?.error) {
-          throw toError(frameResult.error.code ?? 'E_EXECUTION', frameResult.error.message, frameResult.error.details);
-        }
-        const first = frameResult?.value;
-        if (!first) {
-          throw toError('E_EXECUTION', 'network replay returned no response payload');
-        }
+    case 'network.replay': {
+      return await preserveHumanFocus(typeof target.tabId !== 'number', async () => {
+        const tab = await withTab(target);
+        await ensureTabNetworkCapture(tab.id!);
+        const replayable = getReplayableNetworkRequest(tab.id!, String(params.id ?? ''));
+        if (!replayable) {
+          throw toError('E_NOT_FOUND', `network entry not found: ${String(params.id ?? '')}`);
+        }
+        if (replayable.degradedReason) {
+          return {
+            url: replayable.entry.url,
+            status: 0,
+            ok: false,
+            headers: {},
+            bytes: replayable.entry.requestBytes,
+            truncated: true,
+            degradedReason: replayable.degradedReason
+          } satisfies PageFetchResponse;
+        }
+        const replayed = await executePageWorld<PageFetchResponse>(tab.id!, 'fetch', {
+          url: replayable.entry.url,
+          method: replayable.entry.method,
+          headers: replayHeadersFromRequestHeaders(replayable.headers),
+          body: replayable.body,
+          contentType: replayable.contentType,
+          mode: params.mode,
+          timeoutMs: params.timeoutMs,
+          maxBytes: params.maxBytes,
+          fullResponse: params.fullResponse === true,
+          auth: params.auth,
+          scope: 'current'
+        });
+        const frameResult = replayed.result ?? replayed.results?.find((candidate) => candidate.value || candidate.error);
+        if (frameResult?.error) {
+          throw toError(frameResult.error.code ?? 'E_EXECUTION', frameResult.error.message, frameResult.error.details);
+        }
+        const first = frameResult?.value;
+        if (!first) {
+          return {
+            url: replayable.entry.url,
+            status: 0,
+            ok: false,
+            headers: {},
+            degradedReason: 'network replay returned no response payload'
+          } satisfies PageFetchResponse;
+        }
         return params.withSchema === 'auto' && params.mode === 'json'
           ? await enrichReplayWithSchema(tab.id!, String(params.id ?? ''), first)
           : first;