fix(tabs): coalesce concurrent open() calls so rapid clicks don't duplicate

User report: "I was able to get a pad to open twice if I click it
quickly multiple times. It shows up multiple times in the Tab view."

Root cause: TabManager.open() looks for an existing tab via
this.tabs.find(...) and bails early if found, but factory.create() is
async (it awaits webContents.loadURL). Two clicks <100ms apart both
pass the existence check while neither has pushed its tab yet, then
both push, then both register events — duplicate tabs.

Add an inflight Map<key, Promise<OpenTab>> keyed by
"\${workspaceId}|\${padName}". Concurrent calls that find an inflight
promise return that same promise, so all callers resolve to the same
OpenTab and only one factory.create + viewHost.add fires. Also re-
check for an existing tab AFTER the await, in case some other path
created one while we were waiting.

Three regression tests pin the contract:
- two concurrent opens for the same key resolve to one tab
- three concurrent opens still resolve to one tab
- after coalescing, a later open with the same key still dedups

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: JohnMcLear

src/main/tabs/tab-manager.ts

@@ -45,6 +45,13 @@ export class TabManager {
   private readonly tabs: Internal[] = [];
   private activeWorkspaceId: string | null = null;
   private activeTabId: string | null = null;
+  /**
+   * Tracks open() calls that are still awaiting factory.create() so a
+   * second rapid click on the same pad doesn't race past the existence
+   * check and end up creating a duplicate tab. Keyed by
+   * `${workspaceId}|${padName}`.
+   */
+  private readonly inflight = new Map<string, Promise<OpenTab>>();
 
   constructor(private readonly opts: TabManagerOptions) {}
 
@@ -76,27 +83,50 @@ export class TabManager {
       this.emitTabs();
       return existing.tab;
     }
-    const view = await this.opts.factory.create({
-      workspaceId: input.workspaceId,
-      src: input.src,
-      preloadPath: this.opts.preloadPath,
-    });
-    const tab: OpenTab = {
-      tabId: randomUUID(),
-      workspaceId: input.workspaceId,
-      padName: input.padName,
-      title: input.padName,
-      state: 'loading',
-    };
-    this.tabs.push({ tab, view });
-    this.opts.viewHost.add(view);
-    if (input.workspaceId === this.activeWorkspaceId) {
-      this.activeTabId = tab.tabId;
+    // Coalesce rapid concurrent opens for the same (workspace, pad) pair.
+    // Without this, two clicks <100ms apart both see no existing tab,
+    // both await factory.create(), both push their own view, and the
+    // user ends up with duplicate tabs.
+    const key = `${input.workspaceId}|${input.padName}`;
+    const inflight = this.inflight.get(key);
+    if (inflight) return inflight;
+
+    const promise = (async () => {
+      const view = await this.opts.factory.create({
+        workspaceId: input.workspaceId,
+        src: input.src,
+        preloadPath: this.opts.preloadPath,
+      });
+      // Re-check after the await: another path (e.g. a concurrent
+      // restoration) may have created the tab while we were waiting.
+      const raced = this.tabs.find(
+        (t) => t.tab.workspaceId === input.workspaceId && t.tab.padName === input.padName,
+      );
+      if (raced) return raced.tab;
+      const tab: OpenTab = {
+        tabId: randomUUID(),
+        workspaceId: input.workspaceId,
+        padName: input.padName,
+        title: input.padName,
+        state: 'loading',
+      };
+      this.tabs.push({ tab, view });
+      this.opts.viewHost.add(view);
+      if (input.workspaceId === this.activeWorkspaceId) {
+        this.activeTabId = tab.tabId;
+      }
+      this.applyVisibility();
+      this.wireViewEvents(tab.tabId, view);
+      return tab;
+    })();
+    this.inflight.set(key, promise);
+    try {
+      const tab = await promise;
+      this.emitTabs();
+      return tab;
+    } finally {
+      this.inflight.delete(key);
     }
-    this.applyVisibility();
-    this.wireViewEvents(tab.tabId, view);
-    this.emitTabs();
-    return tab;
   }
 
   close(tabId: string): void {

tests/main/tabs/tab-manager.spec.ts

@@ -4,7 +4,14 @@ import type { PadView } from '../../../src/main/pads/pad-view-factory';
 
 function fakeView(): PadView {
   return {
-    webContents: { loadURL: vi.fn().mockResolvedValue(undefined), on: vi.fn(), id: 1 },
+    webContents: {
+      loadURL: vi.fn().mockResolvedValue(undefined),
+      on: vi.fn(),
+      getUserAgent: vi.fn(() => 'Mozilla/5.0 Test'),
+      setUserAgent: vi.fn(),
+      focus: vi.fn(),
+      id: 1,
+    },
     setBounds: vi.fn(),
     setVisible: vi.fn(),
   };
@@ -55,6 +62,55 @@ describe('TabManager', () => {
     expect(factory.create).toHaveBeenCalledTimes(1);
   });
 
+  // REGRESSION: 2026-05-05 — user reported a pad opening multiple times
+  // when clicked quickly in succession. The dedup check looked for an
+  // existing tab BEFORE awaiting factory.create(); two concurrent opens
+  // both passed the check and both pushed their own view, producing
+  // duplicate tabs. Coalesce concurrent opens for the same key.
+  it('coalesces rapid concurrent opens for the same (workspaceId, padName)', async () => {
+    // Slow factory: returns a promise that resolves on the next tick so
+    // both calls overlap inside open().
+    let resolveCreate!: (v: PadView) => void;
+    factory.create = vi.fn().mockImplementation(
+      () => new Promise<PadView>((r) => { resolveCreate = r; }),
+    );
+    const p1 = mgr.open({ workspaceId: WS_A, padName: 'samepad', src: 'https://x/p/samepad' });
+    const p2 = mgr.open({ workspaceId: WS_A, padName: 'samepad', src: 'https://x/p/samepad' });
+    // Resolve the (single) factory call.
+    resolveCreate(fakeView());
+    const [a, b] = await Promise.all([p1, p2]);
+    expect(b.tabId).toBe(a.tabId);
+    expect(factory.create).toHaveBeenCalledTimes(1);
+    expect(host.add).toHaveBeenCalledTimes(1);
+  });
+
+  it('coalesces three concurrent opens too — all share one tab', async () => {
+    let resolveCreate!: (v: PadView) => void;
+    factory.create = vi.fn().mockImplementation(
+      () => new Promise<PadView>((r) => { resolveCreate = r; }),
+    );
+    const opens = [
+      mgr.open({ workspaceId: WS_A, padName: 'pad', src: 'https://x/p/pad' }),
+      mgr.open({ workspaceId: WS_A, padName: 'pad', src: 'https://x/p/pad' }),
+      mgr.open({ workspaceId: WS_A, padName: 'pad', src: 'https://x/p/pad' }),
+    ];
+    resolveCreate(fakeView());
+    const results = await Promise.all(opens);
+    const ids = new Set(results.map((t) => t.tabId));
+    expect(ids.size).toBe(1);
+    expect(factory.create).toHaveBeenCalledTimes(1);
+  });
+
+  it('after a coalesced open finishes, a later open with the same key returns the same tab', async () => {
+    const a = await mgr.open({ workspaceId: WS_A, padName: 'p', src: 'https://x/p/p' });
+    const b = await mgr.open({ workspaceId: WS_A, padName: 'p', src: 'https://x/p/p' });
+    expect(b.tabId).toBe(a.tabId);
+    // The inflight map should be empty after each open() resolves —
+    // verified indirectly by factory.create being called exactly once
+    // across two completed (non-overlapping) opens.
+    expect(factory.create).toHaveBeenCalledTimes(1);
+  });
+
   it('positions the active view to the main area on resize', async () => {
     mgr.setActiveWorkspace(WS_A);
     const tab = await mgr.open({ workspaceId: WS_A, padName: 'p', src: 'https://x/p/p' });