@flrande/bak-extension 0.5.0 → 0.6.0

package/dist/background.global.js

@@ -1,5 +1,438 @@
 "use strict";
 (() => {
+  // src/privacy.ts
+  var HIGH_ENTROPY_TOKEN_PATTERN = /^(?=.*\d)(?=.*[a-zA-Z])[A-Za-z0-9~!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?`]{16,}$/;
+  var TRANSPORT_SECRET_KEY_SOURCE = "(?:api[_-]?key|authorization|auth|cookie|csrf(?:token)?|nonce|password|passwd|secret|session(?:id)?|token|xsrf(?:token)?)";
+  var TRANSPORT_SECRET_PAIR_PATTERN = new RegExp(`((?:^|[?&;,\\s])${TRANSPORT_SECRET_KEY_SOURCE}=)[^&\\r\\n"'>]*`, "gi");
+  var JSON_SECRET_VALUE_PATTERN = new RegExp(
+    `((?:"|')${TRANSPORT_SECRET_KEY_SOURCE}(?:"|')\\s*:\\s*)(?:"[^"]*"|'[^']*'|true|false|null|-?\\d+(?:\\.\\d+)?)`,
+    "gi"
+  );
+  var ASSIGNMENT_SECRET_VALUE_PATTERN = new RegExp(
+    `((?:^|[\\s,{;])${TRANSPORT_SECRET_KEY_SOURCE}\\s*[:=]\\s*)([^,&;}"'\\r\\n]+)`,
+    "gi"
+  );
+  var AUTHORIZATION_VALUE_PATTERN = /\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]+\b/gi;
+  var SENSITIVE_HEADER_PATTERNS = [
+    /^authorization$/i,
+    /^proxy-authorization$/i,
+    /^cookie$/i,
+    /^set-cookie$/i,
+    /^x-csrf-token$/i,
+    /^x-xsrf-token$/i,
+    /^csrf-token$/i,
+    /^x-auth-token$/i,
+    /^x-api-key$/i,
+    /^api-key$/i
+  ];
+  function redactTransportSecrets(text) {
+    let output = text;
+    output = output.replace(AUTHORIZATION_VALUE_PATTERN, "$1 [REDACTED]");
+    output = output.replace(TRANSPORT_SECRET_PAIR_PATTERN, "$1[REDACTED]");
+    output = output.replace(JSON_SECRET_VALUE_PATTERN, '$1"[REDACTED]"');
+    output = output.replace(ASSIGNMENT_SECRET_VALUE_PATTERN, "$1[REDACTED]");
+    if (HIGH_ENTROPY_TOKEN_PATTERN.test(output) && !/[ =&:]/.test(output) && !output.includes("[REDACTED")) {
+      return "[REDACTED:secret]";
+    }
+    return output;
+  }
+  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 "";
+    }
+    return redactTransportSecrets(String(raw));
+  }
+  function redactHeaderMap(headers) {
+    if (!headers) {
+      return void 0;
+    }
+    const result = {};
+    for (const [name, value] of Object.entries(headers)) {
+      result[name] = shouldRedactHeader(name) ? `[REDACTED:${name.toLowerCase()}]` : redactTransportText(value);
+    }
+    return Object.keys(result).length > 0 ? result : void 0;
+  }
+
+  // src/network-debugger.ts
+  var DEBUGGER_VERSION = "1.3";
+  var MAX_ENTRIES = 1e3;
+  var DEFAULT_BODY_BYTES = 8 * 1024;
+  var DEFAULT_TOTAL_BODY_BYTES = 256 * 1024;
+  var textEncoder = new TextEncoder();
+  var textDecoder = new TextDecoder();
+  var captures = /* @__PURE__ */ new Map();
+  function getState(tabId) {
+    const existing = captures.get(tabId);
+    if (existing) {
+      return existing;
+    }
+    const created = {
+      attached: false,
+      attachError: null,
+      entries: [],
+      entriesById: /* @__PURE__ */ new Map(),
+      requestIdToEntryId: /* @__PURE__ */ new Map(),
+      lastTouchedAt: Date.now()
+    };
+    captures.set(tabId, created);
+    return created;
+  }
+  function debuggerTarget(tabId) {
+    return { tabId };
+  }
+  function utf8ByteLength(value) {
+    return textEncoder.encode(value).byteLength;
+  }
+  function truncateUtf8(value, limit) {
+    const encoded = textEncoder.encode(value);
+    if (encoded.byteLength <= limit) {
+      return value;
+    }
+    return textDecoder.decode(encoded.subarray(0, limit));
+  }
+  function decodeBase64Utf8(value) {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+      bytes[index] = binary.charCodeAt(index);
+    }
+    return textDecoder.decode(bytes);
+  }
+  function truncateText(value, limit = DEFAULT_BODY_BYTES) {
+    if (typeof value !== "string") {
+      return { truncated: false };
+    }
+    const bytes = utf8ByteLength(value);
+    if (bytes <= limit) {
+      return { text: value, truncated: false, bytes };
+    }
+    const truncatedText = truncateUtf8(value, limit);
+    return { text: truncatedText, truncated: true, bytes };
+  }
+  function normalizeHeaders(headers) {
+    if (typeof headers !== "object" || headers === null) {
+      return void 0;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      result[String(key)] = Array.isArray(value) ? value.map(String).join(", ") : String(value);
+    }
+    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;
+    }
+    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 pushEntry(state, entry, requestId) {
+    state.entries.push(entry);
+    state.entriesById.set(entry.id, entry);
+    state.requestIdToEntryId.set(requestId, entry.id);
+    state.lastTouchedAt = Date.now();
+    while (state.entries.length > MAX_ENTRIES) {
+      const removed = state.entries.shift();
+      if (!removed) {
+        break;
+      }
+      state.entriesById.delete(removed.id);
+    }
+  }
+  function entryForRequest(tabId, requestId) {
+    const state = captures.get(tabId);
+    if (!state) {
+      return null;
+    }
+    const entryId = state.requestIdToEntryId.get(requestId);
+    if (!entryId) {
+      return null;
+    }
+    return state.entriesById.get(entryId) ?? null;
+  }
+  async function sendDebuggerCommand(tabId, method, commandParams) {
+    return await chrome.debugger.sendCommand(debuggerTarget(tabId), method, commandParams);
+  }
+  async function getResponseBodyPreview(tabId, requestId, contentType) {
+    try {
+      const response = await sendDebuggerCommand(tabId, "Network.getResponseBody", { requestId }) ?? { body: "" };
+      const rawBody = typeof response.body === "string" ? response.body : "";
+      const base64Encoded = response.base64Encoded === true;
+      const binary = base64Encoded && !isTextualContentType(contentType);
+      if (binary) {
+        return { binary: true };
+      }
+      const decoded = base64Encoded ? decodeBase64Utf8(rawBody) : rawBody;
+      const preview = truncateText(decoded, DEFAULT_BODY_BYTES);
+      return {
+        responseBodyPreview: preview.text ? redactTransportText(preview.text) : void 0,
+        responseBodyTruncated: preview.truncated
+      };
+    } catch (error) {
+      const entry = entryForRequest(tabId, requestId);
+      if (entry) {
+        entry.failureReason = error instanceof Error ? error.message : String(error);
+      }
+      return {};
+    }
+  }
+  async function handleLoadingFinished(tabId, params) {
+    const requestId = String(params.requestId ?? "");
+    const entry = entryForRequest(tabId, requestId);
+    if (!entry) {
+      return;
+    }
+    entry.durationMs = entry.startedAt ? Math.max(0, Date.now() - entry.startedAt) : entry.durationMs;
+    if (typeof params.encodedDataLength === "number") {
+      entry.responseBytes = Math.max(0, Math.round(params.encodedDataLength));
+    }
+    const body = await getResponseBodyPreview(tabId, requestId, entry.contentType);
+    Object.assign(entry, body);
+    if ((entry.requestBytes ?? 0) + (entry.responseBytes ?? 0) > DEFAULT_TOTAL_BODY_BYTES) {
+      entry.truncated = true;
+    }
+  }
+  function upsertRequest(tabId, params) {
+    const state = getState(tabId);
+    const requestId = String(params.requestId ?? "");
+    if (!requestId) {
+      return;
+    }
+    const request = typeof params.request === "object" && params.request !== null ? params.request : {};
+    const headers = redactHeaderMap(normalizeHeaders(request.headers));
+    const truncatedRequest = truncateText(typeof request.postData === "string" ? request.postData : void 0, DEFAULT_BODY_BYTES);
+    const entry = {
+      id: `net_${tabId}_${requestId}`,
+      url: typeof request.url === "string" ? request.url : "",
+      method: typeof request.method === "string" ? request.method : "GET",
+      status: 0,
+      ok: false,
+      kind: params.type === "XHR" ? "xhr" : params.type === "Fetch" ? "fetch" : params.type === "Document" ? "navigation" : "resource",
+      resourceType: typeof params.type === "string" ? String(params.type) : void 0,
+      ts: Date.now(),
+      startedAt: Date.now(),
+      durationMs: 0,
+      requestBytes: truncatedRequest.bytes,
+      requestHeaders: headers,
+      requestBodyPreview: truncatedRequest.text ? redactTransportText(truncatedRequest.text) : void 0,
+      requestBodyTruncated: truncatedRequest.truncated,
+      initiatorUrl: typeof params.initiator === "object" && params.initiator !== null && typeof params.initiator.url === "string" ? String(params.initiator.url) : void 0,
+      tabId,
+      source: "debugger"
+    };
+    pushEntry(state, entry, requestId);
+  }
+  function updateResponse(tabId, params) {
+    const requestId = String(params.requestId ?? "");
+    const entry = entryForRequest(tabId, requestId);
+    if (!entry) {
+      return;
+    }
+    const response = typeof params.response === "object" && params.response !== null ? params.response : {};
+    const responseHeaders = redactHeaderMap(normalizeHeaders(response.headers));
+    entry.status = typeof response.status === "number" ? Math.round(response.status) : entry.status;
+    entry.ok = entry.status >= 200 && entry.status < 400;
+    entry.contentType = typeof response.mimeType === "string" ? response.mimeType : headerValue(responseHeaders, "content-type");
+    entry.responseHeaders = responseHeaders;
+    if (typeof response.encodedDataLength === "number") {
+      entry.responseBytes = Math.max(0, Math.round(response.encodedDataLength));
+    }
+  }
+  function updateFailure(tabId, params) {
+    const requestId = String(params.requestId ?? "");
+    const entry = entryForRequest(tabId, requestId);
+    if (!entry) {
+      return;
+    }
+    entry.ok = false;
+    entry.failureReason = typeof params.errorText === "string" ? params.errorText : "loading failed";
+    entry.durationMs = entry.startedAt ? Math.max(0, Date.now() - entry.startedAt) : entry.durationMs;
+  }
+  chrome.debugger.onEvent.addListener((source, method, params) => {
+    const tabId = typeof source.tabId === "number" ? source.tabId : void 0;
+    if (typeof tabId !== "number") {
+      return;
+    }
+    const payload = typeof params === "object" && params !== null ? params : {};
+    if (method === "Network.requestWillBeSent") {
+      upsertRequest(tabId, payload);
+      return;
+    }
+    if (method === "Network.responseReceived") {
+      updateResponse(tabId, payload);
+      return;
+    }
+    if (method === "Network.loadingFailed") {
+      updateFailure(tabId, payload);
+      return;
+    }
+    if (method === "Network.loadingFinished") {
+      void handleLoadingFinished(tabId, payload);
+    }
+  });
+  chrome.debugger.onDetach.addListener((source, reason) => {
+    const tabId = typeof source.tabId === "number" ? source.tabId : void 0;
+    if (typeof tabId !== "number") {
+      return;
+    }
+    const state = getState(tabId);
+    state.attached = false;
+    state.attachError = reason;
+  });
+  async function ensureNetworkDebugger(tabId) {
+    const state = getState(tabId);
+    if (state.attached) {
+      return;
+    }
+    try {
+      await chrome.debugger.attach(debuggerTarget(tabId), DEBUGGER_VERSION);
+    } catch (error) {
+      state.attachError = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+    await sendDebuggerCommand(tabId, "Network.enable");
+    state.attached = true;
+    state.attachError = null;
+  }
+  function clearNetworkEntries(tabId) {
+    const state = getState(tabId);
+    state.entries = [];
+    state.entriesById.clear();
+    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 }));
+  }
+  function getNetworkEntry(tabId, id) {
+    const state = getState(tabId);
+    const entry = state.entriesById.get(id);
+    return entry ? { ...entry } : null;
+  }
+  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));
+    while (Date.now() < deadline) {
+      const nextState = getState(tabId);
+      const matched = nextState.entries.find((entry) => !seenIds.has(entry.id) && entryMatchesFilters(entry, filters));
+      if (matched) {
+        return { ...matched };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 75));
+    }
+    throw {
+      code: "E_TIMEOUT",
+      message: "network.waitFor timeout"
+    };
+  }
+  function searchNetworkEntries(tabId, pattern, limit = 50) {
+    const normalized = pattern.toLowerCase();
+    return listNetworkEntries(tabId, { limit: Math.max(limit, 1) }).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);
+    });
+  }
+  function latestNetworkTimestamp(tabId) {
+    const entries = listNetworkEntries(tabId, { limit: MAX_ENTRIES });
+    return entries.length > 0 ? entries[0].ts : null;
+  }
+  function recentNetworkSampleIds(tabId, limit = 5) {
+    return listNetworkEntries(tabId, { limit }).map((entry) => entry.id);
+  }
+  function exportHar(tabId, limit = MAX_ENTRIES) {
+    const entries = listNetworkEntries(tabId, { limit }).reverse();
+    return {
+      log: {
+        version: "1.2",
+        creator: {
+          name: "bak",
+          version: "0.6.0"
+        },
+        entries: entries.map((entry) => ({
+          startedDateTime: new Date(entry.startedAt ?? entry.ts).toISOString(),
+          time: entry.durationMs,
+          request: {
+            method: entry.method,
+            url: entry.url,
+            headers: Object.entries(entry.requestHeaders ?? {}).map(([name, value]) => ({ name, value })),
+            postData: typeof entry.requestBodyPreview === "string" ? {
+              mimeType: headerValue(entry.requestHeaders, "content-type") ?? "",
+              text: entry.requestBodyPreview
+            } : void 0,
+            headersSize: -1,
+            bodySize: entry.requestBytes ?? -1
+          },
+          response: {
+            status: entry.status,
+            statusText: entry.ok ? "OK" : entry.failureReason ?? "",
+            headers: Object.entries(entry.responseHeaders ?? {}).map(([name, value]) => ({ name, value })),
+            content: {
+              mimeType: entry.contentType ?? "",
+              size: entry.responseBytes ?? -1,
+              text: entry.binary ? void 0 : entry.responseBodyPreview,
+              comment: entry.binary ? "binary body omitted" : void 0
+            },
+            headersSize: -1,
+            bodySize: entry.responseBytes ?? -1
+          },
+          cache: {},
+          timings: {
+            send: 0,
+            wait: entry.durationMs,
+            receive: 0
+          },
+          _bak: entry
+        }))
+      }
+    };
+  }
+  function dropNetworkCapture(tabId) {
+    captures.delete(tabId);
+  }
+
   // src/url-policy.ts
   function isSupportedAutomationUrl(url) {
     if (typeof url !== "string" || !url) {
@@ -106,19 +539,19 @@
       const created = !persisted;
       let state = this.normalizeState(persisted, workspaceId);
       const originalWindowId = state.windowId;
-      let window = state.windowId !== null ? await this.waitForWindow(state.windowId) : null;
+      let window2 = state.windowId !== null ? await this.waitForWindow(state.windowId) : null;
       let tabs = [];
-      if (!window) {
+      if (!window2) {
         const rebound = await this.rebindWorkspaceWindow(state);
         if (rebound) {
-          window = rebound.window;
+          window2 = rebound.window;
           tabs = rebound.tabs;
           if (originalWindowId !== rebound.window.id) {
             repairActions.push("rebound-window");
           }
         }
       }
-      if (!window) {
+      if (!window2) {
         const createdWindow = await this.browser.createWindow({
           url: initialUrl,
           focused: options.focus === true
@@ -128,7 +561,7 @@
         state.tabIds = [];
         state.activeTabId = null;
         state.primaryTabId = null;
-        window = createdWindow;
+        window2 = createdWindow;
         tabs = await this.waitForWindowTabs(createdWindow.id);
         state.tabIds = tabs.map((tab) => tab.id);
         if (state.primaryTabId === null) {
@@ -153,7 +586,7 @@
         const ownership = await this.inspectWorkspaceWindowOwnership(state, state.windowId);
         if (ownership.foreignTabs.length > 0) {
           const migrated = await this.moveWorkspaceIntoDedicatedWindow(state, ownership, initialUrl);
-          window = migrated.window;
+          window2 = migrated.window;
           tabs = migrated.tabs;
           state.tabIds = tabs.map((tab) => tab.id);
           repairActions.push("migrated-dirty-window");
@@ -216,8 +649,8 @@
       state.tabIds = [...new Set(tabs.map((tab) => tab.id))];
       if (options.focus === true && state.activeTabId !== null) {
         await this.browser.updateTab(state.activeTabId, { active: true });
-        window = await this.browser.updateWindow(state.windowId, { focused: true });
-        void window;
+        window2 = await this.browser.updateWindow(state.windowId, { focused: true });
+        void window2;
         repairActions.push("focused-window");
       }
       await this.storage.save(state);
@@ -556,8 +989,8 @@
         pushWindowId(tab.windowId);
       }
       for (const candidateWindowId of candidateWindowIds) {
-        const window = await this.waitForWindow(candidateWindowId);
-        if (!window) {
+        const window2 = await this.waitForWindow(candidateWindowId);
+        if (!window2) {
           continue;
         }
         let tabs = await this.readTrackedTabs(this.collectCandidateTabIds(state), candidateWindowId);
@@ -578,7 +1011,7 @@
             state.activeTabId = tabs.find((tab) => tab.active)?.id ?? state.primaryTabId;
           }
         }
-        return { window, tabs };
+        return { window: window2, tabs };
       }
       return null;
     }
@@ -593,11 +1026,11 @@
     async moveWorkspaceIntoDedicatedWindow(state, ownership, initialUrl) {
       const sourceTabs = this.orderWorkspaceTabsForMigration(state, ownership.workspaceTabs);
       const seedUrl = sourceTabs[0]?.url ?? initialUrl;
-      const window = await this.browser.createWindow({
+      const window2 = await this.browser.createWindow({
         url: seedUrl || DEFAULT_WORKSPACE_URL,
         focused: false
       });
-      const recreatedTabs = await this.waitForWindowTabs(window.id);
+      const recreatedTabs = await this.waitForWindowTabs(window2.id);
       const firstTab = recreatedTabs[0] ?? null;
       const tabIdMap = /* @__PURE__ */ new Map();
       if (sourceTabs[0] && firstTab) {
@@ -605,7 +1038,7 @@
       }
       for (const sourceTab of sourceTabs.slice(1)) {
         const recreated = await this.createWorkspaceTab({
-          windowId: window.id,
+          windowId: window2.id,
           url: sourceTab.url,
           active: false
         });
@@ -617,7 +1050,7 @@
       if (nextActiveTabId !== null) {
         await this.browser.updateTab(nextActiveTabId, { active: true });
       }
-      state.windowId = window.id;
+      state.windowId = window2.id;
       state.groupId = null;
       state.tabIds = recreatedTabs.map((tab) => tab.id);
       state.primaryTabId = nextPrimaryTabId;
@@ -626,7 +1059,7 @@
         await this.browser.closeTab(workspaceTab.id);
       }
       return {
-        window,
+        window: window2,
         tabs: await this.readTrackedTabs(state.tabIds, state.windowId)
       };
     }
@@ -756,9 +1189,9 @@
     async waitForWindow(windowId, timeoutMs = 750) {
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
-        const window = await this.browser.getWindow(windowId);
-        if (window) {
-          return window;
+        const window2 = await this.browser.getWindow(windowId);
+        if (window2) {
+          return window2;
         }
         await this.delay(50);
       }
@@ -801,6 +1234,20 @@
   var STORAGE_KEY_PORT = "cliPort";
   var STORAGE_KEY_DEBUG_RICH_TEXT = "debugRichText";
   var DEFAULT_TAB_LOAD_TIMEOUT_MS = 4e4;
+  var textEncoder2 = new TextEncoder();
+  var textDecoder2 = new TextDecoder();
+  var REPLAY_FORBIDDEN_HEADER_NAMES = /* @__PURE__ */ new Set([
+    "accept-encoding",
+    "authorization",
+    "connection",
+    "content-length",
+    "cookie",
+    "host",
+    "origin",
+    "proxy-authorization",
+    "referer",
+    "set-cookie"
+  ]);
   var ws = null;
   var reconnectTimer = null;
   var nextReconnectInMs = null;
@@ -965,17 +1412,17 @@
     },
     async getWindow(windowId) {
       try {
-        const window = await chrome.windows.get(windowId);
+        const window2 = await chrome.windows.get(windowId);
         return {
-          id: window.id,
-          focused: Boolean(window.focused)
+          id: window2.id,
+          focused: Boolean(window2.focused)
         };
       } catch {
         return null;
       }
     },
     async createWindow(options) {
-      const previouslyFocusedWindow = options.focused === true ? null : (await chrome.windows.getAll()).find((window) => window.focused === true && typeof window.id === "number") ?? null;
+      const previouslyFocusedWindow = options.focused === true ? null : (await chrome.windows.getAll()).find((window2) => window2.focused === true && typeof window2.id === "number") ?? null;
       const previouslyFocusedTab = previouslyFocusedWindow?.id !== void 0 ? (await chrome.tabs.query({ windowId: previouslyFocusedWindow.id, active: true })).find((tab) => typeof tab.id === "number") ?? null : null;
       const created = await chrome.windows.create({
         url: options.url ?? "about:blank",
@@ -1290,6 +1737,369 @@
     }
     return response.result;
   }
+  async function ensureTabNetworkCapture(tabId) {
+    try {
+      await ensureNetworkDebugger(tabId);
+    } catch (error) {
+      throw toError("E_DEBUGGER_NOT_ATTACHED", "Debugger-backed network capture unavailable", {
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  function normalizePageExecutionScope(value) {
+    return value === "main" || value === "all-frames" ? value : "current";
+  }
+  async function currentContextFramePath(tabId) {
+    try {
+      const context = await forwardContentRpc(tabId, "context.get", { tabId });
+      return Array.isArray(context.framePath) ? context.framePath.map(String) : [];
+    } catch {
+      return [];
+    }
+  }
+  async function executePageWorld(tabId, action, params) {
+    const scope = normalizePageExecutionScope(params.scope);
+    const framePath = scope === "current" ? await currentContextFramePath(tabId) : [];
+    const target = scope === "all-frames" ? { tabId, allFrames: true } : {
+      tabId,
+      frameIds: [0]
+    };
+    const results = await chrome.scripting.executeScript({
+      target,
+      world: "MAIN",
+      args: [
+        {
+          action,
+          scope,
+          framePath,
+          expr: typeof params.expr === "string" ? params.expr : "",
+          path: typeof params.path === "string" ? params.path : "",
+          url: typeof params.url === "string" ? params.url : "",
+          method: typeof params.method === "string" ? params.method : "GET",
+          headers: typeof params.headers === "object" && params.headers !== null ? params.headers : void 0,
+          body: typeof params.body === "string" ? params.body : void 0,
+          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
+        }
+      ],
+      func: async (payload) => {
+        const serializeValue = (value, maxBytes) => {
+          let cloned;
+          try {
+            cloned = typeof structuredClone === "function" ? structuredClone(value) : JSON.parse(JSON.stringify(value));
+          } catch (error) {
+            throw {
+              code: "E_NOT_SERIALIZABLE",
+              message: error instanceof Error ? error.message : String(error)
+            };
+          }
+          const json = JSON.stringify(cloned);
+          const bytes = typeof json === "string" ? json.length : 0;
+          if (typeof maxBytes === "number" && maxBytes > 0 && bytes > maxBytes) {
+            throw {
+              code: "E_BODY_TOO_LARGE",
+              message: "serialized value exceeds max-bytes",
+              details: { bytes, maxBytes }
+            };
+          }
+          return { value: cloned, bytes };
+        };
+        const parsePath = (path) => {
+          if (typeof path !== "string" || !path.trim()) {
+            throw { code: "E_INVALID_PARAMS", message: "path is required" };
+          }
+          const normalized = path.replace(/^globalThis\.?/, "").replace(/^window\.?/, "").trim();
+          if (!normalized) {
+            return [];
+          }
+          const segments = [];
+          let index = 0;
+          while (index < normalized.length) {
+            if (normalized[index] === ".") {
+              index += 1;
+              continue;
+            }
+            if (normalized[index] === "[") {
+              const bracket = normalized.slice(index).match(/^\[(\d+)\]/);
+              if (!bracket) {
+                throw { code: "E_INVALID_PARAMS", message: "Only numeric bracket paths are supported" };
+              }
+              segments.push(Number(bracket[1]));
+              index += bracket[0].length;
+              continue;
+            }
+            const identifier = normalized.slice(index).match(/^[A-Za-z_$][\w$]*/);
+            if (!identifier) {
+              throw { code: "E_INVALID_PARAMS", message: `Unsupported path token near: ${normalized.slice(index, index + 16)}` };
+            }
+            segments.push(identifier[0]);
+            index += identifier[0].length;
+          }
+          return segments;
+        };
+        const resolveFrameWindow = (frameSelectors) => {
+          let currentWindow = window;
+          let currentDocument = document;
+          for (const selector of frameSelectors) {
+            const frame = currentDocument.querySelector(selector);
+            if (!frame || !("contentWindow" in frame)) {
+              throw { code: "E_NOT_FOUND", message: `frame not found: ${selector}` };
+            }
+            const nextWindow = frame.contentWindow;
+            if (!nextWindow) {
+              throw { code: "E_NOT_READY", message: `frame window unavailable: ${selector}` };
+            }
+            currentWindow = nextWindow;
+            currentDocument = nextWindow.document;
+          }
+          return currentWindow;
+        };
+        try {
+          const targetWindow = payload.scope === "main" ? window : payload.scope === "current" ? resolveFrameWindow(payload.framePath ?? []) : window;
+          if (payload.action === "eval") {
+            const evaluator = targetWindow.eval;
+            const serialized = serializeValue(evaluator(payload.expr), payload.maxBytes);
+            return { url: targetWindow.location.href, framePath: payload.scope === "current" ? payload.framePath ?? [] : [], value: serialized.value, bytes: serialized.bytes };
+          }
+          if (payload.action === "extract") {
+            const segments = parsePath(payload.path);
+            let current = targetWindow;
+            for (const segment of segments) {
+              if (current === null || current === void 0 || !(segment in current)) {
+                throw { code: "E_NOT_FOUND", message: `path not found: ${payload.path}` };
+              }
+              current = current[segment];
+            }
+            const serialized = serializeValue(current, payload.maxBytes);
+            return { url: targetWindow.location.href, framePath: payload.scope === "current" ? payload.framePath ?? [] : [], value: serialized.value, bytes: serialized.bytes };
+          }
+          if (payload.action === "fetch") {
+            const headers = { ...payload.headers ?? {} };
+            if (payload.contentType && !headers["Content-Type"]) {
+              headers["Content-Type"] = payload.contentType;
+            }
+            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;
+            try {
+              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
+              });
+            } finally {
+              if (timeoutId !== null) {
+                window.clearTimeout(timeoutId);
+              }
+            }
+            const bodyText = await response.text();
+            const headerMap = {};
+            response.headers.forEach((value, key) => {
+              headerMap[key] = value;
+            });
+            return {
+              url: targetWindow.location.href,
+              framePath: payload.scope === "current" ? payload.framePath ?? [] : [],
+              value: (() => {
+                const encoder = typeof TextEncoder === "function" ? new TextEncoder() : null;
+                const decoder = typeof TextDecoder === "function" ? new TextDecoder() : null;
+                const previewLimit = typeof payload.maxBytes === "number" && payload.maxBytes > 0 ? payload.maxBytes : 8192;
+                const encodedBody = encoder ? encoder.encode(bodyText) : null;
+                const bodyBytes = encodedBody ? encodedBody.byteLength : bodyText.length;
+                const truncated = bodyBytes > previewLimit;
+                if (payload.mode === "json" && truncated) {
+                  throw {
+                    code: "E_BODY_TOO_LARGE",
+                    message: "JSON response exceeds max-bytes",
+                    details: {
+                      bytes: bodyBytes,
+                      maxBytes: previewLimit
+                    }
+                  };
+                }
+                const previewText = encodedBody && decoder ? decoder.decode(encodedBody.subarray(0, Math.min(encodedBody.byteLength, previewLimit))) : truncated ? bodyText.slice(0, previewLimit) : bodyText;
+                return {
+                  url: response.url,
+                  status: response.status,
+                  ok: response.ok,
+                  headers: headerMap,
+                  contentType: response.headers.get("content-type") ?? void 0,
+                  bodyText: payload.mode === "json" ? void 0 : previewText,
+                  json: payload.mode === "json" && bodyText ? JSON.parse(bodyText) : void 0,
+                  bytes: bodyBytes,
+                  truncated
+                };
+              })()
+            };
+          }
+          throw { code: "E_NOT_FOUND", message: `Unsupported page world action: ${payload.action}` };
+        } catch (error) {
+          return {
+            url: window.location.href,
+            framePath: payload.scope === "current" ? payload.framePath ?? [] : [],
+            error: typeof error === "object" && error !== null && "code" in error ? error : { code: "E_EXECUTION", message: error instanceof Error ? error.message : String(error) }
+          };
+        }
+      }
+    });
+    if (scope === "all-frames") {
+      return {
+        scope,
+        results: results.map((item) => item.result ?? { url: "", framePath: [] })
+      };
+    }
+    return {
+      scope,
+      result: results[0]?.result ?? { url: "", framePath }
+    };
+  }
+  function truncateNetworkEntry(entry, bodyBytes) {
+    if (typeof bodyBytes !== "number" || !Number.isFinite(bodyBytes) || bodyBytes <= 0) {
+      return entry;
+    }
+    const maxBytes = Math.max(1, Math.floor(bodyBytes));
+    const clone = { ...entry };
+    if (typeof clone.requestBodyPreview === "string") {
+      const requestBytes = textEncoder2.encode(clone.requestBodyPreview);
+      if (requestBytes.byteLength > maxBytes) {
+        clone.requestBodyPreview = textDecoder2.decode(requestBytes.subarray(0, maxBytes));
+        clone.requestBodyTruncated = true;
+        clone.truncated = true;
+      }
+    }
+    if (typeof clone.responseBodyPreview === "string") {
+      const responseBytes = textEncoder2.encode(clone.responseBodyPreview);
+      if (responseBytes.byteLength > maxBytes) {
+        clone.responseBodyPreview = textDecoder2.decode(responseBytes.subarray(0, maxBytes));
+        clone.responseBodyTruncated = true;
+        clone.truncated = true;
+      }
+    }
+    return clone;
+  }
+  function filterNetworkEntrySections(entry, include) {
+    if (!Array.isArray(include)) {
+      return entry;
+    }
+    const sections = new Set(
+      include.map(String).filter((section) => section === "request" || section === "response")
+    );
+    if (sections.size === 0 || sections.size === 2) {
+      return entry;
+    }
+    const clone = { ...entry };
+    if (!sections.has("request")) {
+      delete clone.requestHeaders;
+      delete clone.requestBodyPreview;
+      delete clone.requestBodyTruncated;
+    }
+    if (!sections.has("response")) {
+      delete clone.responseHeaders;
+      delete clone.responseBodyPreview;
+      delete clone.responseBodyTruncated;
+      delete clone.binary;
+    }
+    return clone;
+  }
+  function replayHeadersFromEntry(entry) {
+    if (!entry.requestHeaders) {
+      return void 0;
+    }
+    const headers = {};
+    for (const [name, value] of Object.entries(entry.requestHeaders)) {
+      const normalizedName = name.toLowerCase();
+      if (REPLAY_FORBIDDEN_HEADER_NAMES.has(normalizedName) || normalizedName.startsWith("sec-")) {
+        continue;
+      }
+      if (containsRedactionMarker(value)) {
+        continue;
+      }
+      headers[name] = value;
+    }
+    return Object.keys(headers).length > 0 ? headers : void 0;
+  }
+  function parseTimestampCandidate(value, now = Date.now()) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized) {
+      return null;
+    }
+    if (normalized === "today") {
+      return now;
+    }
+    if (normalized === "yesterday") {
+      return now - 24 * 60 * 60 * 1e3;
+    }
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  function extractLatestTimestamp(values, now = Date.now()) {
+    if (!Array.isArray(values) || values.length === 0) {
+      return null;
+    }
+    let latest = null;
+    for (const value of values) {
+      const parsed = parseTimestampCandidate(value, now);
+      if (parsed === null) {
+        continue;
+      }
+      latest = latest === null ? parsed : Math.max(latest, parsed);
+    }
+    return latest;
+  }
+  function computeFreshnessAssessment(input) {
+    const now = Date.now();
+    const latestDataTimestamp = [input.latestInlineDataTimestamp, input.domVisibleTimestamp].filter((value) => typeof value === "number").sort((left, right) => right - left)[0] ?? null;
+    if (latestDataTimestamp !== null && now - latestDataTimestamp <= input.freshWindowMs) {
+      return "fresh";
+    }
+    const recentSignals = [input.latestNetworkTimestamp, input.lastMutationAt].filter((value) => typeof value === "number").some((value) => now - value <= input.freshWindowMs);
+    if (recentSignals && latestDataTimestamp !== null && now - latestDataTimestamp > input.freshWindowMs) {
+      return "lagged";
+    }
+    const staleSignals = [input.latestNetworkTimestamp, input.lastMutationAt, latestDataTimestamp].filter((value) => typeof value === "number");
+    if (staleSignals.length > 0 && staleSignals.every((value) => now - value > input.staleWindowMs)) {
+      return "stale";
+    }
+    return "unknown";
+  }
+  async function collectPageInspection(tabId, params = {}) {
+    return await forwardContentRpc(tabId, "bak.internal.inspectState", params);
+  }
+  async function buildFreshnessForTab(tabId, params = {}) {
+    const inspection = await collectPageInspection(tabId, params);
+    const visibleTimestamps = Array.isArray(inspection.visibleTimestamps) ? inspection.visibleTimestamps.map(String) : [];
+    const inlineTimestamps = Array.isArray(inspection.inlineTimestamps) ? inspection.inlineTimestamps.map(String) : [];
+    const now = Date.now();
+    const freshWindowMs = typeof params.freshWindowMs === "number" ? Math.max(1, Math.floor(params.freshWindowMs)) : 15 * 60 * 1e3;
+    const staleWindowMs = typeof params.staleWindowMs === "number" ? Math.max(freshWindowMs, Math.floor(params.staleWindowMs)) : 24 * 60 * 60 * 1e3;
+    const latestInlineDataTimestamp = extractLatestTimestamp(inlineTimestamps, now);
+    const domVisibleTimestamp = extractLatestTimestamp(visibleTimestamps, now);
+    const latestNetworkTs = latestNetworkTimestamp(tabId);
+    const lastMutationAt = typeof inspection.lastMutationAt === "number" ? inspection.lastMutationAt : null;
+    return {
+      pageLoadedAt: typeof inspection.pageLoadedAt === "number" ? inspection.pageLoadedAt : null,
+      lastMutationAt,
+      latestNetworkTimestamp: latestNetworkTs,
+      latestInlineDataTimestamp,
+      domVisibleTimestamp,
+      assessment: computeFreshnessAssessment({
+        latestInlineDataTimestamp,
+        latestNetworkTimestamp: latestNetworkTs,
+        domVisibleTimestamp,
+        lastMutationAt,
+        freshWindowMs,
+        staleWindowMs
+      }),
+      evidence: {
+        visibleTimestamps,
+        inlineTimestamps,
+        networkSampleIds: recentNetworkSampleIds(tabId)
+      }
+    };
+  }
   async function handleRequest(request) {
     const params = request.params ?? {};
     const target = {
@@ -1329,11 +2139,10 @@
       "context.enterShadow",
       "context.exitShadow",
       "context.reset",
-      "network.list",
-      "network.get",
-      "network.waitFor",
-      "network.clear",
-      "debug.dumpState"
+      "table.list",
+      "table.schema",
+      "table.rows",
+      "table.export"
     ]);
     switch (request.method) {
       case "session.ping": {
@@ -1396,11 +2205,15 @@
       }
       case "workspace.ensure": {
         return preserveHumanFocus(params.focus !== true, async () => {
-          return await bindingManager.ensureWorkspace({
+          const result = await bindingManager.ensureWorkspace({
             workspaceId: String(params.workspaceId ?? ""),
             focus: params.focus === true,
             initialUrl: typeof params.url === "string" ? params.url : void 0
           });
+          for (const tab of result.workspace.tabs) {
+            void ensureNetworkDebugger(tab.id).catch(() => void 0);
+          }
+          return result;
         });
       }
       case "workspace.info": {
@@ -1418,7 +2231,9 @@
             focus: params.focus === true
           });
         });
-        return await finalizeOpenedWorkspaceTab(opened, expectedUrl);
+        const finalized = await finalizeOpenedWorkspaceTab(opened, expectedUrl);
+        void ensureNetworkDebugger(finalized.tab.id).catch(() => void 0);
+        return finalized;
       }
       case "workspace.listTabs": {
         return await bindingManager.listTabs(String(params.workspaceId ?? ""));
@@ -1427,7 +2242,9 @@
         return await bindingManager.getActiveTab(String(params.workspaceId ?? ""));
       }
       case "workspace.setActiveTab": {
-        return await bindingManager.setActiveTab(Number(params.tabId), String(params.workspaceId ?? ""));
+        const result = await bindingManager.setActiveTab(Number(params.tabId), String(params.workspaceId ?? ""));
+        void ensureNetworkDebugger(result.tab.id).catch(() => void 0);
+        return result;
       }
       case "workspace.focus": {
         return await bindingManager.focus(String(params.workspaceId ?? ""));
@@ -1449,6 +2266,7 @@
           const tab = await withTab(target, {
             requireSupportedAutomationUrl: false
           });
+          void ensureNetworkDebugger(tab.id).catch(() => void 0);
           const url = String(params.url ?? "about:blank");
           await chrome.tabs.update(tab.id, { url });
           await waitForTabUrl(tab.id, url);
@@ -1460,6 +2278,7 @@
       case "page.back": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
           const tab = await withTab(target);
+          void ensureNetworkDebugger(tab.id).catch(() => void 0);
           await chrome.tabs.goBack(tab.id);
           await waitForTabComplete(tab.id);
           return { ok: true };
@@ -1468,6 +2287,7 @@
       case "page.forward": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
           const tab = await withTab(target);
+          void ensureNetworkDebugger(tab.id).catch(() => void 0);
           await chrome.tabs.goForward(tab.id);
           await waitForTabComplete(tab.id);
           return { ok: true };
@@ -1476,6 +2296,7 @@
       case "page.reload": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
           const tab = await withTab(target);
+          void ensureNetworkDebugger(tab.id).catch(() => void 0);
           await chrome.tabs.reload(tab.id);
           await waitForTabComplete(tab.id);
           return { ok: true };
@@ -1507,6 +2328,24 @@
           };
         });
       }
+      case "page.eval": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          return await executePageWorld(tab.id, "eval", params);
+        });
+      }
+      case "page.extract": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          return await executePageWorld(tab.id, "extract", params);
+        });
+      }
+      case "page.fetch": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          return await executePageWorld(tab.id, "fetch", params);
+        });
+      }
       case "page.snapshot": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
           const tab = await withTab(target);
