@flrande/bak-extension 0.3.8 → 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) {
@@ -30,42 +463,95 @@
     return Math.min(maxDelayMs, baseDelayMs * 2 ** safeAttempt);
   }
 
+  // src/session-binding-storage.ts
+  var STORAGE_KEY_SESSION_BINDINGS = "sessionBindings";
+  var LEGACY_STORAGE_KEY_WORKSPACES = "agentWorkspaces";
+  var LEGACY_STORAGE_KEY_WORKSPACE = "agentWorkspace";
+  function isWorkspaceRecord(value) {
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === "string" && Array.isArray(candidate.tabIds) && (typeof candidate.windowId === "number" || candidate.windowId === null) && (typeof candidate.groupId === "number" || candidate.groupId === null) && (typeof candidate.activeTabId === "number" || candidate.activeTabId === null) && (typeof candidate.primaryTabId === "number" || candidate.primaryTabId === null);
+  }
+  function cloneWorkspaceRecord(state) {
+    return {
+      ...state,
+      tabIds: [...state.tabIds]
+    };
+  }
+  function normalizeWorkspaceRecordMap(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return {
+        found: false,
+        map: {}
+      };
+    }
+    const normalizedEntries = [];
+    for (const [workspaceId, entry] of Object.entries(value)) {
+      if (!isWorkspaceRecord(entry)) {
+        continue;
+      }
+      normalizedEntries.push([workspaceId, cloneWorkspaceRecord(entry)]);
+    }
+    return {
+      found: true,
+      map: Object.fromEntries(normalizedEntries)
+    };
+  }
+  function resolveSessionBindingStateMap(stored) {
+    const current = normalizeWorkspaceRecordMap(stored[STORAGE_KEY_SESSION_BINDINGS]);
+    if (current.found) {
+      return current.map;
+    }
+    const legacyMap = normalizeWorkspaceRecordMap(stored[LEGACY_STORAGE_KEY_WORKSPACES]);
+    if (legacyMap.found) {
+      return legacyMap.map;
+    }
+    const legacySingle = stored[LEGACY_STORAGE_KEY_WORKSPACE];
+    if (isWorkspaceRecord(legacySingle)) {
+      return {
+        [legacySingle.id]: cloneWorkspaceRecord(legacySingle)
+      };
+    }
+    return {};
+  }
+
   // src/workspace.ts
-  var DEFAULT_WORKSPACE_ID = "default";
   var DEFAULT_WORKSPACE_LABEL = "bak agent";
   var DEFAULT_WORKSPACE_COLOR = "blue";
   var DEFAULT_WORKSPACE_URL = "about:blank";
