@flrande/bak-extension 0.6.8 → 0.6.10

package/src/session-binding.ts

@@ -1,9 +1,9 @@
-export const DEFAULT_SESSION_BINDING_LABEL = 'bak agent';
-export const DEFAULT_SESSION_BINDING_COLOR = 'blue';
-export const DEFAULT_SESSION_BINDING_URL = 'about:blank';
-const WINDOW_LOOKUP_TIMEOUT_MS = 1_500;
-const GROUP_LOOKUP_TIMEOUT_MS = 1_000;
-const WINDOW_TABS_LOOKUP_TIMEOUT_MS = 1_500;
+export const DEFAULT_SESSION_BINDING_LABEL = 'bak agent';
+export const DEFAULT_SESSION_BINDING_COLOR = 'blue';
+export const DEFAULT_SESSION_BINDING_URL = 'about:blank';
+const WINDOW_LOOKUP_TIMEOUT_MS = 1_500;
+const GROUP_LOOKUP_TIMEOUT_MS = 1_000;
+const WINDOW_TABS_LOOKUP_TIMEOUT_MS = 1_500;
 
 export type SessionBindingColor = 'grey' | 'blue' | 'red' | 'yellow' | 'green' | 'pink' | 'purple' | 'cyan' | 'orange';
 
@@ -16,11 +16,11 @@ export interface SessionBindingTab {
   groupId: number | null;
 }
 
