@flrande/bak-extension 0.6.15 → 0.6.17

package/dist/background.global.js

@@ -302,7 +302,7 @@
         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());
+    const explicitReferenceHit = table.table.label.toLowerCase().includes(source.source.label.toLowerCase()) || (table.table.selector ?? "").toLowerCase().includes(source.source.label.toLowerCase()) || source.source.label.toLowerCase().includes(table.table.label.toLowerCase());
     if (explicitReferenceHit) {
       basis.push({
         type: "explicitReference",
@@ -360,8 +360,8 @@
       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`,
+          title: `Clone ${requestId} into a reusable fetch template`,
+          command: `bak network clone ${requestId}`,
           note: `Recent response mapped to ${mapping.tableId} with ${mapping.confidence} confidence.`
         });
         continue;
@@ -381,6 +381,96 @@
     }
     return recommendations.slice(0, 6);
   }
+  function confidenceRank(confidence) {
+    switch (confidence) {
+      case "high":
+        return 0;
+      case "medium":
+        return 1;
+      case "low":
+        return 2;
+      default:
+        return 3;
+    }
+  }
+  function isSameOrigin(pageUrl, requestUrl) {
+    if (!pageUrl) {
+      return false;
+    }
+    try {
+      const page = new URL(pageUrl);
+      const request = new URL(requestUrl, page);
+      return page.origin === request.origin;
+    } catch {
+      return false;
+    }
+  }
+  function selectPrimaryEndpoint(recentNetwork, mappings, pageUrl) {
+    const mapped = mappings.filter((mapping) => mapping.sourceId.startsWith("networkResponse:")).map((mapping) => ({
+      mapping,
+      entry: recentNetwork.find((entry) => entry.id === mapping.sourceId.replace(/^networkResponse:/, ""))
+    })).filter((candidate) => candidate.entry !== void 0).sort((left, right) => {
+      return confidenceRank(left.mapping.confidence) - confidenceRank(right.mapping.confidence) || right.entry.ts - left.entry.ts || left.entry.id.localeCompare(right.entry.id);
+    })[0];
+    if (mapped) {
+      return {
+        requestId: mapped.entry.id,
+        url: mapped.entry.url,
+        method: mapped.entry.method,
+        status: mapped.entry.status,
+        kind: mapped.entry.kind,
+        resourceType: mapped.entry.resourceType,
+        contentType: mapped.entry.contentType,
+        sameOrigin: isSameOrigin(pageUrl, mapped.entry.url),
+        matchedTableId: mapped.mapping.tableId,
+        matchedSourceId: mapped.mapping.sourceId,
+        reason: `Mapped to ${mapped.mapping.tableId} with ${mapped.mapping.confidence} confidence`
+      };
+    }
+    const fallback = recentNetwork.filter((entry) => (entry.kind === "fetch" || entry.kind === "xhr") && entry.status >= 200 && entry.status < 400).sort((left, right) => right.ts - left.ts)[0];
+    if (!fallback) {
+      return null;
+    }
+    return {
+      requestId: fallback.id,
+      url: fallback.url,
+      method: fallback.method,
+      status: fallback.status,
+      kind: fallback.kind,
+      resourceType: fallback.resourceType,
+      contentType: fallback.contentType,
+      sameOrigin: isSameOrigin(pageUrl, fallback.url),
+      reason: `Latest successful ${fallback.kind.toUpperCase()} request observed on the page`
+    };
+  }
+  function summarizeAvailableModes(modeGroups) {
+    return [...new Set(modeGroups.flatMap((group) => group.options.map((option) => option.label)))];
+  }
+  function selectCurrentMode(modeGroups) {
+    for (const group of modeGroups) {
+      const selected = group.options.find((option) => option.selected);
+      if (selected) {
+        return {
+          controlType: group.controlType,
+          label: selected.label,
+          value: selected.value,
+          groupLabel: group.label
+        };
+      }
+    }
+    return null;
+  }
+  function deriveLatestArchiveDate(dateControls) {
+    const candidates = dateControls.flatMap((control) => [
+      control.value,
+      control.min,
+      control.max,
+      control.dataMaxDate,
+      ...Array.isArray(control.options) ? control.options : []
+    ]);
+    const dated = candidates.filter((value) => typeof value === "string").map((value) => ({ value, parsed: Date.parse(value) })).filter((item) => Number.isFinite(item.parsed)).sort((left, right) => right.parsed - left.parsed);
+    return dated[0]?.value ?? null;
+  }
   function buildSourceMappingReport(input) {
     const now = typeof input.now === "number" ? input.now : Date.now();
     const windowAnalyses = buildWindowSources(input.windowSources);
@@ -388,14 +478,15 @@
     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);
+      const confidenceRank2 = { high: 0, medium: 1, low: 2 };
+      return confidenceRank2[left.confidence] - confidenceRank2[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
+      sourceAnalyses,
+      primaryEndpoint: selectPrimaryEndpoint(input.recentNetwork, sourceMappings, input.pageUrl)
     };
   }
   function mapObjectRowToSchema(row, schema) {
@@ -473,12 +564,17 @@
       windowSources: input.pageDataCandidates,
       inlineJsonSources: input.inlineJsonSources,
       recentNetwork: input.recentNetwork,
+      pageUrl: input.pageUrl,
       now: input.now
     });
     return {
       dataSources: report.dataSources,
       sourceMappings: report.sourceMappings,
-      recommendedNextActions: report.recommendedNextActions
+      recommendedNextActions: report.recommendedNextActions,
+      availableModes: summarizeAvailableModes(input.modeGroups),
+      currentMode: selectCurrentMode(input.modeGroups),
+      latestArchiveDate: deriveLatestArchiveDate(input.dateControls),
+      primaryEndpoint: report.primaryEndpoint
     };
   }
   function buildPageDataProbe(name, resolver, sample) {
@@ -533,9 +629,6 @@
   function shouldRedactHeader(name) {
     return SENSITIVE_HEADER_PATTERNS.some((pattern) => pattern.test(name));
   }
-  function containsRedactionMarker(raw) {
-    return typeof raw === "string" && raw.includes("[REDACTED");
-  }
   function redactTransportText(raw) {
     if (!raw) {
       return "";
@@ -553,10 +646,159 @@
     return Object.keys(result).length > 0 ? result : void 0;
   }
 
+  // src/network-tools.ts
+  var ROW_CANDIDATE_KEYS2 = ["data", "rows", "results", "items", "records", "entries"];
+  var SUMMARY_TEXT_LIMIT = 96;
+  function truncateSummaryText(value, limit = SUMMARY_TEXT_LIMIT) {
+    const normalized = value.replace(/\s+/g, " ").trim();
+    if (normalized.length <= limit) {
+      return normalized;
+    }
+    return `${normalized.slice(0, Math.max(1, limit - 1)).trimEnd()}...`;
+  }
+  function safeParseUrl(urlText) {
+    try {
+      return new URL(urlText);
+    } catch {
+      try {
+        return new URL(urlText, "http://127.0.0.1");
+      } catch {
+        return null;
+      }
+    }
+  }
+  function looksLikeFormBody(value) {
+    return value.includes("=") && (value.includes("&") || !value.trim().startsWith("{"));
+  }
+  function summarizeSearchParams(params) {
+    const entries = [];
+    params.forEach((value, key) => {
+      entries.push([key, value]);
+    });
+    if (entries.length === 0) {
+      return void 0;
+    }
+    const preview = entries.slice(0, 4).map(([key, value]) => `${key}=${truncateSummaryText(value, 32)}`);
+    return entries.length > 4 ? `${preview.join(", ")} ...` : preview.join(", ");
+  }
+  function summarizeJsonValue(value) {
+    if (Array.isArray(value)) {
+      return `json array(${value.length})`;
+    }
+    if (!value || typeof value !== "object") {
+      return `json ${truncateSummaryText(String(value), 40)}`;
+    }
+    const record = value;
+    for (const key of ROW_CANDIDATE_KEYS2) {
+      if (Array.isArray(record[key])) {
+        return `json rows(${record[key].length}) via ${key}`;
+      }
+    }
+    const keys = Object.keys(record).slice(0, 5);
+    return keys.length > 0 ? `json keys: ${keys.join(", ")}` : "json object";
+  }
+  function headerValue(headers, name) {
+    if (!headers) {
+      return void 0;
+    }
+    const normalizedName = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+      if (key.toLowerCase() === normalizedName) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  function summarizeNetworkPayload(payload, contentType, truncated = false) {
+    if (typeof payload !== "string") {
+      return void 0;
+    }
+    const trimmed = payload.trim();
+    if (!trimmed) {
+      return void 0;
+    }
+    const normalizedContentType = contentType?.toLowerCase() ?? "";
+    let summary;
+    if (normalizedContentType.includes("json") || trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        summary = summarizeJsonValue(JSON.parse(trimmed));
+      } catch {
+        summary = `json text: ${truncateSummaryText(trimmed)}`;
+      }
+    } else if (normalizedContentType.includes("x-www-form-urlencoded") || looksLikeFormBody(trimmed)) {
+      try {
+        const params = new URLSearchParams(trimmed);
+        const preview = summarizeSearchParams(params);
+        summary = preview ? `form: ${preview}` : "form body";
+      } catch {
+        summary = `form text: ${truncateSummaryText(trimmed)}`;
+      }
+    } else {
+      summary = `text: ${truncateSummaryText(trimmed)}`;
+    }
+    return truncated ? `${summary} (truncated)` : summary;
+  }
+  function buildNetworkEntryDerivedFields(entry) {
+    const parsedUrl = safeParseUrl(entry.url);
+    const preview = {
+      query: parsedUrl ? summarizeSearchParams(parsedUrl.searchParams) : void 0,
+      request: summarizeNetworkPayload(
+        entry.requestBodyPreview,
+        headerValue(entry.requestHeaders, "content-type"),
+        entry.requestBodyTruncated === true
+      ),
+      response: summarizeNetworkPayload(entry.responseBodyPreview, entry.contentType, entry.responseBodyTruncated === true)
+    };
+    return {
+      hostname: parsedUrl?.hostname,
+      pathname: parsedUrl?.pathname,
+      preview: preview.query || preview.request || preview.response ? preview : void 0
+    };
+  }
+  function clampNetworkListLimit(limit, fallback = 50) {
+    return typeof limit === "number" ? Math.max(1, Math.min(500, Math.floor(limit))) : fallback;
+  }
+  function networkEntryMatchesFilters(entry, filters) {
+    const urlIncludes = typeof filters.urlIncludes === "string" ? filters.urlIncludes : "";
+    const method = typeof filters.method === "string" ? filters.method.toUpperCase() : "";
+    const status = typeof filters.status === "number" ? filters.status : void 0;
+    const domain = typeof filters.domain === "string" ? filters.domain.trim().toLowerCase() : "";
+    const resourceType = typeof filters.resourceType === "string" ? filters.resourceType.trim().toLowerCase() : "";
+    const kind = typeof filters.kind === "string" ? filters.kind : void 0;
+    const sinceTs = typeof filters.sinceTs === "number" ? filters.sinceTs : void 0;
+    if (typeof sinceTs === "number" && entry.ts < sinceTs) {
+      return false;
+    }
+    if (urlIncludes && !entry.url.includes(urlIncludes)) {
+      return false;
+    }
+    if (method && entry.method.toUpperCase() !== method) {
+      return false;
+    }
+    if (typeof status === "number" && entry.status !== status) {
+      return false;
+    }
+    if (domain) {
+      const hostname = (entry.hostname ?? safeParseUrl(entry.url)?.hostname ?? "").toLowerCase();
+      if (!hostname || !hostname.includes(domain) && hostname !== domain) {
+        return false;
+      }
+    }
+    if (resourceType) {
+      if ((entry.resourceType ?? "").toLowerCase() !== resourceType) {
+        return false;
+      }
+    }
+    if (kind && entry.kind !== kind) {
+      return false;
+    }
+    return true;
+  }
+
   // package.json
   var package_default = {
     name: "@flrande/bak-extension",
-    version: "0.6.15",
+    version: "0.6.17",
     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",
@@ -645,18 +887,6 @@
     }
     return Object.keys(result).length > 0 ? result : void 0;
   }
-  function headerValue(headers, name) {
-    if (!headers) {
-      return void 0;
-    }
-    const lower = name.toLowerCase();
-    for (const [key, value] of Object.entries(headers)) {
-      if (key.toLowerCase() === lower) {
-        return value;
-      }
-    }
-    return void 0;
-  }
   function isTextualContentType(contentType) {
     if (!contentType) {
       return true;
@@ -664,6 +894,18 @@
     const normalized = contentType.toLowerCase();
     return normalized.startsWith("text/") || normalized.includes("json") || normalized.includes("javascript") || normalized.includes("xml") || normalized.includes("html") || normalized.includes("urlencoded") || normalized.includes("graphql");
   }
+  function sanitizeEntry(entry) {
+    const { rawRequestHeaders, rawRequestBody, rawRequestBodyTruncated, ...publicEntry } = entry;
+    void rawRequestHeaders;
+    void rawRequestBody;
+    void rawRequestBodyTruncated;
+    return {
+      ...publicEntry,
+      requestHeaders: typeof entry.requestHeaders === "object" && entry.requestHeaders !== null ? { ...entry.requestHeaders } : void 0,
+      responseHeaders: typeof entry.responseHeaders === "object" && entry.responseHeaders !== null ? { ...entry.responseHeaders } : void 0,
+      ...buildNetworkEntryDerivedFields(entry)
+    };
+  }
   function pushEntry(state, entry, requestId) {
     state.entries.push(entry);
     state.entriesById.set(entry.id, entry);
@@ -737,7 +979,8 @@
       return;
     }
     const request = typeof params.request === "object" && params.request !== null ? params.request : {};
-    const headers = redactHeaderMap(normalizeHeaders(request.headers));
+    const rawHeaders = normalizeHeaders(request.headers);
+    const headers = redactHeaderMap(rawHeaders);
     const truncatedRequest = truncateText(typeof request.postData === "string" ? request.postData : void 0, DEFAULT_BODY_BYTES);
     const entry = {
       id: `net_${tabId}_${requestId}`,
@@ -754,6 +997,9 @@
       requestHeaders: headers,
       requestBodyPreview: truncatedRequest.text ? redactTransportText(truncatedRequest.text) : void 0,
       requestBodyTruncated: truncatedRequest.truncated,
+      rawRequestHeaders: rawHeaders,
+      rawRequestBody: typeof request.postData === "string" ? request.postData : void 0,
+      rawRequestBodyTruncated: false,
       initiatorUrl: typeof params.initiator === "object" && params.initiator !== null && typeof params.initiator.url === "string" ? String(params.initiator.url) : void 0,
       tabId,
       source: "debugger"
@@ -839,41 +1085,49 @@
     state.requestIdToEntryId.clear();
     state.lastTouchedAt = Date.now();
   }
-  function entryMatchesFilters(entry, filters) {
-    const urlIncludes = typeof filters.urlIncludes === "string" ? filters.urlIncludes : "";
-    const method = typeof filters.method === "string" ? filters.method.toUpperCase() : "";
-    const status = typeof filters.status === "number" ? filters.status : void 0;
-    if (urlIncludes && !entry.url.includes(urlIncludes)) {
-      return false;
-    }
-    if (method && entry.method.toUpperCase() !== method) {
-      return false;
-    }
-    if (typeof status === "number" && entry.status !== status) {
-      return false;
-    }
-    return true;
-  }
   function listNetworkEntries(tabId, filters = {}) {
     const state = getState(tabId);
-    const limit = typeof filters.limit === "number" ? Math.max(1, Math.min(500, Math.floor(filters.limit))) : 50;
-    return state.entries.filter((entry) => entryMatchesFilters(entry, filters)).slice(-limit).reverse().map((entry) => ({ ...entry }));
+    const limit = clampNetworkListLimit(filters.limit, 50);
+    const ordered = state.entries.filter((entry) => networkEntryMatchesFilters(entry, filters)).slice(-limit).map((entry) => sanitizeEntry(entry));
+    return filters.tail === true ? ordered : ordered.reverse();
   }
   function getNetworkEntry(tabId, id) {
     const state = getState(tabId);
     const entry = state.entriesById.get(id);
-    return entry ? { ...entry } : null;
+    return entry ? sanitizeEntry(entry) : null;
+  }
+  function getReplayableNetworkRequest(tabId, id) {
+    const state = getState(tabId);
+    const entry = state.entriesById.get(id);
+    if (!entry) {
+      return null;
+    }
+    const publicEntry = sanitizeEntry(entry);
+    if (entry.rawRequestBodyTruncated === true) {
+      return {
+        entry: publicEntry,
+        bodyTruncated: true,
+        degradedReason: "live replay unavailable because the captured request body was truncated in memory"
+      };
+    }
+    return {
+      entry: publicEntry,
+      headers: entry.rawRequestHeaders ? { ...entry.rawRequestHeaders } : void 0,
+      body: entry.rawRequestBody,
+      contentType: headerValue(entry.rawRequestHeaders, "content-type"),
+      bodyTruncated: false
+    };
   }
   async function waitForNetworkEntry(tabId, filters = {}) {
     const timeoutMs = typeof filters.timeoutMs === "number" ? Math.max(1, Math.floor(filters.timeoutMs)) : 5e3;
     const deadline = Date.now() + timeoutMs;
     const state = getState(tabId);
-    const seenIds = new Set(state.entries.filter((entry) => entryMatchesFilters(entry, filters)).map((entry) => entry.id));
+    const seenIds = new Set(state.entries.filter((entry) => networkEntryMatchesFilters(entry, filters)).map((entry) => entry.id));
     while (Date.now() < deadline) {
       const nextState = getState(tabId);
-      const matched = nextState.entries.find((entry) => !seenIds.has(entry.id) && entryMatchesFilters(entry, filters));
+      const matched = nextState.entries.find((entry) => !seenIds.has(entry.id) && networkEntryMatchesFilters(entry, filters));
       if (matched) {
-        return { ...matched };
+        return sanitizeEntry(matched);
       }
       await new Promise((resolve) => setTimeout(resolve, 75));
     }
@@ -883,14 +1137,30 @@
     };
   }
   function searchNetworkEntries(tabId, pattern, limit = 50) {
+    const state = getState(tabId);
     const normalized = pattern.toLowerCase();
-    return listNetworkEntries(tabId, { limit: Math.max(limit, 1) }).filter((entry) => {
+    const matchedEntries = state.entries.filter((entry) => {
       const headerText = JSON.stringify({
         requestHeaders: entry.requestHeaders,
         responseHeaders: entry.responseHeaders
       }).toLowerCase();
       return entry.url.toLowerCase().includes(normalized) || (entry.requestBodyPreview ?? "").toLowerCase().includes(normalized) || (entry.responseBodyPreview ?? "").toLowerCase().includes(normalized) || headerText.includes(normalized);
     });
+    const scannedEntries = state.entries.filter((entry) => networkEntryMatchesFilters(entry, {}));
+    const toCoverage = (entries, key, truncatedKey) => ({
+      full: entries.filter((entry) => typeof entry[key] === "string" && entry[truncatedKey] !== true).length,
+      partial: entries.filter((entry) => typeof entry[key] === "string" && entry[truncatedKey] === true).length,
+      none: entries.filter((entry) => typeof entry[key] !== "string").length
+    });
+    return {
+      entries: matchedEntries.slice(-Math.max(limit, 1)).reverse().map((entry) => sanitizeEntry(entry)),
+      scanned: scannedEntries.length,
+      matched: matchedEntries.length,
+      bodyCoverage: {
+        request: toCoverage(scannedEntries, "requestBodyPreview", "requestBodyTruncated"),
+        response: toCoverage(scannedEntries, "responseBodyPreview", "responseBodyTruncated")
+      }
+    };
   }
   function latestNetworkTimestamp(tabId) {
     const entries = listNetworkEntries(tabId, { limit: MAX_ENTRIES });
@@ -1931,6 +2201,11 @@
     "referer",
     "set-cookie"
   ]);
+  var CLONE_FORBIDDEN_HEADER_NAMES = /* @__PURE__ */ new Set([
+    ...REPLAY_FORBIDDEN_HEADER_NAMES,
+    "x-csrf-token",
+    "x-xsrf-token"
+  ]);
   var ws = null;
   var reconnectTimer = null;
   var nextReconnectInMs = null;
@@ -2075,6 +2350,12 @@
   async function listSessionBindingStates() {
     return Object.values(await loadSessionBindingStateMap());
   }
+  function quotePowerShellArg(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+  }
+  function renderPowerShellCommand(argv) {
+    return ["bak", ...argv].map((part) => quotePowerShellArg(part)).join(" ");
+  }
   function collectPopupSessionBindingTabIds(state) {
     return [
       ...new Set(state.tabIds.concat([state.activeTabId, state.primaryTabId].filter((value) => typeof value === "number")))
@@ -2507,7 +2788,18 @@
       await new Promise((resolve) => setTimeout(resolve, 80));
     }
     try {
-      return await chrome.tabs.captureVisibleTab(tab.windowId, { format: "png" });
+      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 {
@@ -2638,7 +2930,9 @@
           contentType: typeof params.contentType === "string" ? params.contentType : void 0,
           mode: params.mode === "json" ? "json" : "raw",
           maxBytes: typeof params.maxBytes === "number" ? params.maxBytes : void 0,
-          timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : void 0
+          timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : void 0,
+          fullResponse: params.fullResponse === true,
+          auth: params.auth === "manual" || params.auth === "off" ? params.auth : "auto"
         }
       ],
       func: async (payload) => {
@@ -2761,6 +3055,117 @@
           }
           return { resolver: "lexical", value: readLexical() };
         };
+        const findHeaderName = (headers, name) => Object.keys(headers).find((key) => key.toLowerCase() === name.toLowerCase());
+        const findCookieValue = (cookieString, name) => {
+          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 void 0;
+        };
+        const buildJsonSummary = (value) => {
+          const rowsCandidate = (() => {
+            if (Array.isArray(value)) {
+              return value;
+            }
+            if (typeof value !== "object" || value === null) {
+              return null;
+            }
+            const record = value;
+            for (const key of ["data", "rows", "results", "items"]) {
+              if (Array.isArray(record[key])) {
+                return record[key];
+              }
+            }
+            return null;
+          })();
+          if (Array.isArray(rowsCandidate) && rowsCandidate.length > 0) {
+            const objectRows = rowsCandidate.filter((row) => 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 = {};
+                  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).slice(0, 20);
+            if (columns.length > 0) {
+              return {
+                schema: {
+                  columns: columns.map((label, index) => ({
+                    key: `col_${index + 1}`,
+                    label
+                  }))
+                }
+              };
+            }
+          }
+          return {};
+        };
+        const utf8ByteLength2 = (value) => {
+          if (typeof TextEncoder === "function") {
+            return new TextEncoder().encode(value).byteLength;
+          }
+          return value.length;
+        };
+        const truncateUtf8Text = (value, limit) => {
+          if (limit <= 0) {
+            return "";
+          }
+          if (typeof TextEncoder !== "function" || typeof TextDecoder !== "function") {
+            return value.slice(0, limit);
+          }
+          const encoded = new TextEncoder().encode(value);
+          if (encoded.byteLength <= limit) {
+            return value;
+          }
+          return new TextDecoder().decode(encoded.subarray(0, limit));
+        };
+        const buildRetryHints = (requestUrl, baseUrl) => {
+          const hints = [];
+          let parsed = null;
+          try {
+            parsed = new URL(requestUrl, baseUrl);
+          } catch {
+            parsed = null;
+          }
+          const keys = (() => {
+            if (!parsed) {
+              return [];
+            }
+            const collected = [];
+            parsed.searchParams.forEach((_value, key) => {
+              collected.push(key.toLowerCase());
+            });
+            return [...new Set(collected)];
+          })();
+          if (keys.some((key) => key.includes("limit"))) {
+            hints.push("reduce the limit parameter and retry");
+          }
+          if (keys.some((key) => /(from|to|start|end|date|time|timestamp)/i.test(key))) {
+            hints.push("narrow the requested time window and retry");
+          }
+          if (keys.some((key) => key.includes("page")) && keys.some((key) => key.includes("limit"))) {
+            hints.push("retry with smaller paginated windows");
+          }
+          return hints;
+        };
         try {
           const targetWindow = payload.scope === "main" ? window : payload.scope === "current" ? resolveFrameWindow(payload.framePath ?? []) : window;
           if (payload.action === "eval") {
@@ -2781,25 +3186,155 @@
           }
           if (payload.action === "fetch") {
             const headers = { ...payload.headers ?? {} };
-            if (payload.contentType && !headers["Content-Type"]) {
+            if (payload.contentType && !findHeaderName(headers, "Content-Type")) {
               headers["Content-Type"] = payload.contentType;
             }
+            const fullResponse = payload.fullResponse === true;
+            const authApplied = [];
+            const authSources = /* @__PURE__ */ new Set();
+            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, value, source) => {
+              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(token.selector);
+                const content = meta?.content?.trim();
+                if (content) {
+                  maybeApplyHeader(token.header, content, token.source);
+                }
+              }
+            }
+            const requestHints = buildRetryHints(payload.url, targetWindow.location.href);
+            const diagnosticsBase = {
+              requestSent: false,
+              responseStarted: false,
+              status: void 0,
+              headersReceived: {},
+              bodyBytesRead: 0,
+              partialBodyPreview: "",
+              timing: {
+                startedAt: Date.now()
+              }
+            };
+            const previewLimit = !fullResponse && typeof payload.maxBytes === "number" && payload.maxBytes > 0 ? payload.maxBytes : 8192;
+            let previewBytes = 0;
+            const appendPreviewText = (value) => {
+              if (!value || previewBytes >= previewLimit) {
+                return;
+              }
+              const remaining = previewLimit - previewBytes;
+              const next = truncateUtf8Text(value, remaining);
+              diagnosticsBase.partialBodyPreview += next;
+              previewBytes += utf8ByteLength2(next);
+            };
             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;
             let response;
+            let bodyText = "";
             try {
+              diagnosticsBase.requestSent = true;
+              diagnosticsBase.timing.requestSentAt = Date.now();
               response = await targetWindow.fetch(payload.url, {
                 method: payload.method || "GET",
                 headers,
                 body: typeof payload.body === "string" ? payload.body : void 0,
                 signal: controller ? controller.signal : void 0
               });
+              diagnosticsBase.responseStarted = true;
+              diagnosticsBase.timing.responseStartedAt = Date.now();
+              diagnosticsBase.status = response.status;
+              response.headers.forEach((value, key) => {
+                diagnosticsBase.headersReceived[key] = value;
+              });
+              const reader = response.body?.getReader?.();
+              if (reader) {
+                const decoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
+                while (true) {
+                  const chunk = await reader.read();
+                  if (chunk.done) {
+                    break;
+                  }
+                  const value = chunk.value ?? new Uint8Array();
+                  diagnosticsBase.bodyBytesRead += value.byteLength;
+                  if (decoder) {
+                    const decoded = decoder.decode(value, { stream: true });
+                    bodyText += decoded;
+                    appendPreviewText(decoded);
+                  } else {
+                    const fallback = String.fromCharCode(...value);
+                    bodyText += fallback;
+                    appendPreviewText(fallback);
+                  }
+                }
+                if (decoder) {
+                  const flushed = decoder.decode();
+                  if (flushed) {
+                    bodyText += flushed;
+                    appendPreviewText(flushed);
+                  }
+                }
+              } else {
+                bodyText = await response.text();
+                diagnosticsBase.bodyBytesRead = utf8ByteLength2(bodyText);
+                appendPreviewText(bodyText);
+              }
+              diagnosticsBase.timing.completedAt = Date.now();
+            } catch (error) {
+              const abortLike = error instanceof DOMException && error.name === "AbortError" || error instanceof Error && /abort|timeout/i.test(error.message);
+              const where = diagnosticsBase.requestSent !== true ? "dispatch" : diagnosticsBase.responseStarted !== true ? "ttfb" : "body";
+              const diagnostics = {
+                kind: abortLike ? "timeout" : "network",
+                retryable: true,
+                where,
+                timing: {
+                  ...diagnosticsBase.timing,
+                  ...abortLike ? { timeoutAt: Date.now() } : {}
+                },
+                requestSent: diagnosticsBase.requestSent,
+                responseStarted: diagnosticsBase.responseStarted,
+                status: diagnosticsBase.status,
+                headersReceived: Object.keys(diagnosticsBase.headersReceived).length > 0 ? diagnosticsBase.headersReceived : void 0,
+                bodyBytesRead: diagnosticsBase.bodyBytesRead,
+                partialBodyPreview: diagnosticsBase.partialBodyPreview || void 0,
+                hints: requestHints
+              };
+              throw {
+                code: abortLike ? "E_TIMEOUT" : "E_EXECUTION",
+                message: abortLike ? `page.fetch timeout during ${where}` : error instanceof Error ? error.message : String(error),
+                details: {
+                  ...diagnostics,
+                  diagnostics
+                }
+              };
             } finally {
               if (timeoutId !== null) {
                 window.clearTimeout(timeoutId);
               }
             }
-            const bodyText = await response.text();
             const headerMap = {};
             response.headers.forEach((value, key) => {
               headerMap[key] = value;
@@ -2808,34 +3343,88 @@
               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 {
+                const bodyBytes = diagnosticsBase.bodyBytesRead || utf8ByteLength2(bodyText);
+                const truncated = !fullResponse && bodyBytes > previewLimit;
+                const previewText = fullResponse ? bodyText : truncated ? truncateUtf8Text(bodyText, previewLimit) : bodyText;
+                const result = {
                   url: response.url,
                   status: response.status,
                   ok: response.ok,
                   headers: headerMap,
                   contentType: response.headers.get("content-type") ?? void 0,
-                  bodyText: payload.mode === "json" ? void 0 : previewText,
-                  json: payload.mode === "json" && bodyText ? JSON.parse(bodyText) : void 0,
                   bytes: bodyBytes,
-                  truncated
+                  truncated,
+                  authApplied: authApplied.length > 0 ? authApplied : void 0,
+                  authSources: authSources.size > 0 ? [...authSources] : void 0,
+                  diagnostics: {
+                    kind: "success",
+                    retryable: false,
+                    where: "complete",
+                    timing: diagnosticsBase.timing,
+                    requestSent: diagnosticsBase.requestSent,
+                    responseStarted: diagnosticsBase.responseStarted,
+                    status: response.status,
+                    headersReceived: headerMap,
+                    bodyBytesRead: bodyBytes,
+                    partialBodyPreview: diagnosticsBase.partialBodyPreview || void 0,
+                    hints: requestHints
+                  }
                 };
+                if (payload.mode === "json") {
+                  let parsedJson;
+                  try {
+                    parsedJson = bodyText ? JSON.parse(bodyText) : void 0;
+                  } catch (error) {
+                    throw {
+                      code: "E_EXECUTION",
+                      message: error instanceof Error ? error.message : String(error),
+                      details: {
+                        kind: "execution",
+                        retryable: false,
+                        where: "complete",
+                        timing: diagnosticsBase.timing,
+                        requestSent: diagnosticsBase.requestSent,
+                        responseStarted: diagnosticsBase.responseStarted,
+                        status: response.status,
+                        headersReceived: headerMap,
+                        bodyBytesRead: bodyBytes,
+                        partialBodyPreview: diagnosticsBase.partialBodyPreview || void 0,
+                        hints: requestHints,
+                        diagnostics: {
+                          kind: "execution",
+                          retryable: false,
+                          where: "complete",
+                          timing: diagnosticsBase.timing,
+                          requestSent: diagnosticsBase.requestSent,
+                          responseStarted: diagnosticsBase.responseStarted,
+                          status: response.status,
+                          headersReceived: headerMap,
+                          bodyBytesRead: bodyBytes,
+                          partialBodyPreview: diagnosticsBase.partialBodyPreview || void 0,
+                          hints: requestHints
+                        }
+                      }
+                    };
+                  }
+                  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;
               })()
             };
           }
@@ -2899,31 +3488,135 @@
       delete clone.requestHeaders;
       delete clone.requestBodyPreview;
       delete clone.requestBodyTruncated;
+      if (clone.preview) {
+        clone.preview = { ...clone.preview };
+        delete clone.preview.request;
+        if (!clone.preview.query && !clone.preview.request && !clone.preview.response) {
+          delete clone.preview;
+        }
+      }
     }
     if (!sections.has("response")) {
       delete clone.responseHeaders;
       delete clone.responseBodyPreview;
       delete clone.responseBodyTruncated;
       delete clone.binary;
+      if (clone.preview) {
+        clone.preview = { ...clone.preview };
+        delete clone.preview.response;
+        if (!clone.preview.query && !clone.preview.request && !clone.preview.response) {
+          delete clone.preview;
+        }
+      }
     }
     return clone;
   }
-  function replayHeadersFromEntry(entry) {
-    if (!entry.requestHeaders) {
+  function replayHeadersFromRequestHeaders(requestHeaders) {
+    if (!requestHeaders) {
       return void 0;
     }
     const headers = {};
-    for (const [name, value] of Object.entries(entry.requestHeaders)) {
+    for (const [name, value] of Object.entries(requestHeaders)) {
       const normalizedName = name.toLowerCase();
       if (REPLAY_FORBIDDEN_HEADER_NAMES.has(normalizedName) || normalizedName.startsWith("sec-")) {
         continue;
       }
-      if (containsRedactionMarker(value)) {
+      headers[name] = value;
+    }
+    return Object.keys(headers).length > 0 ? headers : void 0;
+  }
+  function cloneHeadersFromRequestHeaders(requestHeaders) {
+    if (!requestHeaders) {
+      return { omitted: [] };
+    }
+    const headers = {};
+    const omitted = /* @__PURE__ */ new Set();
+    for (const [name, value] of Object.entries(requestHeaders)) {
+      const normalizedName = name.toLowerCase();
+      if (CLONE_FORBIDDEN_HEADER_NAMES.has(normalizedName) || normalizedName.startsWith("sec-")) {
+        omitted.add(normalizedName);
         continue;
       }
       headers[name] = value;
     }
-    return Object.keys(headers).length > 0 ? headers : void 0;
+    return {
+      headers: Object.keys(headers).length > 0 ? headers : void 0,
+      omitted: [...omitted].sort()
+    };
+  }
+  function isSameOriginWithTab(tabUrl, requestUrl) {
+    try {
+      if (!tabUrl) {
+        return false;
+      }
+      return new URL(requestUrl).origin === new URL(tabUrl).origin;
+    } catch {
+      return false;
+    }
+  }
+  function buildNetworkCloneResult(requestId, tabUrl, replayable) {
+    const sameOrigin = isSameOriginWithTab(tabUrl, replayable.entry.url);
+    const cloneable = sameOrigin && replayable.bodyTruncated !== true;
+    const notes = [];
+    const sanitizedHeaders = cloneHeadersFromRequestHeaders(replayable.headers);
+    if (sanitizedHeaders.omitted.length > 0) {
+      notes.push(`omitted sensitive headers: ${sanitizedHeaders.omitted.join(", ")}`);
+    }
+    if (!sameOrigin) {
+      notes.push("preferred page.fetch template was skipped because the captured request is not same-origin with the current page");
+    }
+    if (replayable.bodyTruncated) {
+      notes.push("captured request body was truncated, so bak cannot emit a reliable page.fetch clone");
+    }
+    if (!sameOrigin || replayable.bodyTruncated) {
+      notes.push("falling back to network.replay preserves the captured request shape more safely");
+    } else {
+      notes.push("page.fetch clone keeps session cookies and auto-applies same-origin auth helpers");
+    }
+    const pageFetch = sameOrigin && replayable.bodyTruncated !== true ? {
+      url: replayable.entry.url,
+      method: replayable.entry.method,
+      headers: sanitizedHeaders.headers,
+      body: replayable.body,
+      contentType: replayable.contentType,
+      mode: (replayable.entry.contentType ?? replayable.contentType)?.toLowerCase().includes("json") ? "json" : "raw",
+      auth: "auto"
+    } : void 0;
+    const preferredArgv = pageFetch ? [
+      "page",
+      "fetch",
+      "--url",
+      pageFetch.url,
+      "--method",
+      pageFetch.method,
+      "--auth",
+      pageFetch.auth,
+      "--mode",
+      pageFetch.mode ?? "raw",
+      ...pageFetch.contentType ? ["--content-type", pageFetch.contentType] : [],
+      ...Object.entries(pageFetch.headers ?? {}).flatMap(([name, value]) => ["--header", `${name}: ${value}`]),
+      ...typeof pageFetch.body === "string" ? ["--body", pageFetch.body] : []
+    ] : ["network", "replay", "--request-id", requestId, "--auth", "auto"];
+    return {
+      request: {
+        id: replayable.entry.id,
+        url: replayable.entry.url,
+        method: replayable.entry.method,
+        kind: replayable.entry.kind,
+        contentType: replayable.contentType,
+        sameOrigin,
+        bodyPresent: typeof replayable.body === "string" && replayable.body.length > 0,
+        bodyTruncated: replayable.bodyTruncated
+      },
+      cloneable,
+      preferredCommand: {
+        tool: pageFetch ? "page.fetch" : "network.replay",
+        argv: preferredArgv,
+        powershell: renderPowerShellCommand(preferredArgv)
+      },
+      pageFetch,
+      notes
+    };
   }
   function collectTimestampMatchesFromText(text, source, patterns) {
     const regexes = (patterns ?? [
@@ -3051,6 +3744,64 @@
     }
     return "unknown";
   }
+  function freshnessCategoryPriority(category) {
+    switch (category) {
+      case "data":
+        return 0;
+      case "unknown":
+        return 1;
+      case "event":
+        return 2;
+      case "contract":
+        return 3;
+      default:
+        return 4;
+    }
+  }
+  function freshnessSourcePriority(source) {
+    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, now = Date.now()) {
+    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) {
+    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, params = {}) {
     return await forwardContentRpc(tabId, "bak.internal.inspectState", params);
   }
@@ -3172,7 +3923,9 @@
     const domVisibleTimestamp = latestTimestampFromCandidates(visibleCandidates, now);
     const latestNetworkTs = latestNetworkTimestamp(tabId);
     const lastMutationAt = typeof inspection.lastMutationAt === "number" ? inspection.lastMutationAt : null;
-    const allCandidates = [...visibleCandidates, ...inlineCandidates, ...pageDataCandidates, ...networkCandidates];
+    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,
@@ -3181,6 +3934,11 @@
       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,
@@ -3280,6 +4038,7 @@
     const pageDataCandidates = await probePageDataCandidatesForTab(tabId, inspection);
     const recentNetwork = listNetworkEntries(tabId, { limit: 25 });
     const pageDataReport = buildInspectPageDataResult({
+      pageUrl: inspection.url,
       suspiciousGlobals: inspection.suspiciousGlobals ?? [],
       tables: inspection.tables ?? [],
       visibleTimestamps: inspection.visibleTimestamps ?? [],
@@ -3287,7 +4046,9 @@
       pageDataCandidates,
       recentNetwork,
       tableAnalyses: tables,
-      inlineJsonSources: Array.isArray(inspection.inlineJsonSources) ? inspection.inlineJsonSources : []
+      inlineJsonSources: Array.isArray(inspection.inlineJsonSources) ? inspection.inlineJsonSources : [],
+      modeGroups: Array.isArray(inspection.modeGroups) ? inspection.modeGroups : [],
+      dateControls: Array.isArray(inspection.dateControls) ? inspection.dateControls : []
     });
     const matched = selectReplaySchemaMatch(response.json, tables, {
       preferredSourceId: `networkResponse:${requestId}`,
@@ -3613,9 +4374,11 @@
             type: "bak.collectElements",
             debugRichText: config.debugRichText
           });
-          const imageData = await captureAlignedTabScreenshot(tab);
+          const screenshot = params.capture === false ? { captureStatus: "skipped" } : await captureAlignedTabScreenshot(tab);
           return {
-            imageBase64: includeBase64 ? imageData.replace(/^data:image\/png;base64,/, "") : "",
+            captureStatus: screenshot.captureStatus,
+            captureError: screenshot.captureError,
+            imageBase64: includeBase64 && typeof screenshot.imageData === "string" ? screenshot.imageData.replace(/^data:image\/png;base64,/, "") : void 0,
             elements: elements.elements,
             tabId: tab.id,
             url: tab.url ?? ""
@@ -3705,7 +4468,12 @@
                 limit: typeof params.limit === "number" ? params.limit : void 0,
                 urlIncludes: typeof params.urlIncludes === "string" ? params.urlIncludes : void 0,
                 status: typeof params.status === "number" ? params.status : void 0,
-                method: typeof params.method === "string" ? params.method : void 0
+                method: typeof params.method === "string" ? params.method : void 0,
+                domain: typeof params.domain === "string" ? params.domain : void 0,
+                resourceType: typeof params.resourceType === "string" ? params.resourceType : void 0,
+                kind: typeof params.kind === "string" ? params.kind : void 0,
+                sinceTs: typeof params.sinceTs === "number" ? params.sinceTs : void 0,
+                tail: params.tail === true
               })
             };
           } catch {
@@ -3739,13 +4507,18 @@
         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
-            )
-          };
+          return searchNetworkEntries(tab.id, String(params.pattern ?? ""), typeof params.limit === "number" ? params.limit : 50);
+        });
+      }
+      case "network.clone": {
+        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 ?? "")}`);
+          }
+          return buildNetworkCloneResult(String(params.id ?? ""), tab.url, replayable);
         });
       }
       case "network.waitFor": {
@@ -3779,34 +4552,32 @@
         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) {
+          const replayable = getReplayableNetworkRequest(tab.id, String(params.id ?? ""));
+          if (!replayable) {
             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
-            });
+          if (replayable.degradedReason) {
+            return {
+              url: replayable.entry.url,
+              status: 0,
+              ok: false,
+              headers: {},
+              bytes: replayable.entry.requestBytes,
+              truncated: true,
+              degradedReason: replayable.degradedReason
+            };
           }
           const replayed = await executePageWorld(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] : void 0;
