fix(hub-ui): scope action cleanup to its owning connection

Track the active inspected-page action across sessions and release ownership when page selection changes. Ignore stale deactivation and disconnect requests while preserving serialized teardown for in-flight activations.

Author: SaKaNa-Y

packages/hub-ui/src/client/state/inspected-page.test.ts

@@ -34,7 +34,7 @@ function setup(options: { adapter?: boolean, activate?: (id: string) => Promise<
       // The browser adapter binds this port to its known viewer and inspected
       // document. Production adapter identity checks live in packages/webext.
       if (event.source !== viewer.window || event.origin !== viewer.win.location.origin
-        || event.data?.session !== 'session-a') {
+        || event.data?.session !== new URLSearchParams(viewer.win.location.search).get('devframe-inspected-page')) {
         return
       }
       page.win.dispatch('message', {
@@ -69,14 +69,16 @@ describe('inspected page bridge', () => {
       listener(null)
     await vi.waitFor(() => expect(changed).toHaveBeenCalledExactlyOnceWith(null))
     unsubscribe()
-    await expect(target.deactivate('tracer')).resolves.toBe(true)
-    expect(s.host.deactivate).toHaveBeenCalledExactlyOnceWith('tracer')
+    await expect(target.deactivate('tracer')).resolves.toBe(false)
+    expect(s.host.deactivate).not.toHaveBeenCalled()
   })
 
   it('carries an existing panel channel through the dedicated bridge port', async () => {
     interface Protocol extends InPageChannelProtocol {
-      pageScript: { route: () => string }
-      panel: Record<string, never>
+      functions: {
+        pageScript: { route: () => string }
+        panel: Record<string, never>
+      }
     }
     const s = setup()
     const pageScript = createPageScriptChannel<Protocol>({
@@ -169,6 +171,39 @@ describe('inspected page bridge', () => {
     expect(s.host.deactivate).toHaveBeenCalledExactlyOnceWith('tracer')
   })
 
+  it.each(['disconnect', 'deactivate'])('preserves a newer session activation when the old session requests %s', async (method) => {
+    const s = setup()
+    const first = await connect(s)
+    await first.activate('tracer')
+    s.viewer.win.location.search = s.viewer.win.location.search.replace('session-a', 'session-b')
+    const second = await connect(s)
+    await second.activate('tracer')
+
+    if (method === 'disconnect')
+      first.close()
+    else
+      await expect(first.deactivate('tracer')).resolves.toBe(false)
+    // A later request is a barrier for the host's shared operation queue.
+    await second.prepare('a11y')
+    expect(s.host.deactivate).not.toHaveBeenCalled()
+    second.close()
+    await vi.waitFor(() => expect(s.host.deactivate).toHaveBeenCalledExactlyOnceWith('tracer'))
+  })
+
+  it('releases ownership when inspection ends before an embedded activation', async () => {
+    const s = setup()
+    const target = await connect(s)
+    await target.activate('tracer')
+    for (const id of [null, 'tracer']) {
+      for (const listener of s.selectionListeners)
+        listener(id)
+    }
+    target.close()
+    const replacement = await connect(s)
+    await replacement.prepare('a11y')
+    expect(s.host.deactivate).not.toHaveBeenCalled()
+  })
+
   it('closes a timed-out activation and tears down when the pending action finishes', async () => {
     let finish!: (value: boolean) => void
     let started!: () => void

packages/hub-ui/src/client/state/inspected-page.ts

@@ -44,6 +44,7 @@ function channelTransport(port: MessagePort) {
  */
 export function installInspectedPageHost(host: InspectedPageHost, win: Window = window): () => void {
   const sessions = new Map<string, () => void>()
+  let activeAction: { port: MessagePort, entryId: string } | undefined
   // Replacement connections share the action queue, including teardown. An
   // older pending activation must finish and deactivate before its successor.
   let operations = Promise.resolve()
@@ -55,10 +56,19 @@ export function installInspectedPageHost(host: InspectedPageHost, win: Window =
       return
     sessions.get(data.session)?.()
     const port = event.ports[0]
-    let activeEntry: string | undefined
     let closed = false
     const stopRelay = createInPageChannelRelay({ role: 'page', window: win, transport: channelTransport(port) })
-    const stopSelection = host.onSelection(entryId => port.postMessage({ type: 'selection', entryId }))
+    const stopSelection = host.onSelection((entryId) => {
+      if (activeAction && activeAction.entryId !== entryId)
+        activeAction = undefined
+      port.postMessage({ type: 'selection', entryId })
+    })
+    async function deactivate(entryId: string): Promise<boolean> {
+      if (activeAction?.port !== port || activeAction.entryId !== entryId)
+        return false
+      activeAction = undefined
+      return host.deactivate(entryId)
+    }
     function close() {
       if (closed)
         return
@@ -72,8 +82,8 @@ export function installInspectedPageHost(host: InspectedPageHost, win: Window =
       // Queue teardown after in-flight activation so closing the extension
       // cannot leave an inspector enabled after its asynchronous script loads.
       operations = operations.then(async () => {
-        if (activeEntry)
-          await host.deactivate(activeEntry)
+        if (activeAction?.port === port)
+          await deactivate(activeAction.entryId)
       }).catch(() => {})
     }
     function receive(message: MessageEvent) {
@@ -91,11 +101,9 @@ export function installInspectedPageHost(host: InspectedPageHost, win: Window =
         if (closed)
           return
         try {
-          const result = await host[method](request.entryId)
+          const result = await (method === 'deactivate' ? deactivate(request.entryId) : host[method](request.entryId))
           if (method === 'activate' && result)
-            activeEntry = request.entryId
-          if (method === 'deactivate' && activeEntry === request.entryId)
-            activeEntry = undefined
+            activeAction = { port, entryId: request.entryId }
           if (!closed)
             port.postMessage({ type: 'response', id: request.id, result })
         }