-  var WorkspaceManager = class {
+  var SessionBindingManager = class {
     storage;
     browser;
     constructor(storage, browser) {
       this.storage = storage;
       this.browser = browser;
     }
-    async getWorkspaceInfo(workspaceId = DEFAULT_WORKSPACE_ID) {
+    async getWorkspaceInfo(workspaceId) {
       return this.inspectWorkspace(workspaceId);
     }
     async ensureWorkspace(options = {}) {
       const workspaceId = this.normalizeWorkspaceId(options.workspaceId);
       const repairActions = [];
       const initialUrl = options.initialUrl ?? DEFAULT_WORKSPACE_URL;
-      const persisted = await this.storage.load();
+      const persisted = await this.storage.load(workspaceId);
       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
@@ -75,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) {
@@ -100,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");
@@ -163,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);
@@ -263,7 +749,7 @@
         tab
       };
     }
-    async listTabs(workspaceId = DEFAULT_WORKSPACE_ID) {
+    async listTabs(workspaceId) {
       const ensured = await this.inspectWorkspace(workspaceId);
       if (!ensured) {
         throw new Error(`Workspace ${workspaceId} does not exist`);
@@ -273,7 +759,7 @@
         tabs: ensured.tabs
       };
     }
-    async getActiveTab(workspaceId = DEFAULT_WORKSPACE_ID) {
+    async getActiveTab(workspaceId) {
       const ensured = await this.inspectWorkspace(workspaceId);
       if (!ensured) {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
@@ -290,7 +776,7 @@
         tab: ensured.tabs.find((tab) => tab.id === ensured.activeTabId) ?? null
       };
     }
-    async setActiveTab(tabId, workspaceId = DEFAULT_WORKSPACE_ID) {
+    async setActiveTab(tabId, workspaceId) {
       const ensured = await this.ensureWorkspace({ workspaceId });
       if (!ensured.workspace.tabIds.includes(tabId)) {
         throw new Error(`Tab ${tabId} does not belong to workspace ${workspaceId}`);
@@ -319,7 +805,7 @@
         tab
       };
     }
-    async focus(workspaceId = DEFAULT_WORKSPACE_ID) {
+    async focus(workspaceId) {
       const ensured = await this.ensureWorkspace({ workspaceId, focus: false });
       if (ensured.workspace.activeTabId !== null) {
         await this.browser.updateTab(ensured.workspace.activeTabId, { active: true });
@@ -331,16 +817,20 @@
       return { ok: true, workspace: refreshed.workspace };
     }
     async reset(options = {}) {
-      await this.close(options.workspaceId);
-      return this.ensureWorkspace(options);
+      const workspaceId = this.normalizeWorkspaceId(options.workspaceId);
+      await this.close(workspaceId);
+      return this.ensureWorkspace({
+        ...options,
+        workspaceId
+      });
     }
-    async close(workspaceId = DEFAULT_WORKSPACE_ID) {
-      const state = await this.storage.load();
-      if (!state || state.id !== workspaceId) {
-        await this.storage.save(null);
+    async close(workspaceId) {
+      const state = await this.loadWorkspaceRecord(workspaceId);
+      if (!state) {
+        await this.storage.delete(workspaceId);
         return { ok: true };
       }
-      await this.storage.save(null);
+      await this.storage.delete(workspaceId);
       if (state.windowId !== null) {
         const existingWindow = await this.browser.getWindow(state.windowId);
         if (existingWindow) {
@@ -366,19 +856,11 @@
       }
       const explicitWorkspaceId = typeof options.workspaceId === "string" ? this.normalizeWorkspaceId(options.workspaceId) : void 0;
       if (explicitWorkspaceId) {
-        const ensured2 = await this.ensureWorkspace({
+        const ensured = await this.ensureWorkspace({
           workspaceId: explicitWorkspaceId,
           focus: false
         });
-        return this.buildWorkspaceResolution(ensured2, "explicit-workspace");
-      }
-      const existingWorkspace = await this.loadWorkspaceRecord(DEFAULT_WORKSPACE_ID);
-      if (existingWorkspace) {
-        const ensured2 = await this.ensureWorkspace({
-          workspaceId: existingWorkspace.id,
-          focus: false
-        });
-        return this.buildWorkspaceResolution(ensured2, "default-workspace");
+        return this.buildWorkspaceResolution(ensured, "explicit-workspace");
       }
       if (options.createIfMissing !== true) {
         const activeTab = await this.browser.getActiveTab();
@@ -394,19 +876,12 @@
           repairActions: []
         };
       }
-      const ensured = await this.ensureWorkspace({
-        workspaceId: DEFAULT_WORKSPACE_ID,
-        focus: false
-      });
-      return this.buildWorkspaceResolution(ensured, "default-workspace");
+      throw new Error("workspaceId is required when createIfMissing is true");
     }
     normalizeWorkspaceId(workspaceId) {
       const candidate = workspaceId?.trim();
       if (!candidate) {
-        return DEFAULT_WORKSPACE_ID;
-      }
-      if (candidate !== DEFAULT_WORKSPACE_ID) {
-        throw new Error(`Unsupported workspace id: ${candidate}`);
+        throw new Error("workspaceId is required");
       }
       return candidate;
     }
@@ -422,9 +897,12 @@
         primaryTabId: state?.primaryTabId ?? null
       };
     }
-    async loadWorkspaceRecord(workspaceId = DEFAULT_WORKSPACE_ID) {
+    async listWorkspaceRecords() {
+      return await this.storage.list();
+    }
+    async loadWorkspaceRecord(workspaceId) {
       const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
-      const state = await this.storage.load();
+      const state = await this.storage.load(normalizedWorkspaceId);
       if (!state || state.id !== normalizedWorkspaceId) {
         return null;
       }
@@ -511,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);
@@ -533,7 +1011,7 @@
             state.activeTabId = tabs.find((tab) => tab.active)?.id ?? state.primaryTabId;
           }
         }
-        return { window, tabs };
+        return { window: window2, tabs };
       }
       return null;
     }
@@ -548,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) {
@@ -560,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
         });
@@ -572,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;
@@ -581,7 +1059,7 @@
         await this.browser.closeTab(workspaceTab.id);
       }
       return {
-        window,
+        window: window2,
         tabs: await this.readTrackedTabs(state.tabIds, state.windowId)
       };
     }
@@ -659,7 +1137,7 @@
       }
       throw lastError2 ?? new Error(`No window with id: ${options.windowId}.`);
     }