-export interface SessionBindingWindow {
-  id: number;
-  focused: boolean;
-  initialTabId?: number | null;
-}
+export interface SessionBindingWindow {
+  id: number;
+  focused: boolean;
+  initialTabId?: number | null;
+}
 
 export interface SessionBindingGroup {
   id: number;
@@ -68,8 +68,8 @@ export interface SessionBindingStorage {
   list(): Promise<SessionBindingRecord[]>;
 }
 
-export interface SessionBindingBrowser {
-  getTab(tabId: number): Promise<SessionBindingTab | null>;
+export interface SessionBindingBrowser {
+  getTab(tabId: number): Promise<SessionBindingTab | null>;
   getActiveTab(): Promise<SessionBindingTab | null>;
   listTabs(filter?: { windowId?: number }): Promise<SessionBindingTab[]>;
   createTab(options: { windowId?: number; url?: string; active?: boolean }): Promise<SessionBindingTab>;
@@ -81,29 +81,23 @@ export interface SessionBindingBrowser {
   closeWindow(windowId: number): Promise<void>;
   getGroup(groupId: number): Promise<SessionBindingGroup | null>;
   groupTabs(tabIds: number[], groupId?: number): Promise<number>;
-  updateGroup(groupId: number, options: { title?: string; color?: SessionBindingColor; collapsed?: boolean }): Promise<SessionBindingGroup>;
-}
-
-interface SessionBindingWindowOwnership {
-  bindingTabs: SessionBindingTab[];
-  sharedBindingTabs: SessionBindingTab[];
-  foreignTabs: SessionBindingTab[];
-}
-
+  updateGroup(groupId: number, options: { title?: string; color?: SessionBindingColor; collapsed?: boolean }): Promise<SessionBindingGroup>;
+}
+
 export interface SessionBindingEnsureOptions {
-  bindingId?: string;
-  focus?: boolean;
-  initialUrl?: string;
-  label?: string;
-}
-
-export interface SessionBindingOpenTabOptions {
-  bindingId?: string;
-  url?: string;
-  active?: boolean;
-  focus?: boolean;
-  label?: string;
-}
+  bindingId?: string;
+  focus?: boolean;
+  initialUrl?: string;
+  label?: string;
+}
+
+export interface SessionBindingOpenTabOptions {
+  bindingId?: string;
+  url?: string;
+  active?: boolean;
+  focus?: boolean;
+  label?: string;
+}
 
 export interface SessionBindingResolveTargetOptions {
   tabId?: number;
@@ -124,13 +118,13 @@ class SessionBindingManager {
     return this.inspectBinding(bindingId);
   }
 
-  async ensureBinding(options: SessionBindingEnsureOptions = {}): Promise<SessionBindingEnsureResult> {
-    const bindingId = this.normalizeBindingId(options.bindingId);
-    const repairActions: string[] = [];
-    const initialUrl = options.initialUrl ?? DEFAULT_SESSION_BINDING_URL;
-    const persisted = await this.storage.load(bindingId);
-    const created = !persisted;
-    let state = this.normalizeState(persisted, bindingId, options.label);
+  async ensureBinding(options: SessionBindingEnsureOptions = {}): Promise<SessionBindingEnsureResult> {
+    const bindingId = this.normalizeBindingId(options.bindingId);
+    const repairActions: string[] = [];
+    const initialUrl = options.initialUrl ?? DEFAULT_SESSION_BINDING_URL;
+    const persisted = await this.storage.load(bindingId);
+    const created = !persisted;
+    let state = this.normalizeState(persisted, bindingId, options.label);
 
     const originalWindowId = state.windowId;
     let window = state.windowId !== null ? await this.waitForWindow(state.windowId) : null;
@@ -145,46 +139,53 @@ class SessionBindingManager {
         }
       }
     }
+    if (!window) {
+      const activeWindow = await this.attachBindingToActiveWindow(state);
+      if (activeWindow) {
+        window = activeWindow;
+        repairActions.push('attached-active-window');
+      }
+    }
     if (!window) {
       const sharedWindow = await this.findSharedBindingWindow(bindingId);
       if (sharedWindow) {
         state.windowId = sharedWindow.id;
         state.groupId = null;
-        state.tabIds = [];
-        state.activeTabId = null;
-        state.primaryTabId = null;
-        window = sharedWindow;
-        repairActions.push('attached-shared-window');
-      } else {
-        const createdWindow = await this.browser.createWindow({
-          url: initialUrl,
-          focused: options.focus === true
-        });
-        state.windowId = createdWindow.id;
-        state.groupId = null;
-        state.tabIds = [];
-        state.activeTabId = null;
-        state.primaryTabId = null;
-        window = createdWindow;
-        const initialTab =
-          typeof createdWindow.initialTabId === 'number'
-            ? await this.waitForTrackedTab(createdWindow.initialTabId, createdWindow.id)
-            : null;
-        tabs = initialTab ? [initialTab] : await this.waitForWindowTabs(createdWindow.id);
-        state.tabIds = tabs.map((tab) => tab.id);
-        if (state.primaryTabId === null) {
-          state.primaryTabId = initialTab?.id ?? tabs[0]?.id ?? null;
-        }
-        if (state.activeTabId === null) {
-          state.activeTabId = tabs.find((tab) => tab.active)?.id ?? initialTab?.id ?? tabs[0]?.id ?? null;
-        }
-        repairActions.push(created ? 'created-window' : 'recreated-window');
-      }
+        state.tabIds = [];
+        state.activeTabId = null;
+        state.primaryTabId = null;
+        window = sharedWindow;
+        repairActions.push('attached-shared-window');
+      } else {
+        const createdWindow = await this.browser.createWindow({
+          url: initialUrl,
+          focused: options.focus === true
+        });
+        state.windowId = createdWindow.id;
+        state.groupId = null;
+        state.tabIds = [];
+        state.activeTabId = null;
+        state.primaryTabId = null;
+        window = createdWindow;
+        const initialTab =
+          typeof createdWindow.initialTabId === 'number'
+            ? await this.waitForTrackedTab(createdWindow.initialTabId, createdWindow.id)
+            : null;
+        tabs = initialTab ? [initialTab] : await this.waitForWindowTabs(createdWindow.id);
+        state.tabIds = tabs.map((tab) => tab.id);
+        if (state.primaryTabId === null) {
+          state.primaryTabId = initialTab?.id ?? tabs[0]?.id ?? null;
+        }
+        if (state.activeTabId === null) {
+          state.activeTabId = tabs.find((tab) => tab.active)?.id ?? initialTab?.id ?? tabs[0]?.id ?? null;
+        }
+        repairActions.push(created ? 'created-window' : 'recreated-window');
+      }
     }
 
     tabs = tabs.length > 0 ? tabs : await this.readTrackedTabs(state.tabIds, state.windowId);
     const recoveredTabs = await this.recoverBindingTabs(state, tabs);
-    if (recoveredTabs.length > tabs.length) {
+    if (recoveredTabs.length > tabs.length) {
       tabs = recoveredTabs;
       repairActions.push('recovered-tracked-tabs');
     }
@@ -193,26 +194,15 @@ class SessionBindingManager {
     }
     state.tabIds = tabs.map((tab) => tab.id);
 
-    if (state.windowId !== null) {
-      const ownership = await this.inspectBindingWindowOwnership(state, state.windowId);
-      if (ownership.foreignTabs.length > 0 && ownership.bindingTabs.length > 0) {
-        const migrated = await this.moveBindingIntoBakWindow(state, ownership, initialUrl);
-        window = migrated.window;
-        tabs = migrated.tabs;
-        state.tabIds = tabs.map((tab) => tab.id);
-        repairActions.push('evacuated-foreign-window');
-      }
-    }
-
     if (tabs.length === 0) {
-      const primary = await this.createBindingTab({
-        windowId: state.windowId,
-        url: initialUrl,
-        active: true
-      });
-      tabs = [primary];
-      state.tabIds = [primary.id];
-      state.primaryTabId = primary.id;
+      const primary = await this.createBindingTab({
+        windowId: state.windowId,
+        url: initialUrl,
+        active: options.focus === true
+      });
+      tabs = [primary];
+      state.tabIds = [primary.id];
+      state.primaryTabId = primary.id;
       state.activeTabId = primary.id;
       repairActions.push('created-primary-tab');
     }
@@ -227,7 +217,7 @@ class SessionBindingManager {
       repairActions.push('reassigned-active-tab');
     }
 
-    let group = state.groupId !== null ? await this.waitForGroup(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, {
@@ -265,12 +255,12 @@ class SessionBindingManager {
     }
     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;
-      repairActions.push('focused-window');
-    }
+    if (options.focus === true && state.windowId !== null && state.activeTabId !== null) {
+      await this.focusBindingWindow(state.windowId, state.activeTabId);
+      window = await this.waitForWindow(state.windowId, 300);
+      void window;
+      repairActions.push('focused-window');
+    }
 
     await this.storage.save(state);
 
@@ -285,15 +275,15 @@ class SessionBindingManager {
     };
   }
 
-  async openTab(options: SessionBindingOpenTabOptions = {}): Promise<{ binding: SessionBindingInfo; tab: SessionBindingTab }> {
-    const bindingId = this.normalizeBindingId(options.bindingId);
-    const hadBinding = (await this.loadBindingRecord(bindingId)) !== null;
-    const ensured = await this.ensureBinding({
-      bindingId,
-      focus: false,
-      initialUrl: hadBinding ? options.url ?? DEFAULT_SESSION_BINDING_URL : DEFAULT_SESSION_BINDING_URL,
-      label: options.label
-    });
+  async openTab(options: SessionBindingOpenTabOptions = {}): Promise<{ binding: SessionBindingInfo; tab: SessionBindingTab }> {
+    const bindingId = this.normalizeBindingId(options.bindingId);
+    const hadBinding = (await this.loadBindingRecord(bindingId)) !== null;
+    const ensured = await this.ensureBinding({
+      bindingId,
+      focus: false,
+      initialUrl: hadBinding ? options.url ?? DEFAULT_SESSION_BINDING_URL : DEFAULT_SESSION_BINDING_URL,
+      label: options.label
+    });
     let state = { ...ensured.binding, tabIds: [...ensured.binding.tabIds], tabs: [...ensured.binding.tabs] };
     if (state.windowId !== null && state.tabs.length === 0) {
       const rebound = await this.rebindBindingWindow(state);
@@ -305,12 +295,12 @@ class SessionBindingManager {
     }
     const active = options.active === true;
     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')
-    );
+    let reusablePrimaryTab = await this.resolveReusablePrimaryTab(
+      state,
+      ensured.created ||
+        ensured.repairActions.includes('recreated-window') ||
+        ensured.repairActions.includes('created-primary-tab')
+    );
 
     let createdTab: SessionBindingTab;
     try {
@@ -328,12 +318,12 @@ class SessionBindingManager {
       if (!this.isMissingWindowError(error)) {
         throw error;
       }
-      const repaired = await this.ensureBinding({
-        bindingId,
-        focus: false,
-        initialUrl: desiredUrl,
-        label: options.label
-      });
+      const repaired = await this.ensureBinding({
+        bindingId,
+        focus: false,
+        initialUrl: desiredUrl,
+        label: options.label
+      });
       state = { ...repaired.binding };
       reusablePrimaryTab = await this.resolveReusablePrimaryTab(state, true);
       createdTab = reusablePrimaryTab
@@ -361,14 +351,13 @@ class SessionBindingManager {
       windowId: state.windowId,
       groupId,
       tabIds: nextTabIds,
-      activeTabId: active || options.focus === true ? createdTab.id : state.activeTabId ?? state.primaryTabId ?? createdTab.id,
+      activeTabId: active || options.focus === true ? createdTab.id : state.activeTabId ?? state.primaryTabId ?? createdTab.id,
       primaryTabId: state.primaryTabId ?? createdTab.id
     };
 
-    if (options.focus === true) {
-      await this.browser.updateTab(createdTab.id, { active: true });
-      await this.browser.updateWindow(state.windowId!, { focused: true });
-    }
+    if (options.focus === true && state.windowId !== null) {
+      await this.focusBindingWindow(state.windowId, createdTab.id);
+    }
 
     await this.storage.save(nextState);
     const tabs = await this.readTrackedTabs(nextState.tabIds, nextState.windowId);
@@ -442,96 +431,136 @@ class SessionBindingManager {
   }
 
   async focus(bindingId: string): Promise<{ ok: true; binding: SessionBindingInfo }> {
-    const ensured = await this.ensureBinding({ bindingId, focus: false });
-    if (ensured.binding.activeTabId !== null) {
-      await this.browser.updateTab(ensured.binding.activeTabId, { active: true });
-    }
-    if (ensured.binding.windowId !== null) {
-      await this.browser.updateWindow(ensured.binding.windowId, { focused: true });
-    }
-    const refreshed = await this.ensureBinding({ bindingId, focus: false });
-    return { ok: true, binding: refreshed.binding };
-  }
+    const normalizedBindingId = this.normalizeBindingId(bindingId);
+    let binding =
+      (await this.inspectBinding(normalizedBindingId)) ??
+      (
+        await this.ensureBinding({
+          bindingId: normalizedBindingId,
+          focus: false
+        })
+      ).binding;
+    let targetTabId = this.resolveFocusTabId(binding);
 
-  async closeTab(bindingId: string, tabId?: number): Promise<{ binding: SessionBindingInfo | null; closedTabId: number }> {
-    const binding = await this.inspectBinding(bindingId);
-    if (!binding) {
-      throw new Error(`Binding ${bindingId} does not exist`);
-    }
-    const resolvedTabId =
-      typeof tabId === 'number'
-        ? tabId
-        : binding.activeTabId ?? binding.primaryTabId ?? binding.tabs[0]?.id;
-    if (typeof resolvedTabId !== 'number' || !binding.tabIds.includes(resolvedTabId)) {
-      throw new Error(`Tab ${tabId ?? 'active'} does not belong to binding ${bindingId}`);
+    if (binding.windowId === null || targetTabId === null) {
+      binding = (
+        await this.ensureBinding({
+          bindingId: normalizedBindingId,
+          focus: false
+        })
+      ).binding;
+      targetTabId = this.resolveFocusTabId(binding);
     }
 
-    await this.browser.closeTab(resolvedTabId);
-    const remainingTabIds = binding.tabIds.filter((candidate) => candidate !== resolvedTabId);
-
-    if (remainingTabIds.length === 0) {
-      await this.storage.delete(binding.id);
-      return {
-        binding: null,
-        closedTabId: resolvedTabId
-      };
+    if (binding.windowId !== null && targetTabId !== null) {
+      try {
+        await this.focusBindingWindow(binding.windowId, targetTabId);
+      } catch (error) {
+        if (!this.isMissingWindowError(error)) {
+          throw error;
+        }
+        binding = (
+          await this.ensureBinding({
+            bindingId: normalizedBindingId,
+            focus: false
+          })
+        ).binding;
+        targetTabId = this.resolveFocusTabId(binding);
+        if (binding.windowId !== null && targetTabId !== null) {
+          await this.focusBindingWindow(binding.windowId, targetTabId);
+        }
+      }
     }
 
-    const tabs = await this.readLooseTrackedTabs(remainingTabIds);
-    const nextPrimaryTabId =
-      binding.primaryTabId === resolvedTabId ? tabs[0]?.id ?? null : binding.primaryTabId;
-    const nextActiveTabId =
-      binding.activeTabId === resolvedTabId
-        ? tabs.find((candidate) => candidate.active)?.id ?? nextPrimaryTabId ?? tabs[0]?.id ?? null
-        : binding.activeTabId;
-    const nextState: SessionBindingRecord = {
-      id: binding.id,
-      label: binding.label,
-      color: binding.color,
-      windowId: tabs[0]?.windowId ?? binding.windowId,
-      groupId: tabs[0]?.groupId ?? binding.groupId,
-      tabIds: tabs.map((candidate) => candidate.id),
-      activeTabId: nextActiveTabId,
-      primaryTabId: nextPrimaryTabId
-    };
-    await this.storage.save(nextState);
+    const refreshed = (await this.inspectBinding(normalizedBindingId)) ?? binding;
     return {
-      binding: {
-        ...nextState,
-        tabs
-      },
-      closedTabId: resolvedTabId
+      ok: true,
+      binding:
+        refreshed.windowId !== null && targetTabId !== null
+          ? this.withFocusedTab(refreshed, targetTabId)
+          : refreshed
     };
   }
-
-  async reset(options: SessionBindingEnsureOptions = {}): Promise<SessionBindingEnsureResult> {
-    const bindingId = this.normalizeBindingId(options.bindingId);
-    await this.close(bindingId);
+
+  async closeTab(bindingId: string, tabId?: number): Promise<{ binding: SessionBindingInfo | null; closedTabId: number }> {
+    const binding = await this.inspectBinding(bindingId);
+    if (!binding) {
+      throw new Error(`Binding ${bindingId} does not exist`);
+    }
+    const resolvedTabId =
+      typeof tabId === 'number'
+        ? tabId
+        : binding.activeTabId ?? binding.primaryTabId ?? binding.tabs[0]?.id;
+    if (typeof resolvedTabId !== 'number' || !binding.tabIds.includes(resolvedTabId)) {
+      throw new Error(`Tab ${tabId ?? 'active'} does not belong to binding ${bindingId}`);
+    }
+
+    await this.browser.closeTab(resolvedTabId);
+    const remainingTabIds = binding.tabIds.filter((candidate) => candidate !== resolvedTabId);
+
+    if (remainingTabIds.length === 0) {
+      await this.storage.delete(binding.id);
+      return {
+        binding: null,
+        closedTabId: resolvedTabId
+      };
+    }
+
+    const tabs = await this.readLooseTrackedTabs(remainingTabIds);
+    const nextPrimaryTabId =
+      binding.primaryTabId === resolvedTabId ? tabs[0]?.id ?? null : binding.primaryTabId;
+    const nextActiveTabId =
+      binding.activeTabId === resolvedTabId
+        ? tabs.find((candidate) => candidate.active)?.id ?? nextPrimaryTabId ?? tabs[0]?.id ?? null
+        : binding.activeTabId;
+    const nextState: SessionBindingRecord = {
+      id: binding.id,
+      label: binding.label,
+      color: binding.color,
+      windowId: tabs[0]?.windowId ?? binding.windowId,
+      groupId: tabs[0]?.groupId ?? binding.groupId,
+      tabIds: tabs.map((candidate) => candidate.id),
+      activeTabId: nextActiveTabId,
+      primaryTabId: nextPrimaryTabId
+    };
+    await this.storage.save(nextState);
+    return {
+      binding: {
+        ...nextState,
+        tabs
+      },
+      closedTabId: resolvedTabId
+    };
+  }
+
+  async reset(options: SessionBindingEnsureOptions = {}): Promise<SessionBindingEnsureResult> {
+    const bindingId = this.normalizeBindingId(options.bindingId);
+    await this.close(bindingId);
     return this.ensureBinding({
       ...options,
       bindingId
     });
   }
 
-  async close(bindingId: string): Promise<{ ok: true }> {
-    const state = await this.loadBindingRecord(bindingId);
-    if (!state) {
-      await this.storage.delete(bindingId);
-      return { ok: true };
-    }
-    // Clear persisted state before closing the window so tab/window removal
-    // listeners cannot race and resurrect an empty binding record.
-    await this.storage.delete(bindingId);
-    const trackedTabs = await this.collectBindingTabsForClose(state);
-    for (const trackedTab of trackedTabs) {
-      try {
-        await this.browser.closeTab(trackedTab.id);
-      } catch {
-        // Ignore tabs that were already removed before explicit close.
-      }
-    }
-    return { ok: true };
-  }
+  async close(bindingId: string): Promise<{ ok: true }> {
+    const state = await this.loadBindingRecord(bindingId);
+    if (!state) {
+      await this.storage.delete(bindingId);
+      return { ok: true };
+    }
+    // Clear persisted state before closing the window so tab/window removal
+    // listeners cannot race and resurrect an empty binding record.
+    await this.storage.delete(bindingId);
+    const trackedTabs = await this.collectBindingTabsForClose(state);
+    for (const trackedTab of trackedTabs) {
+      try {
+        await this.browser.closeTab(trackedTab.id);
+      } catch {
+        // Ignore tabs that were already removed before explicit close.
+      }
+    }
+    return { ok: true };
+  }
 
   async resolveTarget(options: SessionBindingResolveTargetOptions = {}): Promise<SessionBindingTargetResolution> {
     if (typeof options.tabId === 'number') {
@@ -584,13 +613,13 @@ class SessionBindingManager {
     return candidate;
   }
 
-  private normalizeState(state: SessionBindingRecord | null, bindingId: string, label?: string): SessionBindingRecord {
-    return {
-      id: bindingId,
-      label: label?.trim() ? label.trim() : state?.label ?? DEFAULT_SESSION_BINDING_LABEL,
-      color: state?.color ?? DEFAULT_SESSION_BINDING_COLOR,
-      windowId: state?.windowId ?? null,
-      groupId: state?.groupId ?? null,
+  private normalizeState(state: SessionBindingRecord | null, bindingId: string, label?: string): SessionBindingRecord {
+    return {
+      id: bindingId,
+      label: label?.trim() ? label.trim() : state?.label ?? DEFAULT_SESSION_BINDING_LABEL,
+      color: state?.color ?? DEFAULT_SESSION_BINDING_COLOR,
+      windowId: state?.windowId ?? null,
+      groupId: state?.groupId ?? null,
       tabIds: state?.tabIds ?? [],
       activeTabId: state?.activeTabId ?? null,
       primaryTabId: state?.primaryTabId ?? null
@@ -687,7 +716,7 @@ class SessionBindingManager {
     return [...new Set(state.tabIds.concat([state.activeTabId, state.primaryTabId].filter((value): value is number => typeof value === 'number')))];
   }
 
-  private async rebindBindingWindow(state: SessionBindingRecord): Promise<{ window: SessionBindingWindow; tabs: SessionBindingTab[] } | null> {
+  private async rebindBindingWindow(state: SessionBindingRecord): Promise<{ window: SessionBindingWindow; tabs: SessionBindingTab[] } | null> {
     const candidateWindowIds: number[] = [];
     const pushWindowId = (windowId: number | null | undefined): void => {
       if (typeof windowId !== 'number') {
@@ -698,7 +727,7 @@ class SessionBindingManager {
       }
     };
 
-    const group = state.groupId !== null ? await this.waitForGroup(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));
@@ -707,13 +736,13 @@ class SessionBindingManager {
     }
 
     for (const candidateWindowId of candidateWindowIds) {
-      const window = await this.waitForWindow(candidateWindowId);
+      const window = await this.waitForWindow(candidateWindowId);
       if (!window) {
         continue;
       }
       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, WINDOW_TABS_LOOKUP_TIMEOUT_MS);
+        const windowTabs = await this.waitForWindowTabs(candidateWindowId, WINDOW_TABS_LOOKUP_TIMEOUT_MS);
         tabs = windowTabs.filter((tab) => tab.groupId === group.id);
       }
       if (tabs.length === 0) {
@@ -735,146 +764,21 @@ class SessionBindingManager {
     return null;
   }
 
-  private async inspectBindingWindowOwnership(state: SessionBindingRecord, windowId: number): Promise<SessionBindingWindowOwnership> {
-    const windowTabs = await this.waitForWindowTabs(windowId, 500);
-    const bindingTabIds = new Set(this.collectCandidateTabIds(state));
-    const peerBindings = (await this.storage.list()).filter((candidate) => candidate.id !== state.id);
-    const peerTabIds = new Set<number>();
-    const peerGroupIds = new Set<number>();
-    for (const peer of peerBindings) {
-      for (const tabId of this.collectCandidateTabIds(peer)) {
-        peerTabIds.add(tabId);
-      }
-      if (peer.groupId !== null) {
-        peerGroupIds.add(peer.groupId);
-      }
-    }
-
-    const bindingTabs: SessionBindingTab[] = [];
-    const sharedBindingTabs: SessionBindingTab[] = [];
-    const foreignTabs: SessionBindingTab[] = [];
-    for (const tab of windowTabs) {
-      if (bindingTabIds.has(tab.id) || (state.groupId !== null && tab.groupId === state.groupId)) {
-        bindingTabs.push(tab);
-        continue;
-      }
-      if (peerTabIds.has(tab.id) || (tab.groupId !== null && peerGroupIds.has(tab.groupId))) {
-        sharedBindingTabs.push(tab);
-        continue;
-      }
-      foreignTabs.push(tab);
-    }
-
-    return {
-      bindingTabs,
-      sharedBindingTabs,
-      foreignTabs
-    };
-  }
-
-  private async moveBindingIntoBakWindow(
-    state: SessionBindingRecord,
-    ownership: SessionBindingWindowOwnership,
-    initialUrl: string
-  ): Promise<{ window: SessionBindingWindow; tabs: SessionBindingTab[] }> {
-    const sourceTabs = this.orderSessionBindingTabsForMigration(state, ownership.bindingTabs);
-    const seedUrl = sourceTabs[0]?.url ?? initialUrl;
-    const sharedWindow = await this.findSharedBindingWindow(state.id, state.windowId === null ? [] : [state.windowId]);
-    const window =
-      sharedWindow ??
-      (await this.browser.createWindow({
-        url: seedUrl || DEFAULT_SESSION_BINDING_URL,
-        focused: false
-      }));
-    const initialTab =
-      sharedWindow || typeof window.initialTabId !== 'number' ? null : await this.waitForTrackedTab(window.initialTabId, window.id);
-    const recreatedTabs: SessionBindingTab[] = [];
-    const tabIdMap = new Map<number, number>();
-
-    if (sourceTabs[0]) {
-      const firstTab = initialTab
-        ? await this.browser.updateTab(initialTab.id, {
-            url: sourceTabs[0].url,
-            active: false
-          })
-        : await this.createBindingTab({
-            windowId: window.id,
-            url: sourceTabs[0].url,
-            active: false
-          });
-      recreatedTabs.push(firstTab);
-      tabIdMap.set(sourceTabs[0].id, firstTab.id);
-    }
-
-    for (const sourceTab of sourceTabs.slice(1)) {
-      const recreated = await this.createBindingTab({
-        windowId: window.id,
-        url: sourceTab.url,
-        active: false
-      });
-      recreatedTabs.push(recreated);
-      tabIdMap.set(sourceTab.id, recreated.id);
+  private async attachBindingToActiveWindow(state: SessionBindingRecord): Promise<SessionBindingWindow | null> {
+    const activeTab = await this.browser.getActiveTab();
+    if (!activeTab) {
+      return null;
     }
-
-    const nextPrimaryTabId =
-      (state.primaryTabId !== null ? tabIdMap.get(state.primaryTabId) : undefined) ??
-      recreatedTabs[0]?.id ??
-      null;
-    const nextActiveTabId =
-      (state.activeTabId !== null ? tabIdMap.get(state.activeTabId) : undefined) ?? nextPrimaryTabId ?? recreatedTabs[0]?.id ?? null;
-    if (nextActiveTabId !== null) {
-      await this.browser.updateTab(nextActiveTabId, { active: true });
+    const window = await this.waitForWindow(activeTab.windowId, 300);
+    if (!window) {
+      return null;
     }
-
     state.windowId = window.id;
     state.groupId = null;
-    state.tabIds = recreatedTabs.map((tab) => tab.id);
-    state.primaryTabId = nextPrimaryTabId;
-    state.activeTabId = nextActiveTabId;
-    await this.storage.save({
-      ...state,
-      tabIds: [...state.tabIds]
-    });
-
-    for (const bindingTab of ownership.bindingTabs) {
-      try {
-        await this.browser.closeTab(bindingTab.id);
-      } catch {
-        // Ignore tabs that were already removed while evacuating the binding.
-      }
-    }
-
-    return {
-      window,
-      tabs: await this.readTrackedTabs(state.tabIds, state.windowId)
-    };
-  }
-
-  private orderSessionBindingTabsForMigration(state: SessionBindingRecord, tabs: SessionBindingTab[]): SessionBindingTab[] {
-    const ordered: SessionBindingTab[] = [];
-    const seen = new Set<number>();
-    const pushById = (tabId: number | null): void => {
-      if (typeof tabId !== 'number') {
-        return;
-      }
-      const tab = tabs.find((candidate) => candidate.id === tabId);
-      if (!tab || seen.has(tab.id)) {
-        return;
-      }
-      ordered.push(tab);
-      seen.add(tab.id);
-    };
-
-    pushById(state.primaryTabId);
-    pushById(state.activeTabId);
-    for (const tab of tabs) {
-      if (seen.has(tab.id)) {
-        continue;
-      }
-      ordered.push(tab);
-      seen.add(tab.id);
-    }
-    return ordered;
+    state.tabIds = [];
+    state.activeTabId = null;
+    state.primaryTabId = null;
+    return window;
   }
 
   private async findSharedBindingWindow(bindingId: string, excludedWindowIds: number[] = []): Promise<SessionBindingWindow | null> {
@@ -886,51 +790,47 @@ class SessionBindingManager {
       if (typeof windowId !== 'number') {
         return;
       }
-      if (excludedWindowIds.includes(windowId) || candidateWindowIds.includes(windowId)) {
-        return;
-      }
-      candidateWindowIds.push(windowId);
-    };
+      if (excludedWindowIds.includes(windowId) || candidateWindowIds.includes(windowId)) {
+        return;
+      }
+      candidateWindowIds.push(windowId);
+    };
 
     for (const peer of peers) {
-      pushWindowId(peer.windowId);
-      if (peer.groupId !== null) {
-        peerGroupIds.add(peer.groupId);
-        const group = await this.waitForGroup(peer.groupId, 300);
-        pushWindowId(group?.windowId);
-      }
       const trackedTabIds = this.collectCandidateTabIds(peer);
+      pushWindowId(peer.windowId);
       for (const trackedTabId of trackedTabIds) {
         peerTabIds.add(trackedTabId);
       }
+      if (peer.groupId !== null) {
+        const group = await this.waitForGroup(peer.groupId, 300);
+        if (group) {
+          peerGroupIds.add(group.id);
+          pushWindowId(group.windowId);
+        }
+      }
       const trackedTabs = await this.readLooseTrackedTabs(trackedTabIds);
       for (const tab of trackedTabs) {
         pushWindowId(tab.windowId);
       }
     }
-
+
     for (const windowId of candidateWindowIds) {
       const window = await this.waitForWindow(windowId, 300);
       if (window) {
-        const windowTabs = await this.waitForWindowTabs(window.id, 300);
+        const windowTabs = await this.readStableWindowTabs(window.id, WINDOW_TABS_LOOKUP_TIMEOUT_MS, 150);
         const ownedTabs = windowTabs.filter(
           (tab) => peerTabIds.has(tab.id) || (tab.groupId !== null && peerGroupIds.has(tab.groupId))
         );
         if (ownedTabs.length === 0) {
           continue;
         }
-        const foreignTabs = windowTabs.filter(
-          (tab) => !peerTabIds.has(tab.id) && (tab.groupId === null || !peerGroupIds.has(tab.groupId))
-        );
-        if (foreignTabs.length > 0) {
-          continue;
-        }
         return window;
       }
     }
-
-    return null;
-  }
+
+    return null;
+  }
 
   private async recoverBindingTabs(state: SessionBindingRecord, existingTabs: SessionBindingTab[]): Promise<SessionBindingTab[]> {
     if (state.windowId === null) {
@@ -964,19 +864,43 @@ class SessionBindingManager {
     return existingTabs;
   }
 
-  private async collectBindingTabsForClose(state: SessionBindingRecord): Promise<SessionBindingTab[]> {
-    const trackedTabs = await this.readLooseTrackedTabs(this.collectCandidateTabIds(state));
-    if (state.windowId === null || state.groupId === null) {
-      return trackedTabs;
-    }
-    const windowTabs = await this.waitForWindowTabs(state.windowId, 300);
-    const groupedTabs = windowTabs.filter((tab) => tab.groupId === state.groupId);
-    const merged = new Map<number, SessionBindingTab>();
-    for (const tab of [...trackedTabs, ...groupedTabs]) {
-      merged.set(tab.id, tab);
+  private resolveFocusTabId(binding: Pick<SessionBindingInfo, 'activeTabId' | 'primaryTabId' | 'tabs'>): number | null {
+    return binding.activeTabId ?? binding.primaryTabId ?? binding.tabs[0]?.id ?? null;
+  }
+
+  private withFocusedTab(binding: SessionBindingInfo, targetTabId: number): SessionBindingInfo {
+    return {
+      ...binding,
+      activeTabId: targetTabId,
+      tabs: binding.tabs.map((tab) => ({
+        ...tab,
+        active: tab.id === targetTabId
+      }))
+    };
+  }
+
+  private async focusBindingWindow(windowId: number, tabId: number): Promise<void> {
+    await this.browser.updateWindow(windowId, { focused: true });
+    await this.browser.updateTab(tabId, { active: true });
+    const focusedTab = await this.waitForTrackedTab(tabId, windowId, 500);
+    if (!focusedTab?.active) {
+      await this.browser.updateTab(tabId, { active: true });
     }
-    return [...merged.values()];
   }
+
+  private async collectBindingTabsForClose(state: SessionBindingRecord): Promise<SessionBindingTab[]> {
+    const trackedTabs = await this.readLooseTrackedTabs(this.collectCandidateTabIds(state));
+    if (state.windowId === null || state.groupId === null) {
+      return trackedTabs;
+    }
+    const windowTabs = await this.waitForWindowTabs(state.windowId, 300);
+    const groupedTabs = windowTabs.filter((tab) => tab.groupId === state.groupId);
+    const merged = new Map<number, SessionBindingTab>();
+    for (const tab of [...trackedTabs, ...groupedTabs]) {
+      merged.set(tab.id, tab);
+    }
+    return [...merged.values()];
+  }
 
   private async createBindingTab(options: { windowId: number | null; url: string; active: boolean }): Promise<SessionBindingTab> {
     if (options.windowId === null) {
@@ -1005,18 +929,18 @@ class SessionBindingManager {
     throw lastError ?? new Error(`No window with id: ${options.windowId}.`);
   }
 
-  private async inspectBinding(bindingId: string): Promise<SessionBindingInfo | null> {
-    const state = await this.loadBindingRecord(bindingId);
-    if (!state) {
-      return null;
-    }
-
-    let tabs = await this.readTrackedTabs(state.tabIds, state.windowId);
-    tabs = await this.recoverBindingTabs(state, tabs);
-    const activeTab = state.activeTabId !== null ? await this.waitForTrackedTab(state.activeTabId, state.windowId, 300) : null;
-    if (activeTab && !tabs.some((tab) => tab.id === activeTab.id)) {
-      tabs = [...tabs, activeTab];
-    }
+  private async inspectBinding(bindingId: string): Promise<SessionBindingInfo | null> {
+    const state = await this.loadBindingRecord(bindingId);
+    if (!state) {
+      return null;
+    }
+
+    let tabs = await this.readTrackedTabs(state.tabIds, state.windowId);
+    tabs = await this.recoverBindingTabs(state, tabs);
+    const activeTab = state.activeTabId !== null ? await this.waitForTrackedTab(state.activeTabId, state.windowId, 300) : null;
+    if (activeTab && !tabs.some((tab) => tab.id === activeTab.id)) {
+      tabs = [...tabs, activeTab];
+    }
     if (tabs.length === 0 && state.primaryTabId !== null) {
       const primaryTab = await this.waitForTrackedTab(state.primaryTabId, state.windowId, 300);
       if (primaryTab) {
@@ -1036,12 +960,12 @@ class SessionBindingManager {
       return null;
     }
     if (binding.primaryTabId !== null) {
-      const trackedPrimary = binding.tabs.find((tab) => tab.id === binding.primaryTabId) ?? (await this.waitForTrackedTab(binding.primaryTabId, binding.windowId));
+      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(binding.windowId, WINDOW_TABS_LOOKUP_TIMEOUT_MS);
+    const windowTabs = await this.waitForWindowTabs(binding.windowId, WINDOW_TABS_LOOKUP_TIMEOUT_MS);
     if (windowTabs.length !== 1) {
       return null;
     }
@@ -1060,29 +984,29 @@ class SessionBindingManager {
     return normalizedUrl === '' || normalizedUrl === DEFAULT_SESSION_BINDING_URL;
   }
 
-  private async waitForWindow(windowId: number, timeoutMs = WINDOW_LOOKUP_TIMEOUT_MS): Promise<SessionBindingWindow | null> {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      const window = await this.browser.getWindow(windowId);
-      if (window) {
-        return window;
+  private async waitForWindow(windowId: number, timeoutMs = WINDOW_LOOKUP_TIMEOUT_MS): Promise<SessionBindingWindow | null> {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const window = await this.browser.getWindow(windowId);
+      if (window) {
+        return window;
       }
       await this.delay(50);
     }
-    return null;
-  }
-
-  private async waitForGroup(groupId: number, timeoutMs = GROUP_LOOKUP_TIMEOUT_MS): Promise<SessionBindingGroup | null> {
-    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;
-  }
+    return null;
+  }
+
+  private async waitForGroup(groupId: number, timeoutMs = GROUP_LOOKUP_TIMEOUT_MS): Promise<SessionBindingGroup | null> {
+    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;
+  }
 
   private async waitForTrackedTab(tabId: number, windowId: number | null, timeoutMs = 1_000): Promise<SessionBindingTab | null> {
     const deadline = Date.now() + timeoutMs;
@@ -1097,16 +1021,55 @@ class SessionBindingManager {
   }
 
   private async waitForWindowTabs(windowId: number, timeoutMs = WINDOW_TABS_LOOKUP_TIMEOUT_MS): Promise<SessionBindingTab[]> {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      const tabs = await this.browser.listTabs({ windowId });
-      if (tabs.length > 0) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const tabs = await this.browser.listTabs({ windowId });
+      if (tabs.length > 0) {
         return tabs;
       }
       await this.delay(50);
-    }
-    return [];
-  }
+    }
+    return [];
+  }
+
+  private async readStableWindowTabs(
+    windowId: number,
+    timeoutMs = WINDOW_TABS_LOOKUP_TIMEOUT_MS,
+    settleMs = 150
+  ): Promise<SessionBindingTab[]> {
+    const deadline = Date.now() + timeoutMs;
+    let bestTabs: SessionBindingTab[] = [];
+    let bestSignature = '';
+    let lastSignature = '';
+    let stableSince = 0;
+
+    while (Date.now() < deadline) {
+      const tabs = await this.browser.listTabs({ windowId });
+      if (tabs.length > 0) {
+        const signature = this.windowTabSnapshotSignature(tabs);
+        if (tabs.length > bestTabs.length || (tabs.length === bestTabs.length && signature !== bestSignature)) {
+          bestTabs = tabs;
+          bestSignature = signature;
+        }
+        if (signature !== lastSignature) {
+          lastSignature = signature;
+          stableSince = Date.now();
+        } else if (Date.now() - stableSince >= settleMs) {
+          return bestTabs;
+        }
+      }
+      await this.delay(50);
+    }
+
+    return bestTabs;
+  }
+
+  private windowTabSnapshotSignature(tabs: SessionBindingTab[]): string {
+    return [...tabs]
+      .map((tab) => `${tab.id}:${tab.groupId ?? 'ungrouped'}`)
+      .sort()
+      .join('|');
+  }
 
   private async delay(ms: number): Promise<void> {
     await new Promise((resolve) => setTimeout(resolve, ms));
@@ -1118,4 +1081,4 @@ class SessionBindingManager {
   }
 }
 
-export { SessionBindingManager };
+export { SessionBindingManager };