@flrande/bak-extension 0.6.16 → 0.6.17

package/dist/background.global.js

@@ -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) {
@@ -550,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.16",
+    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",
@@ -642,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;
@@ -669,7 +902,8 @@
     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
+      responseHeaders: typeof entry.responseHeaders === "object" && entry.responseHeaders !== null ? { ...entry.responseHeaders } : void 0,
+      ...buildNetworkEntryDerivedFields(entry)
     };
   }
   function pushEntry(state, entry, requestId) {
@@ -851,25 +1085,11 @@
     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) => sanitizeEntry(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);
@@ -886,6 +1106,7 @@
     if (entry.rawRequestBodyTruncated === true) {
       return {
         entry: publicEntry,
+        bodyTruncated: true,
         degradedReason: "live replay unavailable because the captured request body was truncated in memory"
       };
     }
@@ -893,17 +1114,18 @@
       entry: publicEntry,
       headers: entry.rawRequestHeaders ? { ...entry.rawRequestHeaders } : void 0,
       body: entry.rawRequestBody,
-      contentType: headerValue(entry.rawRequestHeaders, "content-type")
+      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 sanitizeEntry(matched);
       }
@@ -924,7 +1146,7 @@
       }).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) => entryMatchesFilters(entry, {}));
+    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,
@@ -1979,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;
@@ -2123,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")))
@@ -2885,6 +3118,54 @@
           }
           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") {
@@ -2947,22 +3228,113 @@
                 }
               }
             }
+            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;
@@ -2971,13 +3343,9 @@
               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 = !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 bodyBytes = diagnosticsBase.bodyBytesRead || utf8ByteLength2(bodyText);
                 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 previewText = fullResponse ? bodyText : truncated ? truncateUtf8Text(bodyText, previewLimit) : bodyText;
                 const result = {
                   url: response.url,
                   status: response.status,
@@ -2987,10 +3355,57 @@
                   bytes: bodyBytes,
                   truncated,
                   authApplied: authApplied.length > 0 ? authApplied : void 0,
-                  authSources: authSources.size > 0 ? [...authSources] : 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") {
-                  const parsedJson = bodyText ? JSON.parse(bodyText) : void 0;
+                  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;
@@ -3073,12 +3488,26 @@
       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;
   }
@@ -3096,6 +3525,99 @@
     }
     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 {
+      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 ?? [
       String.raw`\b20\d{2}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b`,
@@ -3516,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 ?? [],
@@ -3523,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}`,
@@ -3943,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 {
@@ -3980,6 +4510,17 @@
           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": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
           const tab = await withTab(target);
@@ -4130,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 ?? [],
@@ -4140,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 {
@@ -4150,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,