@flrande/bak-extension 0.6.0 → 0.6.2

package/dist/background.global.js

@@ -389,7 +389,7 @@
         version: "1.2",
         creator: {
           name: "bak",
-          version: "0.6.0"
+          version: "0.6.1"
         },
         entries: entries.map((entry) => ({
           startedDateTime: new Date(entry.startedAt ?? entry.ts).toISOString(),
@@ -465,22 +465,20 @@
 
   // 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) {
+  function isSessionBindingRecord(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) {
+  function cloneSessionBindingRecord(state) {
     return {
       ...state,
       tabIds: [...state.tabIds]
     };
   }
-  function normalizeWorkspaceRecordMap(value) {
+  function normalizeSessionBindingRecordMap(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
       return {
         found: false,
@@ -488,11 +486,11 @@
       };
     }
     const normalizedEntries = [];
-    for (const [workspaceId, entry] of Object.entries(value)) {
-      if (!isWorkspaceRecord(entry)) {
+    for (const [bindingId, entry] of Object.entries(value)) {
+      if (!isSessionBindingRecord(entry)) {
         continue;
       }
-      normalizedEntries.push([workspaceId, cloneWorkspaceRecord(entry)]);
+      normalizedEntries.push([bindingId, cloneSessionBindingRecord(entry)]);
     }
     return {
       found: true,
@@ -500,27 +498,17 @@
     };
   }
   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 {};
+    const current = normalizeSessionBindingRecordMap(stored[STORAGE_KEY_SESSION_BINDINGS]);
+    return current.found ? current.map : {};
   }
 
-  // src/workspace.ts
-  var DEFAULT_WORKSPACE_LABEL = "bak agent";
-  var DEFAULT_WORKSPACE_COLOR = "blue";
-  var DEFAULT_WORKSPACE_URL = "about:blank";
+  // src/session-binding.ts
+  var DEFAULT_SESSION_BINDING_LABEL = "bak agent";
+  var DEFAULT_SESSION_BINDING_COLOR = "blue";
+  var DEFAULT_SESSION_BINDING_URL = "about:blank";
+  var WINDOW_LOOKUP_TIMEOUT_MS = 1500;
+  var GROUP_LOOKUP_TIMEOUT_MS = 1e3;
+  var WINDOW_TABS_LOOKUP_TIMEOUT_MS = 1500;
   var SessionBindingManager = class {
     storage;
     browser;
@@ -528,21 +516,21 @@
       this.storage = storage;
       this.browser = browser;
     }
-    async getWorkspaceInfo(workspaceId) {
-      return this.inspectWorkspace(workspaceId);
+    async getBindingInfo(bindingId) {
+      return this.inspectBinding(bindingId);
     }
-    async ensureWorkspace(options = {}) {
-      const workspaceId = this.normalizeWorkspaceId(options.workspaceId);
+    async ensureBinding(options = {}) {
+      const bindingId = this.normalizeBindingId(options.bindingId);
       const repairActions = [];
-      const initialUrl = options.initialUrl ?? DEFAULT_WORKSPACE_URL;
-      const persisted = await this.storage.load(workspaceId);
+      const initialUrl = options.initialUrl ?? DEFAULT_SESSION_BINDING_URL;
+      const persisted = await this.storage.load(bindingId);
       const created = !persisted;
-      let state = this.normalizeState(persisted, workspaceId);
+      let state = this.normalizeState(persisted, bindingId);
       const originalWindowId = state.windowId;
       let window2 = state.windowId !== null ? await this.waitForWindow(state.windowId) : null;
       let tabs = [];
       if (!window2) {
-        const rebound = await this.rebindWorkspaceWindow(state);
+        const rebound = await this.rebindBindingWindow(state);
         if (rebound) {
           window2 = rebound.window;
           tabs = rebound.tabs;
@@ -573,7 +561,7 @@
         repairActions.push(created ? "created-window" : "recreated-window");
       }
       tabs = tabs.length > 0 ? tabs : await this.readTrackedTabs(state.tabIds, state.windowId);
-      const recoveredTabs = await this.recoverWorkspaceTabs(state, tabs);
+      const recoveredTabs = await this.recoverBindingTabs(state, tabs);
       if (recoveredTabs.length > tabs.length) {
         tabs = recoveredTabs;
         repairActions.push("recovered-tracked-tabs");
@@ -583,9 +571,9 @@
       }
       state.tabIds = tabs.map((tab) => tab.id);
       if (state.windowId !== null) {
-        const ownership = await this.inspectWorkspaceWindowOwnership(state, state.windowId);
+        const ownership = await this.inspectBindingWindowOwnership(state, state.windowId);
         if (ownership.foreignTabs.length > 0) {
-          const migrated = await this.moveWorkspaceIntoDedicatedWindow(state, ownership, initialUrl);
+          const migrated = await this.moveBindingIntoDedicatedWindow(state, ownership, initialUrl);
           window2 = migrated.window;
           tabs = migrated.tabs;
           state.tabIds = tabs.map((tab) => tab.id);
@@ -593,7 +581,7 @@
         }
       }
       if (tabs.length === 0) {
-        const primary = await this.createWorkspaceTab({
+        const primary = await this.createBindingTab({
           windowId: state.windowId,
           url: initialUrl,
           active: true
@@ -612,7 +600,7 @@
         state.activeTabId = state.primaryTabId ?? tabs[0]?.id ?? null;
         repairActions.push("reassigned-active-tab");
       }
-      let group = state.groupId !== null ? await this.browser.getGroup(state.groupId) : null;
+      let group = state.groupId !== null ? await this.waitForGroup(state.groupId) : null;
       if (!group || group.windowId !== state.windowId) {
         const groupId = await this.browser.groupTabs(tabs.map((tab) => tab.id));
         group = await this.browser.updateGroup(groupId, {
@@ -635,7 +623,7 @@
         repairActions.push("regrouped-tabs");
       }
       tabs = await this.readTrackedTabs(state.tabIds, state.windowId);
-      tabs = await this.recoverWorkspaceTabs(state, tabs);
+      tabs = await this.recoverBindingTabs(state, tabs);
       const activeTab = state.activeTabId !== null ? await this.waitForTrackedTab(state.activeTabId, state.windowId) : null;
       if (activeTab && !tabs.some((tab) => tab.id === activeTab.id)) {
         tabs = [...tabs, activeTab];
@@ -655,7 +643,7 @@
       }
       await this.storage.save(state);
       return {
-        workspace: {
+        binding: {
           ...state,
           tabs
         },
@@ -665,16 +653,16 @@
       };
     }
     async openTab(options = {}) {
-      const workspaceId = this.normalizeWorkspaceId(options.workspaceId);
-      const hadWorkspace = await this.loadWorkspaceRecord(workspaceId) !== null;
-      const ensured = await this.ensureWorkspace({
-        workspaceId,
+      const bindingId = this.normalizeBindingId(options.bindingId);
+      const hadBinding = await this.loadBindingRecord(bindingId) !== null;
+      const ensured = await this.ensureBinding({
+        bindingId,
         focus: false,
-        initialUrl: hadWorkspace ? options.url ?? DEFAULT_WORKSPACE_URL : DEFAULT_WORKSPACE_URL
+        initialUrl: hadBinding ? options.url ?? DEFAULT_SESSION_BINDING_URL : DEFAULT_SESSION_BINDING_URL
       });
-      let state = { ...ensured.workspace, tabIds: [...ensured.workspace.tabIds], tabs: [...ensured.workspace.tabs] };
+      let state = { ...ensured.binding, tabIds: [...ensured.binding.tabIds], tabs: [...ensured.binding.tabs] };
       if (state.windowId !== null && state.tabs.length === 0) {
-        const rebound = await this.rebindWorkspaceWindow(state);
+        const rebound = await this.rebindBindingWindow(state);
         if (rebound) {
           state.windowId = rebound.window.id;
           state.tabs = rebound.tabs;
@@ -682,7 +670,7 @@
         }
       }
       const active = options.active === true;
-      const desiredUrl = options.url ?? DEFAULT_WORKSPACE_URL;
+      const desiredUrl = options.url ?? DEFAULT_SESSION_BINDING_URL;
       let reusablePrimaryTab = await this.resolveReusablePrimaryTab(
         state,
         ensured.created || ensured.repairActions.includes("recreated-window") || ensured.repairActions.includes("created-primary-tab") || ensured.repairActions.includes("migrated-dirty-window")
@@ -692,7 +680,7 @@
         createdTab = reusablePrimaryTab ? await this.browser.updateTab(reusablePrimaryTab.id, {
           url: desiredUrl,
           active
-        }) : await this.createWorkspaceTab({
+        }) : await this.createBindingTab({
           windowId: state.windowId,
           url: desiredUrl,
           active
@@ -701,17 +689,17 @@
         if (!this.isMissingWindowError(error)) {
           throw error;
         }
-        const repaired = await this.ensureWorkspace({
-          workspaceId,
+        const repaired = await this.ensureBinding({
+          bindingId,
           focus: false,
           initialUrl: desiredUrl
         });
-        state = { ...repaired.workspace };
+        state = { ...repaired.binding };
         reusablePrimaryTab = await this.resolveReusablePrimaryTab(state, true);
         createdTab = reusablePrimaryTab ? await this.browser.updateTab(reusablePrimaryTab.id, {
           url: desiredUrl,
           active
-        }) : await this.createWorkspaceTab({
+        }) : await this.createBindingTab({
           windowId: state.windowId,
           url: desiredUrl,
           active
@@ -731,7 +719,7 @@
         windowId: state.windowId,
         groupId,
         tabIds: nextTabIds,
-        activeTabId: createdTab.id,
+        activeTabId: active || options.focus === true ? createdTab.id : state.activeTabId ?? state.primaryTabId ?? createdTab.id,
         primaryTabId: state.primaryTabId ?? createdTab.id
       };
       if (options.focus === true) {
@@ -742,95 +730,95 @@
       const tabs = await this.readTrackedTabs(nextState.tabIds, nextState.windowId);
       const tab = tabs.find((item) => item.id === createdTab.id) ?? createdTab;
       return {
-        workspace: {
+        binding: {
           ...nextState,
           tabs
         },
         tab
       };
     }
-    async listTabs(workspaceId) {
-      const ensured = await this.inspectWorkspace(workspaceId);
+    async listTabs(bindingId) {
+      const ensured = await this.inspectBinding(bindingId);
       if (!ensured) {
-        throw new Error(`Workspace ${workspaceId} does not exist`);
+        throw new Error(`Binding ${bindingId} does not exist`);
       }
       return {
-        workspace: ensured,
+        binding: ensured,
         tabs: ensured.tabs
       };
     }
-    async getActiveTab(workspaceId) {
-      const ensured = await this.inspectWorkspace(workspaceId);
+    async getActiveTab(bindingId) {
+      const ensured = await this.inspectBinding(bindingId);
       if (!ensured) {
-        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const normalizedBindingId = this.normalizeBindingId(bindingId);
         return {
-          workspace: {
-            ...this.normalizeState(null, normalizedWorkspaceId),
+          binding: {
+            ...this.normalizeState(null, normalizedBindingId),
             tabs: []
           },
           tab: null
         };
       }
       return {
-        workspace: ensured,
+        binding: ensured,
         tab: ensured.tabs.find((tab) => tab.id === ensured.activeTabId) ?? null
       };
     }
-    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}`);
+    async setActiveTab(tabId, bindingId) {
+      const ensured = await this.ensureBinding({ bindingId });
+      if (!ensured.binding.tabIds.includes(tabId)) {
+        throw new Error(`Tab ${tabId} does not belong to binding ${bindingId}`);
       }
       const nextState = {
-        id: ensured.workspace.id,
-        label: ensured.workspace.label,
-        color: ensured.workspace.color,
-        windowId: ensured.workspace.windowId,
-        groupId: ensured.workspace.groupId,
-        tabIds: [...ensured.workspace.tabIds],
+        id: ensured.binding.id,
+        label: ensured.binding.label,
+        color: ensured.binding.color,
+        windowId: ensured.binding.windowId,
+        groupId: ensured.binding.groupId,
+        tabIds: [...ensured.binding.tabIds],
         activeTabId: tabId,
-        primaryTabId: ensured.workspace.primaryTabId ?? tabId
+        primaryTabId: ensured.binding.primaryTabId ?? tabId
       };
       await this.storage.save(nextState);
       const tabs = await this.readTrackedTabs(nextState.tabIds, nextState.windowId);
       const tab = tabs.find((item) => item.id === tabId);
       if (!tab) {
-        throw new Error(`Tab ${tabId} is missing from workspace ${workspaceId}`);
+        throw new Error(`Tab ${tabId} is missing from binding ${bindingId}`);
       }
       return {
-        workspace: {
+        binding: {
           ...nextState,
           tabs
         },
         tab
       };
     }
-    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 });
+    async focus(bindingId) {
+      const ensured = await this.ensureBinding({ bindingId, focus: false });
+      if (ensured.binding.activeTabId !== null) {
+        await this.browser.updateTab(ensured.binding.activeTabId, { active: true });
       }
-      if (ensured.workspace.windowId !== null) {
-        await this.browser.updateWindow(ensured.workspace.windowId, { focused: true });
+      if (ensured.binding.windowId !== null) {
+        await this.browser.updateWindow(ensured.binding.windowId, { focused: true });
       }
-      const refreshed = await this.ensureWorkspace({ workspaceId, focus: false });
-      return { ok: true, workspace: refreshed.workspace };
+      const refreshed = await this.ensureBinding({ bindingId, focus: false });
+      return { ok: true, binding: refreshed.binding };
     }
     async reset(options = {}) {
-      const workspaceId = this.normalizeWorkspaceId(options.workspaceId);
-      await this.close(workspaceId);
-      return this.ensureWorkspace({
+      const bindingId = this.normalizeBindingId(options.bindingId);
+      await this.close(bindingId);
+      return this.ensureBinding({
         ...options,
-        workspaceId
+        bindingId
       });
     }
-    async close(workspaceId) {
-      const state = await this.loadWorkspaceRecord(workspaceId);
+    async close(bindingId) {
+      const state = await this.loadBindingRecord(bindingId);
       if (!state) {
-        await this.storage.delete(workspaceId);
+        await this.storage.delete(bindingId);
         return { ok: true };
       }
-      await this.storage.delete(workspaceId);
+      await this.storage.delete(bindingId);
       if (state.windowId !== null) {
         const existingWindow = await this.browser.getWindow(state.windowId);
         if (existingWindow) {
@@ -847,20 +835,20 @@
         }
         return {
           tab: explicitTab,
-          workspace: null,
+          binding: null,
           resolution: "explicit-tab",
-          createdWorkspace: false,
+          createdBinding: false,
           repaired: false,
           repairActions: []
         };
       }
-      const explicitWorkspaceId = typeof options.workspaceId === "string" ? this.normalizeWorkspaceId(options.workspaceId) : void 0;
-      if (explicitWorkspaceId) {
-        const ensured = await this.ensureWorkspace({
-          workspaceId: explicitWorkspaceId,
+      const explicitBindingId = typeof options.bindingId === "string" ? this.normalizeBindingId(options.bindingId) : void 0;
+      if (explicitBindingId) {
+        const ensured = await this.ensureBinding({
+          bindingId: explicitBindingId,
           focus: false
         });
-        return this.buildWorkspaceResolution(ensured, "explicit-workspace");
+        return this.buildBindingResolution(ensured, "explicit-binding");
       }
       if (options.createIfMissing !== true) {
         const activeTab = await this.browser.getActiveTab();
@@ -869,27 +857,27 @@
         }
         return {
           tab: activeTab,
-          workspace: null,
+          binding: null,
           resolution: "browser-active",
-          createdWorkspace: false,
+          createdBinding: false,
           repaired: false,
           repairActions: []
         };
       }
-      throw new Error("workspaceId is required when createIfMissing is true");
+      throw new Error("bindingId is required when createIfMissing is true");
     }
-    normalizeWorkspaceId(workspaceId) {
-      const candidate = workspaceId?.trim();
+    normalizeBindingId(bindingId) {
+      const candidate = bindingId?.trim();
       if (!candidate) {
-        throw new Error("workspaceId is required");
+        throw new Error("bindingId is required");
       }
       return candidate;
     }
-    normalizeState(state, workspaceId) {
+    normalizeState(state, bindingId) {
       return {
-        id: workspaceId,
-        label: state?.label ?? DEFAULT_WORKSPACE_LABEL,
-        color: state?.color ?? DEFAULT_WORKSPACE_COLOR,
+        id: bindingId,
+        label: state?.label ?? DEFAULT_SESSION_BINDING_LABEL,
+        color: state?.color ?? DEFAULT_SESSION_BINDING_COLOR,
         windowId: state?.windowId ?? null,
         groupId: state?.groupId ?? null,
         tabIds: state?.tabIds ?? [],
@@ -897,37 +885,37 @@
         primaryTabId: state?.primaryTabId ?? null
       };
     }
-    async listWorkspaceRecords() {
+    async listBindingRecords() {
       return await this.storage.list();
     }
-    async loadWorkspaceRecord(workspaceId) {
-      const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
-      const state = await this.storage.load(normalizedWorkspaceId);
-      if (!state || state.id !== normalizedWorkspaceId) {
+    async loadBindingRecord(bindingId) {
+      const normalizedBindingId = this.normalizeBindingId(bindingId);
+      const state = await this.storage.load(normalizedBindingId);
+      if (!state || state.id !== normalizedBindingId) {
         return null;
       }
-      return this.normalizeState(state, normalizedWorkspaceId);
+      return this.normalizeState(state, normalizedBindingId);
     }
-    async buildWorkspaceResolution(ensured, resolution) {
-      const tab = ensured.workspace.tabs.find((item) => item.id === ensured.workspace.activeTabId) ?? ensured.workspace.tabs[0] ?? null;
+    async buildBindingResolution(ensured, resolution) {
+      const tab = ensured.binding.tabs.find((item) => item.id === ensured.binding.activeTabId) ?? ensured.binding.tabs[0] ?? null;
       if (tab) {
         return {
           tab,
-          workspace: ensured.workspace,
+          binding: ensured.binding,
           resolution,
-          createdWorkspace: ensured.created,
+          createdBinding: ensured.created,
           repaired: ensured.repaired,
           repairActions: ensured.repairActions
         };
       }
-      if (ensured.workspace.activeTabId !== null) {
-        const activeWorkspaceTab = await this.waitForTrackedTab(ensured.workspace.activeTabId, ensured.workspace.windowId);
-        if (activeWorkspaceTab) {
+      if (ensured.binding.activeTabId !== null) {
+        const activeBindingTab = await this.waitForTrackedTab(ensured.binding.activeTabId, ensured.binding.windowId);
+        if (activeBindingTab) {
           return {
-            tab: activeWorkspaceTab,
-            workspace: ensured.workspace,
+            tab: activeBindingTab,
+            binding: ensured.binding,
             resolution,
-            createdWorkspace: ensured.created,
+            createdBinding: ensured.created,
             repaired: ensured.repaired,
             repairActions: ensured.repairActions
           };
@@ -939,9 +927,9 @@
       }
       return {
         tab: activeTab,
-        workspace: null,
+        binding: null,
         resolution: "browser-active",
-        createdWorkspace: ensured.created,
+        createdBinding: ensured.created,
         repaired: ensured.repaired,
         repairActions: ensured.repairActions
       };
@@ -972,7 +960,7 @@
     collectCandidateTabIds(state) {
       return [...new Set(state.tabIds.concat([state.activeTabId, state.primaryTabId].filter((value) => typeof value === "number")))];
     }
-    async rebindWorkspaceWindow(state) {
+    async rebindBindingWindow(state) {
       const candidateWindowIds = [];
       const pushWindowId = (windowId) => {
         if (typeof windowId !== "number") {
@@ -982,7 +970,7 @@
           candidateWindowIds.push(windowId);
         }
       };
-      const group = state.groupId !== null ? await this.browser.getGroup(state.groupId) : null;
+      const group = state.groupId !== null ? await this.waitForGroup(state.groupId) : null;
       pushWindowId(group?.windowId);
       const trackedTabs = await this.readLooseTrackedTabs(this.collectCandidateTabIds(state));
       for (const tab of trackedTabs) {
@@ -995,7 +983,7 @@
         }
         let tabs = await this.readTrackedTabs(this.collectCandidateTabIds(state), candidateWindowId);
         if (tabs.length === 0 && group?.id !== null && group?.windowId === candidateWindowId) {
-          const windowTabs = await this.waitForWindowTabs(candidateWindowId, 750);
+          const windowTabs = await this.waitForWindowTabs(candidateWindowId, WINDOW_TABS_LOOKUP_TIMEOUT_MS);
           tabs = windowTabs.filter((tab) => tab.groupId === group.id);
         }
         if (tabs.length === 0) {
@@ -1015,19 +1003,19 @@
       }
       return null;
     }
-    async inspectWorkspaceWindowOwnership(state, windowId) {
+    async inspectBindingWindowOwnership(state, windowId) {
       const windowTabs = await this.waitForWindowTabs(windowId, 500);
       const trackedIds = new Set(this.collectCandidateTabIds(state));
       return {
-        workspaceTabs: windowTabs.filter((tab) => trackedIds.has(tab.id) || state.groupId !== null && tab.groupId === state.groupId),
+        bindingTabs: windowTabs.filter((tab) => trackedIds.has(tab.id) || state.groupId !== null && tab.groupId === state.groupId),
         foreignTabs: windowTabs.filter((tab) => !trackedIds.has(tab.id) && (state.groupId === null || tab.groupId !== state.groupId))
       };
     }
-    async moveWorkspaceIntoDedicatedWindow(state, ownership, initialUrl) {
-      const sourceTabs = this.orderWorkspaceTabsForMigration(state, ownership.workspaceTabs);
+    async moveBindingIntoDedicatedWindow(state, ownership, initialUrl) {
+      const sourceTabs = this.orderSessionBindingTabsForMigration(state, ownership.bindingTabs);
       const seedUrl = sourceTabs[0]?.url ?? initialUrl;
       const window2 = await this.browser.createWindow({
-        url: seedUrl || DEFAULT_WORKSPACE_URL,
+        url: seedUrl || DEFAULT_SESSION_BINDING_URL,
         focused: false
       });
       const recreatedTabs = await this.waitForWindowTabs(window2.id);
@@ -1037,7 +1025,7 @@
         tabIdMap.set(sourceTabs[0].id, firstTab.id);
       }
       for (const sourceTab of sourceTabs.slice(1)) {
-        const recreated = await this.createWorkspaceTab({
+        const recreated = await this.createBindingTab({
           windowId: window2.id,
           url: sourceTab.url,
           active: false
@@ -1055,15 +1043,15 @@
       state.tabIds = recreatedTabs.map((tab) => tab.id);
       state.primaryTabId = nextPrimaryTabId;
       state.activeTabId = nextActiveTabId;
-      for (const workspaceTab of ownership.workspaceTabs) {
-        await this.browser.closeTab(workspaceTab.id);
+      for (const bindingTab of ownership.bindingTabs) {
+        await this.browser.closeTab(bindingTab.id);
       }
       return {
         window: window2,
         tabs: await this.readTrackedTabs(state.tabIds, state.windowId)
       };
     }
-    orderWorkspaceTabsForMigration(state, tabs) {
+    orderSessionBindingTabsForMigration(state, tabs) {
       const ordered = [];
       const seen = /* @__PURE__ */ new Set();
       const pushById = (tabId) => {
@@ -1088,7 +1076,7 @@
       }
       return ordered;
     }
-    async recoverWorkspaceTabs(state, existingTabs) {
+    async recoverBindingTabs(state, existingTabs) {
       if (state.windowId === null) {
         return existingTabs;
       }
@@ -1114,9 +1102,9 @@
       }
       return existingTabs;
     }
-    async createWorkspaceTab(options) {
+    async createBindingTab(options) {
       if (options.windowId === null) {
-        throw new Error("Workspace window is unavailable");
+        throw new Error("Binding window is unavailable");
       }
       const deadline = Date.now() + 1500;
       let lastError2 = null;
@@ -1137,8 +1125,8 @@
       }
       throw lastError2 ?? new Error(`No window with id: ${options.windowId}.`);
     }
-    async inspectWorkspace(workspaceId) {
-      const state = await this.loadWorkspaceRecord(workspaceId);
+    async inspectBinding(bindingId) {
+      const state = await this.loadBindingRecord(bindingId);
       if (!state) {
         return null;
       }
@@ -1159,34 +1147,34 @@
         tabs
       };
     }
-    async resolveReusablePrimaryTab(workspace, allowReuse) {
-      if (workspace.windowId === null) {
+    async resolveReusablePrimaryTab(binding, allowReuse) {
+      if (binding.windowId === null) {
         return null;
       }
-      if (workspace.primaryTabId !== null) {
-        const trackedPrimary = workspace.tabs.find((tab) => tab.id === workspace.primaryTabId) ?? await this.waitForTrackedTab(workspace.primaryTabId, workspace.windowId);
-        if (trackedPrimary && (allowReuse || this.isReusableBlankWorkspaceTab(trackedPrimary, workspace))) {
+      if (binding.primaryTabId !== null) {
+        const trackedPrimary = binding.tabs.find((tab) => tab.id === binding.primaryTabId) ?? await this.waitForTrackedTab(binding.primaryTabId, binding.windowId);
+        if (trackedPrimary && (allowReuse || this.isReusableBlankSessionBindingTab(trackedPrimary, binding))) {
           return trackedPrimary;
         }
       }
-      const windowTabs = await this.waitForWindowTabs(workspace.windowId, 750);
+      const windowTabs = await this.waitForWindowTabs(binding.windowId, WINDOW_TABS_LOOKUP_TIMEOUT_MS);
       if (windowTabs.length !== 1) {
         return null;
       }
       const candidate = windowTabs[0];
-      if (allowReuse || this.isReusableBlankWorkspaceTab(candidate, workspace)) {
+      if (allowReuse || this.isReusableBlankSessionBindingTab(candidate, binding)) {
         return candidate;
       }
       return null;
     }
-    isReusableBlankWorkspaceTab(tab, workspace) {
-      if (workspace.tabIds.length > 1) {
+    isReusableBlankSessionBindingTab(tab, binding) {
+      if (binding.tabIds.length > 1) {
         return false;
       }
       const normalizedUrl = tab.url.trim().toLowerCase();
-      return normalizedUrl === "" || normalizedUrl === DEFAULT_WORKSPACE_URL;
+      return normalizedUrl === "" || normalizedUrl === DEFAULT_SESSION_BINDING_URL;
     }
-    async waitForWindow(windowId, timeoutMs = 750) {
+    async waitForWindow(windowId, timeoutMs = WINDOW_LOOKUP_TIMEOUT_MS) {
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
         const window2 = await this.browser.getWindow(windowId);
@@ -1197,6 +1185,17 @@
       }
       return null;
     }
+    async waitForGroup(groupId, timeoutMs = GROUP_LOOKUP_TIMEOUT_MS) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const group = await this.browser.getGroup(groupId);
+        if (group) {
+          return group;
+        }
+        await this.delay(50);
+      }
+      return null;
+    }
     async waitForTrackedTab(tabId, windowId, timeoutMs = 1e3) {
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
@@ -1208,7 +1207,7 @@
       }
       return null;
     }
-    async waitForWindowTabs(windowId, timeoutMs = 1e3) {
+    async waitForWindowTabs(windowId, timeoutMs = WINDOW_TABS_LOOKUP_TIMEOUT_MS) {
       const deadline = Date.now() + timeoutMs;
       while (Date.now() < deadline) {
         const tabs = await this.browser.listTabs({ windowId });
@@ -1236,6 +1235,9 @@
   var DEFAULT_TAB_LOAD_TIMEOUT_MS = 4e4;
   var textEncoder2 = new TextEncoder();
   var textDecoder2 = new TextDecoder();
+  var DATA_TIMESTAMP_CONTEXT_PATTERN = /\b(updated|update|updatedat|asof|timestamp|generated|generatedat|refresh|freshness|latest|last|quote|trade|price|flow|market|time|snapshot|signal)\b/i;
+  var CONTRACT_TIMESTAMP_CONTEXT_PATTERN = /\b(expiry|expiration|expires|option|contract|strike|maturity|dte|call|put|exercise)\b/i;
+  var EVENT_TIMESTAMP_CONTEXT_PATTERN = /\b(earnings|event|report|dividend|split|meeting|fomc|release|filing)\b/i;
   var REPLAY_FORBIDDEN_HEADER_NAMES = /* @__PURE__ */ new Set([
     "accept-encoding",
     "authorization",
@@ -1254,6 +1256,7 @@
   var reconnectAttempt = 0;
   var lastError = null;
   var manualDisconnect = false;
+  var sessionBindingStateMutationQueue = Promise.resolve();
   async function getConfig() {
     const stored = await chrome.storage.local.get([STORAGE_KEY_TOKEN, STORAGE_KEY_PORT, STORAGE_KEY_DEBUG_RICH_TEXT]);
     return {
@@ -1308,10 +1311,10 @@
     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")) {
+    if (lower.includes("binding") && 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")) {
+    if (lower.includes("does not belong to binding") || lower.includes("is missing from binding")) {
       return toError("E_NOT_FOUND", message);
     }
     if (lower.includes("invalid url") || lower.includes("url is invalid")) {
@@ -1335,38 +1338,55 @@
       groupId: typeof tab.groupId === "number" && tab.groupId >= 0 ? tab.groupId : null
     };
   }
-  async function loadWorkspaceStateMap() {
-    const stored = await chrome.storage.local.get([
-      STORAGE_KEY_SESSION_BINDINGS,
-      LEGACY_STORAGE_KEY_WORKSPACES,
-      LEGACY_STORAGE_KEY_WORKSPACE
-    ]);
+  async function readSessionBindingStateMap() {
+    const stored = await chrome.storage.local.get([STORAGE_KEY_SESSION_BINDINGS]);
     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) {
-    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];
+  async function flushSessionBindingStateMap(stateMap) {
     if (Object.keys(stateMap).length === 0) {
-      await chrome.storage.local.remove([STORAGE_KEY_SESSION_BINDINGS, LEGACY_STORAGE_KEY_WORKSPACES, LEGACY_STORAGE_KEY_WORKSPACE]);
+      await chrome.storage.local.remove([STORAGE_KEY_SESSION_BINDINGS]);
       return;
     }
     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 function runSessionBindingStateMutation(operation) {
+    const run = sessionBindingStateMutationQueue.then(operation, operation);
+    sessionBindingStateMutationQueue = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  async function mutateSessionBindingStateMap(mutator) {
+    return await runSessionBindingStateMutation(async () => {
+      const stateMap = await readSessionBindingStateMap();
+      const result = await mutator(stateMap);
+      await flushSessionBindingStateMap(stateMap);
+      return result;
+    });
+  }
+  async function loadSessionBindingStateMap() {
+    await sessionBindingStateMutationQueue;
+    return await readSessionBindingStateMap();
+  }
+  async function loadSessionBindingState(bindingId) {
+    const stateMap = await loadSessionBindingStateMap();
+    return stateMap[bindingId] ?? null;
+  }
+  async function listSessionBindingStates() {
+    return Object.values(await loadSessionBindingStateMap());
+  }
+  async function saveSessionBindingState(state) {
+    await mutateSessionBindingStateMap((stateMap) => {
+      stateMap[state.id] = state;
+    });
+  }
+  async function deleteSessionBindingState(bindingId) {
+    await mutateSessionBindingStateMap((stateMap) => {
+      delete stateMap[bindingId];
+    });
+  }
+  var sessionBindingBrowser = {
     async getTab(tabId) {
       try {
         return toTabInfo(await chrome.tabs.get(tabId));
@@ -1498,12 +1518,12 @@
   };
   var bindingManager = new SessionBindingManager(
     {
-      load: loadWorkspaceState,
-      save: saveWorkspaceState,
-      delete: deleteWorkspaceState,
-      list: listWorkspaceStates
+      load: loadSessionBindingState,
+      save: saveSessionBindingState,
+      delete: deleteSessionBindingState,
+      list: listSessionBindingStates
     },
-    workspaceBrowser
+    sessionBindingBrowser
   );
   async function waitForTabComplete(tabId, timeoutMs = DEFAULT_TAB_LOAD_TIMEOUT_MS) {
     try {
@@ -1592,7 +1612,7 @@
       return raw;
     }
   }
-  async function finalizeOpenedWorkspaceTab(opened, expectedUrl) {
+  async function finalizeOpenedSessionBindingTab(opened, expectedUrl) {
     if (expectedUrl && expectedUrl !== "about:blank") {
       await waitForTabUrl(opened.tab.id, expectedUrl).catch(() => void 0);
     }
@@ -1607,14 +1627,14 @@
         url: effectiveUrl
       };
     } catch {
-      refreshedTab = await workspaceBrowser.getTab(opened.tab.id) ?? opened.tab;
+      refreshedTab = await sessionBindingBrowser.getTab(opened.tab.id) ?? opened.tab;
     }
-    const refreshedWorkspace = await bindingManager.getWorkspaceInfo(opened.workspace.id) ?? {
-      ...opened.workspace,
-      tabs: opened.workspace.tabs.map((tab) => tab.id === refreshedTab.id ? refreshedTab : tab)
+    const refreshedBinding = await bindingManager.getBindingInfo(opened.binding.id) ?? {
+      ...opened.binding,
+      tabs: opened.binding.tabs.map((tab) => tab.id === refreshedTab.id ? refreshedTab : tab)
     };
     return {
-      workspace: refreshedWorkspace,
+      binding: refreshedBinding,
       tab: refreshedTab
     };
   }
@@ -1638,7 +1658,7 @@
     }
     const resolved = await bindingManager.resolveTarget({
       tabId: target.tabId,
-      workspaceId: typeof target.workspaceId === "string" ? target.workspaceId : void 0,
+      bindingId: typeof target.bindingId === "string" ? target.bindingId : void 0,
       createIfMissing: false
     });
     const tab = await chrome.tabs.get(resolved.tab.id);
@@ -1774,6 +1794,7 @@
           framePath,
           expr: typeof params.expr === "string" ? params.expr : "",
           path: typeof params.path === "string" ? params.path : "",
+          resolver: typeof params.resolver === "string" ? params.resolver : void 0,
           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,
@@ -1856,6 +1877,54 @@
           }
           return currentWindow;
         };
+        const buildPathExpression = (path) => parsePath(path).map((segment, index) => {
+          if (typeof segment === "number") {
+            return `[${segment}]`;
+          }
+          if (index === 0) {
+            return segment;
+          }
+          return `.${segment}`;
+        }).join("");
+        const readPath = (targetWindow, path) => {
+          const segments = parsePath(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: ${path}` };
+            }
+            current = current[segment];
+          }
+          return current;
+        };
+        const resolveExtractValue = (targetWindow, path, resolver) => {
+          const strategy = resolver === "globalThis" || resolver === "lexical" ? resolver : "auto";
+          const lexicalExpression = buildPathExpression(path);
+          const readLexical = () => {
+            try {
+              return targetWindow.eval(lexicalExpression);
+            } catch (error) {
+              if (error instanceof ReferenceError) {
+                throw { code: "E_NOT_FOUND", message: `path not found: ${path}` };
+              }
+              throw error;
+            }
+          };
+          if (strategy === "globalThis") {
+            return { resolver: "globalThis", value: readPath(targetWindow, path) };
+          }
+          if (strategy === "lexical") {
+            return { resolver: "lexical", value: readLexical() };
+          }
+          try {
+            return { resolver: "globalThis", value: readPath(targetWindow, path) };
+          } catch (error) {
+            if (typeof error !== "object" || error === null || error.code !== "E_NOT_FOUND") {
+              throw error;
+            }
+          }
+          return { resolver: "lexical", value: readLexical() };
+        };
         try {
           const targetWindow = payload.scope === "main" ? window : payload.scope === "current" ? resolveFrameWindow(payload.framePath ?? []) : window;
           if (payload.action === "eval") {
@@ -1864,16 +1933,15 @@
             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 };
+            const extracted = resolveExtractValue(targetWindow, payload.path, payload.resolver);
+            const serialized = serializeValue(extracted.value, payload.maxBytes);
+            return {
+              url: targetWindow.location.href,
+              framePath: payload.scope === "current" ? payload.framePath ?? [] : [],
+              value: serialized.value,
+              bytes: serialized.bytes,
+              resolver: extracted.resolver
+            };
           }
           if (payload.action === "fetch") {
             const headers = { ...payload.headers ?? {} };
@@ -2021,6 +2089,31 @@
     }
     return Object.keys(headers).length > 0 ? headers : void 0;
   }
+  function collectTimestampMatchesFromText(text, source, patterns) {
+    const regexes = (patterns ?? [
+      String.raw`\b20\d{2}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?\b`,
+      String.raw`\b20\d{2}-\d{2}-\d{2}\b`,
+      String.raw`\b20\d{2}\/\d{2}\/\d{2}\b`
+    ]).map((pattern) => new RegExp(pattern, "gi"));
+    const collected = /* @__PURE__ */ new Map();
+    for (const regex of regexes) {
+      for (const match of text.matchAll(regex)) {
+        const value = match[0];
+        if (!value) {
+          continue;
+        }
+        const index = match.index ?? text.indexOf(value);
+        const start = Math.max(0, index - 28);
+        const end = Math.min(text.length, index + value.length + 28);
+        const context = text.slice(start, end).replace(/\s+/g, " ").trim();
+        const key = `${value}::${context}`;
+        if (!collected.has(key)) {
+          collected.set(key, { value, source, context });
+        }
+      }
+    }
+    return [...collected.values()];
+  }
   function parseTimestampCandidate(value, now = Date.now()) {
     const normalized = value.trim().toLowerCase();
     if (!normalized) {
@@ -2035,13 +2128,61 @@
     const parsed = Date.parse(value);
     return Number.isNaN(parsed) ? null : parsed;
   }
-  function extractLatestTimestamp(values, now = Date.now()) {
-    if (!Array.isArray(values) || values.length === 0) {
+  function nearestPatternDistance(text, anchor, pattern) {
+    const normalizedText = text.toLowerCase();
+    const normalizedAnchor = anchor.toLowerCase();
+    const anchorIndex = normalizedText.indexOf(normalizedAnchor);
+    if (anchorIndex < 0) {
       return null;
     }
+    const regex = new RegExp(pattern.source, "gi");
+    let match;
+    let best = null;
+    while ((match = regex.exec(normalizedText)) !== null) {
+      best = best === null ? Math.abs(anchorIndex - match.index) : Math.min(best, Math.abs(anchorIndex - match.index));
+    }
+    return best;
+  }
+  function classifyTimestampCandidate(candidate, now = Date.now()) {
+    const normalizedPath = (candidate.path ?? "").toLowerCase();
+    if (DATA_TIMESTAMP_CONTEXT_PATTERN.test(normalizedPath)) {
+      return "data";
+    }
+    if (CONTRACT_TIMESTAMP_CONTEXT_PATTERN.test(normalizedPath)) {
+      return "contract";
+    }
+    if (EVENT_TIMESTAMP_CONTEXT_PATTERN.test(normalizedPath)) {
+      return "event";
+    }
+    const context = candidate.context ?? "";
+    const distances = [
+      { category: "data", distance: nearestPatternDistance(context, candidate.value, DATA_TIMESTAMP_CONTEXT_PATTERN) },
+      { category: "contract", distance: nearestPatternDistance(context, candidate.value, CONTRACT_TIMESTAMP_CONTEXT_PATTERN) },
+      { category: "event", distance: nearestPatternDistance(context, candidate.value, EVENT_TIMESTAMP_CONTEXT_PATTERN) }
+    ].filter((entry) => typeof entry.distance === "number");
+    if (distances.length > 0) {
+      distances.sort((left, right) => left.distance - right.distance);
+      return distances[0].category;
+    }
+    const parsed = parseTimestampCandidate(candidate.value, now);
+    return typeof parsed === "number" && parsed > now + 36 * 60 * 60 * 1e3 ? "contract" : "unknown";
+  }
+  function normalizeTimestampCandidates(candidates, now = Date.now()) {
+    return candidates.map((candidate) => ({
+      value: candidate.value,
+      source: candidate.source,
+      category: candidate.category ?? classifyTimestampCandidate(candidate, now),
+      context: candidate.context,
+      path: candidate.path
+    }));
+  }
+  function latestTimestampFromCandidates(candidates, now = Date.now()) {
     let latest = null;
-    for (const value of values) {
-      const parsed = parseTimestampCandidate(value, now);
+    for (const candidate of candidates) {
+      if (candidate.category === "contract" || candidate.category === "event") {
+        continue;
+      }
+      const parsed = parseTimestampCandidate(candidate.value, now);
       if (parsed === null) {
         continue;
       }
@@ -2051,15 +2192,24 @@
   }
   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) {
+    const latestPageVisibleTimestamp = [input.latestPageDataTimestamp, input.latestInlineDataTimestamp, input.domVisibleTimestamp].filter((value) => typeof value === "number").sort((left, right) => right - left)[0] ?? null;
+    if (latestPageVisibleTimestamp !== null && now - latestPageVisibleTimestamp <= input.freshWindowMs) {
       return "fresh";
     }
+    const networkHasFreshData = typeof input.latestNetworkDataTimestamp === "number" && now - input.latestNetworkDataTimestamp <= input.freshWindowMs;
+    if (networkHasFreshData) {
+      return "lagged";
+    }
     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) {
+    if (recentSignals && latestPageVisibleTimestamp !== null && now - latestPageVisibleTimestamp > input.freshWindowMs) {
       return "lagged";
     }
-    const staleSignals = [input.latestNetworkTimestamp, input.lastMutationAt, latestDataTimestamp].filter((value) => typeof value === "number");
+    const staleSignals = [
+      input.latestNetworkTimestamp,
+      input.lastMutationAt,
+      latestPageVisibleTimestamp,
+      input.latestNetworkDataTimestamp
+    ].filter((value) => typeof value === "number");
     if (staleSignals.length > 0 && staleSignals.every((value) => now - value > input.staleWindowMs)) {
       return "stale";
     }
@@ -2068,25 +2218,167 @@
   async function collectPageInspection(tabId, params = {}) {
     return await forwardContentRpc(tabId, "bak.internal.inspectState", params);
   }
+  async function probePageDataCandidatesForTab(tabId, inspection) {
+    const candidateNames = [
+      ...Array.isArray(inspection.suspiciousGlobals) ? inspection.suspiciousGlobals.map(String) : [],
+      ...Array.isArray(inspection.globalsPreview) ? inspection.globalsPreview.map(String) : []
+    ].filter((name, index, array) => /^[A-Za-z_$][\w$]*$/.test(name) && array.indexOf(name) === index).slice(0, 16);
+    if (candidateNames.length === 0) {
+      return [];
+    }
+    const expr = `(() => {
+    const candidates = ${JSON.stringify(candidateNames)};
+    const dataPattern = /\\b(updated|update|updatedat|asof|timestamp|generated|generatedat|refresh|latest|last|quote|trade|price|flow|market|time|snapshot|signal)\\b/i;
+    const contractPattern = /\\b(expiry|expiration|expires|option|contract|strike|maturity|dte|call|put|exercise)\\b/i;
+    const eventPattern = /\\b(earnings|event|report|dividend|split|meeting|fomc|release|filing)\\b/i;
+    const isTimestampString = (value) => typeof value === 'string' && value.trim().length > 0 && !Number.isNaN(Date.parse(value.trim()));
+    const classify = (path, value) => {
+      const normalized = String(path || '').toLowerCase();
+      if (dataPattern.test(normalized)) return 'data';
+      if (contractPattern.test(normalized)) return 'contract';
+      if (eventPattern.test(normalized)) return 'event';
+      const parsed = Date.parse(String(value || '').trim());
+      return Number.isFinite(parsed) && parsed > Date.now() + 36 * 60 * 60 * 1000 ? 'contract' : 'unknown';
+    };
+    const sampleValue = (value, depth = 0) => {
+      if (depth >= 2 || value == null || typeof value !== 'object') {
+        if (typeof value === 'string') {
+          return value.length > 160 ? value.slice(0, 160) : value;
+        }
+        if (typeof value === 'function') {
+          return '[Function]';
+        }
+        return value;
+      }
+      if (Array.isArray(value)) {
+        return value.slice(0, 3).map((item) => sampleValue(item, depth + 1));
+      }
+      const sampled = {};
+      for (const key of Object.keys(value).slice(0, 8)) {
+        try {
+          sampled[key] = sampleValue(value[key], depth + 1);
+        } catch {
+          sampled[key] = '[Unreadable]';
+        }
+      }
+      return sampled;
+    };
+    const collectTimestamps = (value, path, depth, collected) => {
+      if (collected.length >= 16) return;
+      if (isTimestampString(value)) {
+        collected.push({ path, value: String(value), category: classify(path, value) });
+        return;
+      }
+      if (depth >= 3) return;
+      if (Array.isArray(value)) {
+        value.slice(0, 3).forEach((item, index) => collectTimestamps(item, path + '[' + index + ']', depth + 1, collected));
+        return;
+      }
+      if (value && typeof value === 'object') {
+        Object.keys(value)
+          .slice(0, 8)
+          .forEach((key) => {
+            try {
+              collectTimestamps(value[key], path ? path + '.' + key : key, depth + 1, collected);
+            } catch {
+              // Ignore unreadable nested properties.
+            }
+          });
+      }
+    };
+    const readCandidate = (name) => {
+      if (name in globalThis) {
+        return { resolver: 'globalThis', value: globalThis[name] };
+      }
+      return { resolver: 'lexical', value: globalThis.eval(name) };
+    };
+    const results = [];
+    for (const name of candidates) {
+      try {
+        const resolved = readCandidate(name);
+        const timestamps = [];
+        collectTimestamps(resolved.value, name, 0, timestamps);
+        results.push({
+          name,
+          resolver: resolved.resolver,
+          sample: sampleValue(resolved.value),
+          timestamps
+        });
+      } catch {
+        // Ignore inaccessible candidates.
+      }
+    }
+    return results;
+  })()`;
+    try {
+      const evaluated = await executePageWorld(tabId, "eval", {
+        expr,
+        scope: "current",
+        maxBytes: 64 * 1024
+      });
+      const frameResult = evaluated.result ?? evaluated.results?.find((candidate) => candidate.value || candidate.error);
+      return Array.isArray(frameResult?.value) ? frameResult.value : [];
+    } catch {
+      return [];
+    }
+  }
   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 probedPageDataCandidates = await probePageDataCandidatesForTab(tabId, inspection);
     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 visibleCandidates = normalizeTimestampCandidates(
+      Array.isArray(inspection.visibleTimestampCandidates) ? inspection.visibleTimestampCandidates.filter((candidate) => typeof candidate === "object" && candidate !== null).map((candidate) => ({
+        value: String(candidate.value ?? ""),
+        context: typeof candidate.context === "string" ? candidate.context : void 0,
+        source: "visible"
+      })) : Array.isArray(inspection.visibleTimestamps) ? inspection.visibleTimestamps.map((value) => ({ value: String(value), source: "visible" })) : [],
+      now
+    );
+    const inlineCandidates = normalizeTimestampCandidates(
+      Array.isArray(inspection.inlineTimestampCandidates) ? inspection.inlineTimestampCandidates.filter((candidate) => typeof candidate === "object" && candidate !== null).map((candidate) => ({
+        value: String(candidate.value ?? ""),
+        context: typeof candidate.context === "string" ? candidate.context : void 0,
+        source: "inline"
+      })) : Array.isArray(inspection.inlineTimestamps) ? inspection.inlineTimestamps.map((value) => ({ value: String(value), source: "inline" })) : [],
+      now
+    );
+    const pageDataCandidates = probedPageDataCandidates.flatMap(
+      (candidate) => Array.isArray(candidate.timestamps) ? candidate.timestamps.map((timestamp) => ({
+        value: String(timestamp.value ?? ""),
+        source: "page-data",
+        path: typeof timestamp.path === "string" ? timestamp.path : candidate.name,
+        category: timestamp.category === "data" || timestamp.category === "contract" || timestamp.category === "event" || timestamp.category === "unknown" ? timestamp.category : "unknown"
+      })) : []
+    );
+    const networkEntries = listNetworkEntries(tabId, { limit: 25 });
+    const networkCandidates = normalizeTimestampCandidates(
+      networkEntries.flatMap((entry) => {
+        const previews = [entry.responseBodyPreview, entry.requestBodyPreview].filter((value) => typeof value === "string");
+        return previews.flatMap((preview) => collectTimestampMatchesFromText(preview, "network", Array.isArray(params.patterns) ? params.patterns.map(String) : void 0));
+      }),
+      now
+    );
+    const latestInlineDataTimestamp = latestTimestampFromCandidates(inlineCandidates, now);
+    const latestPageDataTimestamp = latestTimestampFromCandidates(pageDataCandidates, now);
+    const latestNetworkDataTimestamp = latestTimestampFromCandidates(networkCandidates, now);
+    const domVisibleTimestamp = latestTimestampFromCandidates(visibleCandidates, now);
     const latestNetworkTs = latestNetworkTimestamp(tabId);
     const lastMutationAt = typeof inspection.lastMutationAt === "number" ? inspection.lastMutationAt : null;
+    const allCandidates = [...visibleCandidates, ...inlineCandidates, ...pageDataCandidates, ...networkCandidates];
     return {
       pageLoadedAt: typeof inspection.pageLoadedAt === "number" ? inspection.pageLoadedAt : null,
       lastMutationAt,
       latestNetworkTimestamp: latestNetworkTs,
       latestInlineDataTimestamp,
+      latestPageDataTimestamp,
+      latestNetworkDataTimestamp,
       domVisibleTimestamp,
       assessment: computeFreshnessAssessment({
         latestInlineDataTimestamp,
+        latestPageDataTimestamp,
+        latestNetworkDataTimestamp,
         latestNetworkTimestamp: latestNetworkTs,
         domVisibleTimestamp,
         lastMutationAt,
@@ -2094,17 +2386,116 @@
         staleWindowMs
       }),
       evidence: {
-        visibleTimestamps,
-        inlineTimestamps,
+        visibleTimestamps: visibleCandidates.map((candidate) => candidate.value),
+        inlineTimestamps: inlineCandidates.map((candidate) => candidate.value),
+        pageDataTimestamps: pageDataCandidates.map((candidate) => candidate.value),
+        networkDataTimestamps: networkCandidates.map((candidate) => candidate.value),
+        classifiedTimestamps: allCandidates,
         networkSampleIds: recentNetworkSampleIds(tabId)
       }
     };
   }
+  function summarizeNetworkCadence(entries) {
+    const relevant = entries.filter((entry) => entry.kind === "fetch" || entry.kind === "xhr").slice().sort((left, right) => left.ts - right.ts);
+    if (relevant.length === 0) {
+      return {
+        sampleCount: 0,
+        classification: "none",
+        averageIntervalMs: null,
+        medianIntervalMs: null,
+        latestGapMs: null,
+        endpoints: []
+      };
+    }
+    const intervals = [];
+    for (let index = 1; index < relevant.length; index += 1) {
+      intervals.push(Math.max(0, relevant[index].ts - relevant[index - 1].ts));
+    }
+    const sortedIntervals = intervals.slice().sort((left, right) => left - right);
+    const averageIntervalMs = intervals.length > 0 ? Math.round(intervals.reduce((sum, value) => sum + value, 0) / intervals.length) : null;
+    const medianIntervalMs = sortedIntervals.length > 0 ? sortedIntervals[Math.floor(sortedIntervals.length / 2)] ?? null : null;
+    const latestGapMs = Math.max(0, Date.now() - relevant[relevant.length - 1].ts);
+    const classification = relevant.length >= 3 && medianIntervalMs !== null && medianIntervalMs <= 3e4 ? "polling" : relevant.length >= 2 ? "bursty" : "single-request";
+    return {
+      sampleCount: relevant.length,
+      classification,
+      averageIntervalMs,
+      medianIntervalMs,
+      latestGapMs,
+      endpoints: [...new Set(relevant.slice(-5).map((entry) => entry.url))].slice(0, 5)
+    };
+  }
+  function extractReplayRowsCandidate(json) {
+    if (Array.isArray(json)) {
+      return { rows: json, source: "$" };
+    }
+    if (typeof json !== "object" || json === null) {
+      return null;
+    }
+    const record = json;
+    const preferredKeys = ["data", "rows", "results", "items"];
+    for (const key of preferredKeys) {
+      if (Array.isArray(record[key])) {
+        return { rows: record[key], source: `$.${key}` };
+      }
+    }
+    return null;
+  }
+  async function enrichReplayWithSchema(tabId, response) {
+    const candidate = extractReplayRowsCandidate(response.json);
+    if (!candidate || candidate.rows.length === 0) {
+      return response;
+    }
+    const firstRow = candidate.rows[0];
+    const tablesResult = await forwardContentRpc(tabId, "table.list", {});
+    const tables = Array.isArray(tablesResult.tables) ? tablesResult.tables : [];
+    if (tables.length === 0) {
+      return response;
+    }
+    const schemas = [];
+    for (const table of tables) {
+      const schemaResult = await forwardContentRpc(tabId, "table.schema", { table: table.id });
+      if (schemaResult.schema && Array.isArray(schemaResult.schema.columns)) {
+        schemas.push({ table: schemaResult.table ?? table, schema: schemaResult.schema });
+      }
+    }
+    if (schemas.length === 0) {
+      return response;
+    }
+    if (Array.isArray(firstRow)) {
+      const matchingSchema = schemas.find(({ schema }) => schema.columns.length === firstRow.length) ?? schemas[0];
+      if (!matchingSchema) {
+        return response;
+      }
+      const mappedRows = candidate.rows.filter((row) => Array.isArray(row)).map((row) => {
+        const mapped = {};
+        matchingSchema.schema.columns.forEach((column, index) => {
+          mapped[column.label] = row[index];
+        });
+        return mapped;
+      });
+      return {
+        ...response,
+        table: matchingSchema.table,
+        schema: matchingSchema.schema,
+        mappedRows,
+        mappingSource: candidate.source
+      };
+    }
+    if (typeof firstRow === "object" && firstRow !== null) {
+      return {
+        ...response,
+        mappedRows: candidate.rows.filter((row) => typeof row === "object" && row !== null),
+        mappingSource: candidate.source
+      };
+    }
+    return response;
+  }
   async function handleRequest(request) {
     const params = request.params ?? {};
     const target = {
       tabId: typeof params.tabId === "number" ? params.tabId : void 0,
-      workspaceId: typeof params.workspaceId === "string" ? params.workspaceId : void 0
+      bindingId: typeof params.bindingId === "string" ? params.bindingId : void 0
     };
     const rpcForwardMethods = /* @__PURE__ */ new Set([
       "page.title",
@@ -2203,63 +2594,92 @@
         await chrome.tabs.remove(tabId);
         return { ok: true };
       }
-      case "workspace.ensure": {
+      case "sessionBinding.ensure": {
         return preserveHumanFocus(params.focus !== true, async () => {
-          const result = await bindingManager.ensureWorkspace({
-            workspaceId: String(params.workspaceId ?? ""),
+          const result = await bindingManager.ensureBinding({
+            bindingId: String(params.bindingId ?? ""),
             focus: params.focus === true,
             initialUrl: typeof params.url === "string" ? params.url : void 0
           });
-          for (const tab of result.workspace.tabs) {
+          for (const tab of result.binding.tabs) {
             void ensureNetworkDebugger(tab.id).catch(() => void 0);
           }
-          return result;
+          return {
+            browser: result.binding,
+            created: result.created,
+            repaired: result.repaired,
+            repairActions: result.repairActions
+          };
         });
       }
-      case "workspace.info": {
+      case "sessionBinding.info": {
         return {
-          workspace: await bindingManager.getWorkspaceInfo(String(params.workspaceId ?? ""))
+          browser: await bindingManager.getBindingInfo(String(params.bindingId ?? ""))
         };
       }
-      case "workspace.openTab": {
+      case "sessionBinding.openTab": {
         const expectedUrl = typeof params.url === "string" ? params.url : void 0;
         const opened = await preserveHumanFocus(params.focus !== true, async () => {
           return await bindingManager.openTab({
-            workspaceId: String(params.workspaceId ?? ""),
+            bindingId: String(params.bindingId ?? ""),
             url: expectedUrl,
             active: params.active === true,
             focus: params.focus === true
           });
         });
-        const finalized = await finalizeOpenedWorkspaceTab(opened, expectedUrl);
+        const finalized = await finalizeOpenedSessionBindingTab(opened, expectedUrl);
         void ensureNetworkDebugger(finalized.tab.id).catch(() => void 0);
-        return finalized;
+        return {
+          browser: finalized.binding,
+          tab: finalized.tab
+        };
       }
-      case "workspace.listTabs": {
-        return await bindingManager.listTabs(String(params.workspaceId ?? ""));
+      case "sessionBinding.listTabs": {
+        const listed = await bindingManager.listTabs(String(params.bindingId ?? ""));
+        return {
+          browser: listed.binding,
+          tabs: listed.tabs
+        };
       }
-      case "workspace.getActiveTab": {
-        return await bindingManager.getActiveTab(String(params.workspaceId ?? ""));
+      case "sessionBinding.getActiveTab": {
+        const active = await bindingManager.getActiveTab(String(params.bindingId ?? ""));
+        return {
+          browser: active.binding,
+          tab: active.tab
+        };
       }
-      case "workspace.setActiveTab": {
-        const result = await bindingManager.setActiveTab(Number(params.tabId), String(params.workspaceId ?? ""));
+      case "sessionBinding.setActiveTab": {
+        const result = await bindingManager.setActiveTab(Number(params.tabId), String(params.bindingId ?? ""));
         void ensureNetworkDebugger(result.tab.id).catch(() => void 0);
-        return result;
+        return {
+          browser: result.binding,
+          tab: result.tab
+        };
       }
-      case "workspace.focus": {
-        return await bindingManager.focus(String(params.workspaceId ?? ""));
+      case "sessionBinding.focus": {
+        const result = await bindingManager.focus(String(params.bindingId ?? ""));
+        return {
+          ok: true,
+          browser: result.binding
+        };
       }
-      case "workspace.reset": {
+      case "sessionBinding.reset": {
         return await preserveHumanFocus(params.focus !== true, async () => {
-          return await bindingManager.reset({
-            workspaceId: String(params.workspaceId ?? ""),
+          const result = await bindingManager.reset({
+            bindingId: String(params.bindingId ?? ""),
             focus: params.focus === true,
             initialUrl: typeof params.url === "string" ? params.url : void 0
           });
+          return {
+            browser: result.binding,
+            created: result.created,
+            repaired: result.repaired,
+            repairActions: result.repairActions
+          };
         });
       }
-      case "workspace.close": {
-        return await bindingManager.close(String(params.workspaceId ?? ""));
+      case "sessionBinding.close": {
+        return await bindingManager.close(String(params.bindingId ?? ""));
       }
       case "page.goto": {
         return await preserveHumanFocus(typeof target.tabId !== "number", async () => {
@@ -2562,7 +2982,7 @@
           if (!first) {
             throw toError("E_EXECUTION", "network replay returned no response payload");
           }
-          return first;
+          return params.withSchema === "auto" && params.mode === "json" ? await enrichReplayWithSchema(tab.id, first) : first;
         });
       }
       case "page.freshness": {
@@ -2638,15 +3058,17 @@
           const tab = await withTab(target);
           await ensureNetworkDebugger(tab.id).catch(() => void 0);
           const inspection = await collectPageInspection(tab.id, params);
+          const pageDataCandidates = await probePageDataCandidatesForTab(tab.id, inspection);
           const network = listNetworkEntries(tab.id, { limit: 10 });
           return {
             suspiciousGlobals: inspection.suspiciousGlobals ?? [],
             tables: inspection.tables ?? [],
             visibleTimestamps: inspection.visibleTimestamps ?? [],
             inlineTimestamps: inspection.inlineTimestamps ?? [],
+            pageDataCandidates,
             recentNetwork: network,
             recommendedNextSteps: [
-              "bak page extract --path table_data",
+              "bak page extract --path table_data --resolver auto",
               "bak network search --pattern table_data",
               "bak page freshness"
             ]
@@ -2663,6 +3085,7 @@
             lastMutationAt: inspection.lastMutationAt ?? null,
             timers: inspection.timers ?? { timeouts: 0, intervals: 0 },
             networkCount: network.length,
+            networkCadence: summarizeNetworkCadence(network),
             recentNetwork: network.slice(0, 10)
           };
         });
@@ -2673,7 +3096,10 @@
           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
+            lagMs: typeof freshness.latestNetworkTimestamp === "number" && typeof (freshness.latestPageDataTimestamp ?? freshness.latestInlineDataTimestamp) === "number" ? Math.max(
+              0,
+              freshness.latestNetworkTimestamp - (freshness.latestPageDataTimestamp ?? freshness.latestInlineDataTimestamp ?? freshness.latestNetworkTimestamp)
+            ) : null
           };
         });
       }
@@ -2777,7 +3203,7 @@
       ws?.send(JSON.stringify({
         type: "hello",
         role: "extension",
-        version: "0.6.0",
+        version: "0.6.1",
         ts: Date.now()
       }));
     });
@@ -2813,48 +3239,48 @@
   }
   chrome.tabs.onRemoved.addListener((tabId) => {
     dropNetworkCapture(tabId);
-    void listWorkspaceStates().then(async (states) => {
-      for (const state of states) {
+    void mutateSessionBindingStateMap((stateMap) => {
+      for (const [bindingId, state] of Object.entries(stateMap)) {
         if (!state.tabIds.includes(tabId)) {
           continue;
         }
         const nextTabIds = state.tabIds.filter((id) => id !== tabId);
-        await saveWorkspaceState({
+        stateMap[bindingId] = {
           ...state,
           tabIds: nextTabIds,
           activeTabId: state.activeTabId === tabId ? null : state.activeTabId,
           primaryTabId: state.primaryTabId === tabId ? null : state.primaryTabId
-        });
+        };
       }
     });
   });
   chrome.tabs.onActivated.addListener((activeInfo) => {
-    void listWorkspaceStates().then(async (states) => {
-      for (const state of states) {
+    void mutateSessionBindingStateMap((stateMap) => {
+      for (const [bindingId, state] of Object.entries(stateMap)) {
         if (state.windowId !== activeInfo.windowId || !state.tabIds.includes(activeInfo.tabId)) {
           continue;
         }
-        await saveWorkspaceState({
+        stateMap[bindingId] = {
           ...state,
           activeTabId: activeInfo.tabId
-        });
+        };
       }
     });
   });
   chrome.windows.onRemoved.addListener((windowId) => {
-    void listWorkspaceStates().then(async (states) => {
-      for (const state of states) {
+    void mutateSessionBindingStateMap((stateMap) => {
+      for (const [bindingId, state] of Object.entries(stateMap)) {
         if (state.windowId !== windowId) {
           continue;
         }
-        await saveWorkspaceState({
+        stateMap[bindingId] = {
           ...state,
           windowId: null,
           groupId: null,
           tabIds: [],
           activeTabId: null,
           primaryTabId: null
-        });
+        };
       }
     });
   });