-            })(),
+            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);
@@ -3815,7 +4586,13 @@
           }
           const first = frameResult?.value;
           if (!first) {
-            throw toError("E_EXECUTION", "network replay returned no response payload");
+            return {
+              url: replayable.entry.url,
+              status: 0,
+              ok: false,
+              headers: {},
+              degradedReason: "network replay returned no response payload"
+            };
           }
           return params.withSchema === "auto" && params.mode === "json" ? await enrichReplayWithSchema(tab.id, String(params.id ?? ""), first) : first;
         });
@@ -3894,9 +4671,10 @@
           await ensureNetworkDebugger(tab.id).catch(() => void 0);
           const inspection = await collectPageInspection(tab.id, params);
           const pageDataCandidates = await probePageDataCandidatesForTab(tab.id, inspection);
-          const network = listNetworkEntries(tab.id, { limit: 10 });
+          const network = listNetworkEntries(tab.id, { limit: 25, tail: true });
           const tableAnalyses = await collectTableAnalyses(tab.id);
           const enriched = buildInspectPageDataResult({
+            pageUrl: inspection.url,
             suspiciousGlobals: inspection.suspiciousGlobals ?? [],
             tables: inspection.tables ?? [],
             visibleTimestamps: inspection.visibleTimestamps ?? [],
@@ -3904,7 +4682,9 @@
             pageDataCandidates,
             recentNetwork: network,
             tableAnalyses,
-            inlineJsonSources: Array.isArray(inspection.inlineJsonSources) ? inspection.inlineJsonSources : []
+            inlineJsonSources: Array.isArray(inspection.inlineJsonSources) ? inspection.inlineJsonSources : [],
+            modeGroups: Array.isArray(inspection.modeGroups) ? inspection.modeGroups : [],
+            dateControls: Array.isArray(inspection.dateControls) ? inspection.dateControls : []
           });
           const recommendedNextSteps = enriched.recommendedNextActions.map((action) => action.command);
           return {
@@ -3914,6 +4694,12 @@
             inlineTimestamps: inspection.inlineTimestamps ?? [],
             pageDataCandidates,
             recentNetwork: network,
+            modeGroups: Array.isArray(inspection.modeGroups) ? inspection.modeGroups : [],
+            availableModes: enriched.availableModes,
+            currentMode: enriched.currentMode,
+            dateControls: Array.isArray(inspection.dateControls) ? inspection.dateControls : [],
+            latestArchiveDate: enriched.latestArchiveDate,
+            primaryEndpoint: enriched.primaryEndpoint,
             dataSources: enriched.dataSources,
             sourceMappings: enriched.sourceMappings,
             recommendedNextActions: enriched.recommendedNextActions,