@@ -1601,6 +2440,273 @@
           return { entries: response.entries };
         });
       }
+      case "network.list": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          try {
+            await ensureTabNetworkCapture(tab.id);
+            return {
+              entries: listNetworkEntries(tab.id, {
+                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
+              })
+            };
+          } catch {
+            return await forwardContentRpc(tab.id, "network.list", params);
+          }
+        });
+      }
+      case "network.get": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          try {
+            await ensureTabNetworkCapture(tab.id);
+            const entry = getNetworkEntry(tab.id, String(params.id ?? ""));
+            if (!entry) {
+              throw toError("E_NOT_FOUND", `network entry not found: ${String(params.id ?? "")}`);
+            }
+            const filtered = filterNetworkEntrySections(
+              truncateNetworkEntry(entry, typeof params.bodyBytes === "number" ? params.bodyBytes : void 0),
+              params.include
+            );
+            return { entry: filtered };
+          } catch (error) {
+            if (error?.code === "E_NOT_FOUND") {
+              throw error;
+            }
+            return await forwardContentRpc(tab.id, "network.get", params);
+          }
+        });
+      }
+      case "network.search": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureTabNetworkCapture(tab.id);
+          return {
+            entries: searchNetworkEntries(
+              tab.id,
+              String(params.pattern ?? ""),
+              typeof params.limit === "number" ? params.limit : 50
+            )
+          };
+        });
+      }
+      case "network.waitFor": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          try {
+            await ensureTabNetworkCapture(tab.id);
+          } catch {
+            return await forwardContentRpc(tab.id, "network.waitFor", params);
+          }
+          return {
+            entry: await waitForNetworkEntry(tab.id, {
+              limit: 1,
+              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,
+              timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : void 0
+            })
+          };
+        });
+      }
+      case "network.clear": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          clearNetworkEntries(tab.id);
+          await forwardContentRpc(tab.id, "network.clear", params).catch(() => void 0);
+          return { ok: true };
+        });
+      }
+      case "network.replay": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureTabNetworkCapture(tab.id);
+          const entry = getNetworkEntry(tab.id, String(params.id ?? ""));
+          if (!entry) {
+            throw toError("E_NOT_FOUND", `network entry not found: ${String(params.id ?? "")}`);
+          }
+          if (entry.requestBodyTruncated === true) {
+            throw toError("E_BODY_TOO_LARGE", "captured request body was truncated and cannot be replayed safely", {
+              requestId: entry.id,
+              requestBytes: entry.requestBytes
+            });
+          }
+          if (containsRedactionMarker(entry.requestBodyPreview)) {
+            throw toError("E_EXECUTION", "captured request body was redacted and cannot be replayed safely", {
+              requestId: entry.id
+            });
+          }
+          const replayed = await executePageWorld(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;
+            })(),
+            mode: params.mode,
+            timeoutMs: params.timeoutMs,
+            maxBytes: params.maxBytes,
+            scope: "current"
+          });
+          const frameResult = replayed.result ?? replayed.results?.find((candidate) => candidate.value || candidate.error);
+          if (frameResult?.error) {
+            throw toError(frameResult.error.code ?? "E_EXECUTION", frameResult.error.message, frameResult.error.details);
+          }
+          const first = frameResult?.value;
+          if (!first) {
+            throw toError("E_EXECUTION", "network replay returned no response payload");
+          }
+          return first;
+        });
+      }
+      case "page.freshness": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureNetworkDebugger(tab.id).catch(() => void 0);
+          return await buildFreshnessForTab(tab.id, params);
+        });
+      }
+      case "debug.dumpState": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureNetworkDebugger(tab.id).catch(() => void 0);
+          const dump = await forwardContentRpc(tab.id, "debug.dumpState", params);
+          const inspection = await collectPageInspection(tab.id, params);
+          const network = listNetworkEntries(tab.id, {
+            limit: typeof params.networkLimit === "number" ? params.networkLimit : 80
+          });
+          const sections = Array.isArray(params.section) ? new Set(params.section.map(String)) : null;
+          const result = {
+            ...dump,
+            network,
+            scripts: inspection.scripts,
+            globalsPreview: inspection.globalsPreview,
+            storage: inspection.storage,
+            frames: inspection.frames,
+            networkSummary: {
+              total: network.length,
+              recent: network.slice(0, Math.min(10, network.length))
+            }
+          };
+          if (!sections || sections.size === 0) {
+            return result;
+          }
+          const filtered = {
+            url: result.url,
+            title: result.title,
+            context: result.context
+          };
+          if (sections.has("dom")) {
+            filtered.dom = result.dom;
+          }
+          if (sections.has("visible-text")) {
+            filtered.text = result.text;
+            filtered.elements = result.elements;
+          }
+          if (sections.has("scripts")) {
+            filtered.scripts = result.scripts;
+          }
+          if (sections.has("globals-preview")) {
+            filtered.globalsPreview = result.globalsPreview;
+          }
+          if (sections.has("network-summary")) {
+            filtered.networkSummary = result.networkSummary;
+          }
+          if (sections.has("storage")) {
+            filtered.storage = result.storage;
+          }
+          if (sections.has("frames")) {
+            filtered.frames = result.frames;
+          }
+          if (params.includeAccessibility === true && "accessibility" in result) {
+            filtered.accessibility = result.accessibility;
+          }
+          if ("snapshot" in result) {
+            filtered.snapshot = result.snapshot;
+          }
+          return filtered;
+        });
+      }
+      case "inspect.pageData": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureNetworkDebugger(tab.id).catch(() => void 0);
+          const inspection = await collectPageInspection(tab.id, params);
+          const network = listNetworkEntries(tab.id, { limit: 10 });
+          return {
+            suspiciousGlobals: inspection.suspiciousGlobals ?? [],
+            tables: inspection.tables ?? [],
+            visibleTimestamps: inspection.visibleTimestamps ?? [],
+            inlineTimestamps: inspection.inlineTimestamps ?? [],
+            recentNetwork: network,
+            recommendedNextSteps: [
+              "bak page extract --path table_data",
+              "bak network search --pattern table_data",
+              "bak page freshness"
+            ]
+          };
+        });
+      }
+      case "inspect.liveUpdates": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureNetworkDebugger(tab.id).catch(() => void 0);
+          const inspection = await collectPageInspection(tab.id, params);
+          const network = listNetworkEntries(tab.id, { limit: 25 });
+          return {
+            lastMutationAt: inspection.lastMutationAt ?? null,
+            timers: inspection.timers ?? { timeouts: 0, intervals: 0 },
+            networkCount: network.length,
+            recentNetwork: network.slice(0, 10)
+          };
+        });
+      }
+      case "inspect.freshness": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          const freshness = await buildFreshnessForTab(tab.id, params);
+          return {
+            ...freshness,
+            lagMs: typeof freshness.latestNetworkTimestamp === "number" && typeof freshness.latestInlineDataTimestamp === "number" ? Math.max(0, freshness.latestNetworkTimestamp - freshness.latestInlineDataTimestamp) : null
+          };
+        });
+      }
+      case "capture.snapshot": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureNetworkDebugger(tab.id).catch(() => void 0);
+          const inspection = await collectPageInspection(tab.id, params);
+          return {
+            url: inspection.url ?? tab.url ?? "",
+            title: inspection.title ?? tab.title ?? "",
+            html: inspection.html ?? "",
+            visibleText: inspection.visibleText ?? [],
+            cookies: inspection.cookies ?? [],
+            storage: inspection.storage ?? { localStorageKeys: [], sessionStorageKeys: [] },
+            context: inspection.context ?? { tabId: tab.id, framePath: [], shadowPath: [] },
+            freshness: await buildFreshnessForTab(tab.id, params),
+            network: listNetworkEntries(tab.id, {
+              limit: typeof params.networkLimit === "number" ? params.networkLimit : 20
+            }),
+            capturedAt: Date.now()
+          };
+        });
+      }
+      case "capture.har": {
+        return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
+          const tab = await withTab(target);
+          await ensureTabNetworkCapture(tab.id);
+          return {
+            har: exportHar(tab.id, typeof params.limit === "number" ? params.limit : void 0)
+          };
+        });
+      }
       case "ui.selectCandidate": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
           const tab = await withTab(target);
@@ -1671,7 +2777,7 @@
       ws?.send(JSON.stringify({
         type: "hello",
         role: "extension",
-        version: "0.5.0",
+        version: "0.6.0",
         ts: Date.now()
       }));
     });
@@ -1706,6 +2812,7 @@
     });
   }
   chrome.tabs.onRemoved.addListener((tabId) => {
+    dropNetworkCapture(tabId);
     void listWorkspaceStates().then(async (states) => {
       for (const state of states) {
         if (!state.tabIds.includes(tabId)) {