-    async inspectWorkspace(workspaceId = DEFAULT_WORKSPACE_ID) {
+    async inspectWorkspace(workspaceId) {
       const state = await this.loadWorkspaceRecord(workspaceId);
       if (!state) {
         return null;
@@ -711,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);
       }
@@ -755,8 +1233,21 @@
   var STORAGE_KEY_TOKEN = "pairToken";
   var STORAGE_KEY_PORT = "cliPort";
   var STORAGE_KEY_DEBUG_RICH_TEXT = "debugRichText";
-  var STORAGE_KEY_WORKSPACE = "agentWorkspace";
   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;
@@ -817,6 +1308,12 @@
     if (lower.includes("no tab with id") || lower.includes("no window with id")) {
       return toError("E_NOT_FOUND", message);
     }
+    if (lower.includes("workspace") && lower.includes("does not exist")) {
+      return toError("E_NOT_FOUND", message);
+    }
+    if (lower.includes("does not belong to workspace") || lower.includes("is missing from workspace")) {
+      return toError("E_NOT_FOUND", message);
+    }
     if (lower.includes("invalid url") || lower.includes("url is invalid")) {
       return toError("E_INVALID_PARAMS", message);
     }
@@ -838,20 +1335,36 @@
       groupId: typeof tab.groupId === "number" && tab.groupId >= 0 ? tab.groupId : null
     };
   }
-  async function loadWorkspaceState() {
-    const stored = await chrome.storage.local.get(STORAGE_KEY_WORKSPACE);
-    const state = stored[STORAGE_KEY_WORKSPACE];
-    if (!state || typeof state !== "object") {
-      return null;
-    }
-    return state;
+  async function loadWorkspaceStateMap() {
+    const stored = await chrome.storage.local.get([
+      STORAGE_KEY_SESSION_BINDINGS,
+      LEGACY_STORAGE_KEY_WORKSPACES,
+      LEGACY_STORAGE_KEY_WORKSPACE
+    ]);
+    return resolveSessionBindingStateMap(stored);
+  }
+  async function loadWorkspaceState(workspaceId) {
+    const stateMap = await loadWorkspaceStateMap();
+    return stateMap[workspaceId] ?? null;
+  }
+  async function listWorkspaceStates() {
+    return Object.values(await loadWorkspaceStateMap());
   }
   async function saveWorkspaceState(state) {
-    if (state === null) {
-      await chrome.storage.local.remove(STORAGE_KEY_WORKSPACE);
+    const stateMap = await loadWorkspaceStateMap();
+    stateMap[state.id] = state;
+    await chrome.storage.local.set({ [STORAGE_KEY_SESSION_BINDINGS]: stateMap });
+    await chrome.storage.local.remove([LEGACY_STORAGE_KEY_WORKSPACES, LEGACY_STORAGE_KEY_WORKSPACE]);
+  }
+  async function deleteWorkspaceState(workspaceId) {
+    const stateMap = await loadWorkspaceStateMap();
+    delete stateMap[workspaceId];
+    if (Object.keys(stateMap).length === 0) {
+      await chrome.storage.local.remove([STORAGE_KEY_SESSION_BINDINGS, LEGACY_STORAGE_KEY_WORKSPACES, LEGACY_STORAGE_KEY_WORKSPACE]);
       return;
     }
-    await chrome.storage.local.set({ [STORAGE_KEY_WORKSPACE]: state });
+    await chrome.storage.local.set({ [STORAGE_KEY_SESSION_BINDINGS]: stateMap });
+    await chrome.storage.local.remove([LEGACY_STORAGE_KEY_WORKSPACES, LEGACY_STORAGE_KEY_WORKSPACE]);
   }
   var workspaceBrowser = {
     async getTab(tabId) {
@@ -899,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",
@@ -983,10 +1496,12 @@
       };
     }
   };
-  var workspaceManager = new WorkspaceManager(
+  var bindingManager = new SessionBindingManager(
     {
       load: loadWorkspaceState,
-      save: saveWorkspaceState
+      save: saveWorkspaceState,
+      delete: deleteWorkspaceState,
+      list: listWorkspaceStates
     },
     workspaceBrowser
   );
@@ -1094,7 +1609,7 @@
     } catch {
       refreshedTab = await workspaceBrowser.getTab(opened.tab.id) ?? opened.tab;
     }
-    const refreshedWorkspace = await workspaceManager.getWorkspaceInfo(opened.workspace.id) ?? {
+    const refreshedWorkspace = await bindingManager.getWorkspaceInfo(opened.workspace.id) ?? {
       ...opened.workspace,
       tabs: opened.workspace.tabs.map((tab) => tab.id === refreshedTab.id ? refreshedTab : tab)
     };
@@ -1121,7 +1636,7 @@
       const tab2 = await chrome.tabs.get(target.tabId);
       return validate(tab2);
     }
-    const resolved = await workspaceManager.resolveTarget({
+    const resolved = await bindingManager.resolveTarget({
       tabId: target.tabId,
       workspaceId: typeof target.workspaceId === "string" ? target.workspaceId : void 0,
       createIfMissing: false
@@ -1222,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 = {
@@ -1254,16 +2132,17 @@
       "mouse.click",
       "mouse.wheel",
       "file.upload",
+      "context.get",
+      "context.set",
       "context.enterFrame",
       "context.exitFrame",
       "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": {
@@ -1301,24 +2180,6 @@
         return { ok: true };
       }
       case "tabs.new": {
-        if (typeof params.workspaceId === "string" || params.windowId === void 0) {
-          const expectedUrl = params.url ?? "about:blank";
-          const opened = await preserveHumanFocus(true, async () => {
-            return await workspaceManager.openTab({
-              workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : DEFAULT_WORKSPACE_ID,
-              url: expectedUrl,
-              active: params.active === true,
-              focus: false
-            });
-          });
-          const stabilized = await finalizeOpenedWorkspaceTab(opened, expectedUrl);
-          return {
-            tabId: stabilized.tab.id,
-            windowId: stabilized.tab.windowId,
-            groupId: stabilized.workspace.groupId,
-            workspaceId: stabilized.workspace.id
-          };
-        }
         const tab = await chrome.tabs.create({
           url: params.url ?? "about:blank",
           windowId: typeof params.windowId === "number" ? params.windowId : void 0,
@@ -1344,59 +2205,68 @@
       }
       case "workspace.ensure": {
         return preserveHumanFocus(params.focus !== true, async () => {
-          return await workspaceManager.ensureWorkspace({
-            workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0,
+          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": {
         return {
-          workspace: await workspaceManager.getWorkspaceInfo(typeof params.workspaceId === "string" ? params.workspaceId : void 0)
+          workspace: await bindingManager.getWorkspaceInfo(String(params.workspaceId ?? ""))
         };
       }
       case "workspace.openTab": {
         const expectedUrl = typeof params.url === "string" ? params.url : void 0;
         const opened = await preserveHumanFocus(params.focus !== true, async () => {
-          return await workspaceManager.openTab({
-            workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0,
+          return await bindingManager.openTab({
+            workspaceId: String(params.workspaceId ?? ""),
             url: expectedUrl,
             active: params.active === true,
             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 workspaceManager.listTabs(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+        return await bindingManager.listTabs(String(params.workspaceId ?? ""));
       }
       case "workspace.getActiveTab": {
-        return await workspaceManager.getActiveTab(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+        return await bindingManager.getActiveTab(String(params.workspaceId ?? ""));
       }
       case "workspace.setActiveTab": {
-        return await workspaceManager.setActiveTab(Number(params.tabId), typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+        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 workspaceManager.focus(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+        return await bindingManager.focus(String(params.workspaceId ?? ""));
       }
       case "workspace.reset": {
         return await preserveHumanFocus(params.focus !== true, async () => {
-          return await workspaceManager.reset({
-            workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0,
+          return await bindingManager.reset({
+            workspaceId: String(params.workspaceId ?? ""),
             focus: params.focus === true,
             initialUrl: typeof params.url === "string" ? params.url : void 0
           });
         });
       }
       case "workspace.close": {
-        return await workspaceManager.close(typeof params.workspaceId === "string" ? params.workspaceId : void 0);
+        return await bindingManager.close(String(params.workspaceId ?? ""));
       }
       case "page.goto": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
           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);
@@ -1408,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 };
@@ -1416,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 };
@@ -1424,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 };
@@ -1455,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);
@@ -1549,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);
@@ -1619,7 +2777,7 @@
       ws?.send(JSON.stringify({
         type: "hello",
         role: "extension",
-        version: "0.3.8",
+        version: "0.6.0",
         ts: Date.now()
       }));
     });
@@ -1654,43 +2812,50 @@
     });
   }
   chrome.tabs.onRemoved.addListener((tabId) => {
-    void loadWorkspaceState().then(async (state) => {
-      if (!state || !state.tabIds.includes(tabId)) {
-        return;
+    dropNetworkCapture(tabId);
+    void listWorkspaceStates().then(async (states) => {
+      for (const state of states) {
+        if (!state.tabIds.includes(tabId)) {
+          continue;
+        }
+        const nextTabIds = state.tabIds.filter((id) => id !== tabId);
+        await saveWorkspaceState({
+          ...state,
+          tabIds: nextTabIds,
+          activeTabId: state.activeTabId === tabId ? null : state.activeTabId,
+          primaryTabId: state.primaryTabId === tabId ? null : state.primaryTabId
+        });
       }
-      const nextTabIds = state.tabIds.filter((id) => id !== tabId);
-      await saveWorkspaceState({
-        ...state,
-        tabIds: nextTabIds,
-        activeTabId: state.activeTabId === tabId ? null : state.activeTabId,
-        primaryTabId: state.primaryTabId === tabId ? null : state.primaryTabId
-      });
     });
   });
   chrome.tabs.onActivated.addListener((activeInfo) => {
-    void loadWorkspaceState().then(async (state) => {
-      if (!state || state.windowId !== activeInfo.windowId || !state.tabIds.includes(activeInfo.tabId)) {
-        return;
+    void listWorkspaceStates().then(async (states) => {
+      for (const state of states) {
+        if (state.windowId !== activeInfo.windowId || !state.tabIds.includes(activeInfo.tabId)) {
+          continue;
+        }
+        await saveWorkspaceState({
+          ...state,
+          activeTabId: activeInfo.tabId
+        });
       }
-      await saveWorkspaceState({
-        ...state,
-        activeTabId: activeInfo.tabId
-      });
     });
   });
   chrome.windows.onRemoved.addListener((windowId) => {
-    void loadWorkspaceState().then(async (state) => {
-      if (!state || state.windowId !== windowId) {
-        return;
+    void listWorkspaceStates().then(async (states) => {
+      for (const state of states) {
+        if (state.windowId !== windowId) {
+          continue;
+        }
+        await saveWorkspaceState({
+          ...state,
+          windowId: null,
+          groupId: null,
+          tabIds: [],
+          activeTabId: null,
+          primaryTabId: null
+        });
       }
-      await saveWorkspaceState({
-        ...state,
-        windowId: null,
-        groupId: null,
-        tabIds: [],
-        activeTabId: null,
-        primaryTabId: null
-      });
     });
   });
   chrome.runtime.onInstalled.addListener(() => {