@vforsh/argus-watcher 0.1.3 → 0.1.5

package/dist/sources/extension-source.js

@@ -2,255 +2,539 @@
  * Extension source for CDP access via Chrome extension Native Messaging.
  * Wraps SessionManager and provides a unified source interface.
  */
-import { previewStringify } from '@vforsh/argus-core';
 import { createNativeMessaging } from '../native-messaging/messaging.js';
 import { SessionManager } from '../native-messaging/session-manager.js';
+import { buildFrameTargets, buildPageTarget, collectFrameTree, createEmptyFrameState, createNotAttachedError, frameToTarget, formatPageTargetId, parseExecutionContext, parseExtensionTargetId, parseFrame, resolveRequestedFrameId, } from './extension-frame-state.js';
+import { toConsoleEvent, toExceptionEvent } from './extension-log-events.js';
 /**
  * Create an extension source that connects to Chrome via Native Messaging.
  * Returns a handle that can be used to control the source and access CDP session.
  */
 export const createExtensionSource = (options) => {
-    const { events, ignoreMatcher, stripUrlPrefixes } = options;
+    const { events, ignoreMatcher, stripUrlPrefixes, watcherId, watcherHost, watcherPort } = options;
     const messaging = createNativeMessaging();
+    const hostInfo = {
+        watcherId: watcherId ?? 'extension',
+        watcherHost: watcherHost ?? '127.0.0.1',
+        watcherPort: watcherPort ?? 0,
+        watcherPid: process.pid,
+    };
     let currentSession = null;
     let stopping = false;
-    // Create session manager with event handlers
+    const frameStateByTabId = new Map();
+    const delegatingSessions = new Set();
+    const getCurrentExtensionSession = () => {
+        if (!currentSession) {
+            throw createNotAttachedError();
+        }
+        return currentSession;
+    };
     const sessionManager = new SessionManager(messaging, {
         onAttach: (session) => {
             console.error(`[ExtensionSource] Tab attached: ${session.tabId} - ${session.url}`);
             currentSession = session;
-            sessionManager.enableDomain(session.tabId, 'Page');
-            // Subscribe to console events
-            session.handle.onEvent('Runtime.consoleAPICalled', (params) => {
-                const logEvent = toConsoleEvent(params, session, { ignoreMatcher, stripUrlPrefixes });
-                events.onLog(logEvent);
-            });
-            // Subscribe to exception events
-            session.handle.onEvent('Runtime.exceptionThrown', (params) => {
-                const logEvent = toExceptionEvent(params, session, { ignoreMatcher, stripUrlPrefixes });
-                events.onLog(logEvent);
-            });
-            // Notify status change
-            const target = {
-                id: String(session.tabId),
-                title: session.title,
-                url: session.url,
-                type: 'page',
-                faviconUrl: session.faviconUrl,
-                attached: true,
-            };
-            events.onStatus({
-                attached: true,
-                target: {
-                    title: session.title,
-                    url: session.url,
-                    type: 'page',
-                    parentId: null,
-                },
-                reason: null,
-            });
-            void events.onAttach?.(session.handle, target);
+            rebindDelegatingSessions();
+            seedFrameState(session);
+            void bootstrapAttachedSession(session);
         },
         onDetach: (tabId, reason) => {
             console.error(`[ExtensionSource] Tab detached: ${tabId} - ${reason}`);
             if (currentSession?.tabId === tabId) {
                 currentSession = null;
             }
-            events.onStatus({
-                attached: false,
-                target: null,
-                reason,
-            });
+            rebindDelegatingSessions();
+            frameStateByTabId.delete(tabId);
+            emitStatus(null, reason);
             events.onDetach?.(reason);
         },
         onTabsUpdated: () => {
             // Tabs list updated - no action needed
         },
-    });
-    // Create a proxy session handle that delegates to the current session
-    const proxySession = {
-        isAttached: () => currentSession?.handle.isAttached() ?? false,
-        sendAndWait: async (method, params, options) => {
+        onTargetSelected: (tabId, frameId) => {
             const session = currentSession;
-            if (!session) {
-                const error = new Error('No tab attached via extension');
-                error.code = 'cdp_not_attached';
-                throw error;
+            if (!session || session.tabId !== tabId) {
+                getOrCreateFrameState(tabId).requestedFrameId = frameId;
+                return;
             }
-            return session.handle.sendAndWait(method, params, options);
+            requestTargetSelection(session, frameId);
         },
-        onEvent: (method, handler) => {
-            // For proxy session, we need to track all handlers and replay them
-            // when a new session is attached. For now, just use the current session.
-            if (!currentSession) {
-                // Return a no-op unsubscribe function
-                return () => { };
+    });
+    // Proxy session follows the currently selected page/frame target inside the attached tab.
+    const proxySession = createDelegatingSession({
+        getTargetContext: () => getCurrentTargetContext() ?? { kind: 'page' },
+        mapParams: (method, params) => {
+            const targetContext = getCurrentTargetContext();
+            if (method !== 'Runtime.evaluate' || targetContext?.kind !== 'frame' || params?.contextId != null) {
+                return params;
             }
-            return currentSession.handle.onEvent(method, handler);
+            if (targetContext.executionContextId == null) {
+                throw new Error(`Selected frame is not ready yet: ${targetContext.frameId}`);
+            }
+            return {
+                ...(params ?? {}),
+                contextId: targetContext.executionContextId,
+            };
         },
-    };
-    // Start Native Messaging
+    });
+    // Page session always stays at the top-level tab context so page-level features
+    // (indicator, inject-on-attach, similar lifecycle hooks) don't accidentally run inside an iframe.
+    const pageSession = createDelegatingSession({
+        getTargetContext: () => ({ kind: 'page' }),
+    });
     messaging.start();
+    sendHostInfo();
     messaging.onDisconnect(() => {
         console.error('[ExtensionSource] Extension disconnected');
         if (!stopping) {
-            events.onStatus({
-                attached: false,
-                target: null,
-                reason: 'extension_disconnected',
-            });
+            emitStatus(null, 'extension_disconnected');
             events.onDetach?.('extension_disconnected');
         }
     });
     const stop = async () => {
         stopping = true;
+        disposeDelegatingSessions();
         messaging.stop();
     };
     const listTargets = async () => {
         const tabs = await sessionManager.listTabs();
-        return tabs.map(tabToTarget);
+        return tabs.flatMap((tab) => {
+            const session = currentSession?.tabId === tab.tabId ? currentSession : null;
+            const state = frameStateByTabId.get(tab.tabId);
+            if (!session || !state || state.frames.size === 0) {
+                return [tabToTarget(tab)];
+            }
+            const activeFrameId = state.activeFrameId;
+            const targets = [buildPageTarget(session, { attached: activeFrameId == null })];
+            for (const frame of buildFrameTargets(state, tab.tabId, activeFrameId, tab.faviconUrl)) {
+                targets.push(frame);
+            }
+            return targets;
+        });
     };
     const attachTarget = (targetId) => {
-        sessionManager.attachTab(targetId);
+        const target = parseExtensionTargetId(targetId);
+        const session = currentSession;
+        if (!session || session.tabId !== target.tabId) {
+            getOrCreateFrameState(target.tabId).requestedFrameId = target.frameId;
+            sessionManager.attachTab(target.tabId);
+            return;
+        }
+        requestTargetSelection(session, target.frameId);
     };
     const detachTarget = (targetId) => {
-        sessionManager.detachTab(targetId);
+        sessionManager.detachTab(parseExtensionTargetId(targetId).tabId);
     };
     return {
         session: proxySession,
+        pageSession,
+        syncWatcherInfo: (info) => {
+            hostInfo.watcherId = info.watcherId;
+            hostInfo.watcherHost = info.watcherHost;
+            hostInfo.watcherPort = info.watcherPort;
+            hostInfo.watcherPid = info.watcherPid;
+            sendHostInfo();
+        },
         stop,
         listTargets,
         attachTarget,
         detachTarget,
     };
-};
-/**
- * Convert TabInfo to CdpSourceTarget.
- */
-const tabToTarget = (tab) => ({
-    id: String(tab.tabId),
-    title: tab.title,
-    url: tab.url,
-    type: 'page',
-    faviconUrl: tab.faviconUrl,
-    attached: tab.attached,
-});
-/**
- * Convert Runtime.consoleAPICalled event to LogEvent.
- */
-const toConsoleEvent = (params, session, config) => {
-    const record = params;
-    const args = record.args?.map((a) => a.value) ?? [];
-    const text = formatArgs(record.args ?? []);
-    const frame = selectBestFrame(record.stackTrace?.callFrames, config.ignoreMatcher);
-    return {
-        ts: record.timestamp ?? Date.now(),
-        level: normalizeLevel(record.type ?? 'log'),
-        text,
-        args,
-        source: 'console',
-        file: applyStripPrefixes(frame?.url ?? null, config.stripUrlPrefixes),
-        line: frame?.lineNumber != null ? frame.lineNumber + 1 : null,
-        column: frame?.columnNumber != null ? frame.columnNumber + 1 : null,
-        pageUrl: session.url,
-        pageTitle: session.title,
-    };
-};
-/**
- * Convert Runtime.exceptionThrown event to LogEvent.
- */
-const toExceptionEvent = (params, session, config) => {
-    const record = params;
-    const details = record.exceptionDetails;
-    const text = details?.exception?.description ?? details?.text ?? 'Exception';
-    const args = details?.exception ? [details.exception.value ?? details.exception.description] : [];
-    const frame = selectBestFrame(details?.stackTrace?.callFrames, config.ignoreMatcher);
-    return {
-        ts: record.timestamp ?? Date.now(),
-        level: 'exception',
-        text,
-        args,
-        source: 'exception',
-        file: applyStripPrefixes(frame?.url ?? null, config.stripUrlPrefixes),
-        line: frame?.lineNumber != null ? frame.lineNumber + 1 : null,
-        column: frame?.columnNumber != null ? frame.columnNumber + 1 : null,
-        pageUrl: session.url,
-        pageTitle: session.title,
-    };
-};
-/**
- * Format console args for display.
- */
-const formatArgs = (args) => {
-    if (args.length === 0) {
-        return '';
+    function sendHostInfo() {
+        messaging.send({
+            type: 'host_info',
+            watcherId: hostInfo.watcherId,
+            watcherHost: hostInfo.watcherHost,
+            watcherPort: hostInfo.watcherPort,
+            pid: hostInfo.watcherPid,
+        });
     }
-    return args
-        .map((arg) => {
-        if (arg.value !== undefined) {
-            return typeof arg.value === 'string' ? arg.value : previewStringify(arg.value);
+    function rebindDelegatingSessions() {
+        for (const controller of delegatingSessions) {
+            controller.rebind();
         }
-        return arg.description ?? `[${arg.type}]`;
-    })
-        .join(' ');
-};
-/**
- * Normalize console log type to LogLevel.
- */
-const normalizeLevel = (type) => {
-    switch (type) {
-        case 'log':
-        case 'info':
-        case 'debug':
-        case 'dir':
-        case 'dirxml':
-        case 'table':
-        case 'trace':
-        case 'count':
-        case 'timeEnd':
-        case 'timeLog':
-            return type === 'debug' ? 'debug' : type === 'info' ? 'info' : 'log';
-        case 'warn':
-        case 'warning':
-            return 'warning';
-        case 'error':
-        case 'assert':
-        case 'exception':
-            return type === 'exception' ? 'exception' : 'error';
-        default:
-            return 'log';
     }
-};
-/**
- * Select the best frame from the stack trace (first non-ignored frame).
- */
-const selectBestFrame = (frames, ignoreMatcher) => {
-    if (!frames || frames.length === 0) {
-        return null;
+    function disposeDelegatingSessions() {
+        for (const controller of delegatingSessions) {
+            controller.dispose();
+        }
+    }
+    async function bootstrapAttachedSession(session) {
+        try {
+            registerSessionEventHandlers(session);
+            await enableBootstrapDomains(session);
+            await refreshFrameTree(session);
+            if (currentSession?.tabId !== session.tabId) {
+                return;
+            }
+            const target = buildPageTarget(session, { attached: true });
+            emitStatus(target, null);
+            await events.onAttach?.(session.handle, target);
+            reconcileTargetSelection(session);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[ExtensionSource] Failed to bootstrap attached tab ${session.tabId}: ${message}`);
+            if (currentSession?.tabId === session.tabId) {
+                emitStatus(null, message);
+                events.onDetach?.(message);
+            }
+        }
+    }
+    /**
+     * Subscribe before enabling Runtime/Page so we don't miss the initial execution contexts
+     * that Chrome emits as soon as Runtime becomes active.
+     */
+    async function enableBootstrapDomains(session) {
+        await session.handle.sendAndWait('Runtime.enable');
+        await session.handle.sendAndWait('Page.enable');
+    }
+    function registerSessionEventHandlers(session) {
+        session.handle.onEvent('Runtime.executionContextCreated', (params, meta) => {
+            const context = parseExecutionContext(params);
+            if (!context?.isDefault || !context.frameId) {
+                return;
+            }
+            const state = getOrCreateFrameState(session.tabId);
+            state.executionContexts.set(context.frameId, context.id);
+            const frame = state.frames.get(context.frameId);
+            if (frame) {
+                frame.sessionId = meta.sessionId ?? null;
+            }
+            void refreshFrameTitle(session, context.frameId, context.id);
+            reconcileTargetSelection(session);
+        });
+        session.handle.onEvent('Runtime.executionContextsCleared', () => {
+            const state = getOrCreateFrameState(session.tabId);
+            state.executionContexts.clear();
+            state.pendingTitleLoads.clear();
+        });
+        session.handle.onEvent('Runtime.executionContextDestroyed', (params) => {
+            const record = params;
+            if (record.executionContextId == null) {
+                return;
+            }
+            const state = getOrCreateFrameState(session.tabId);
+            for (const [frameId, contextId] of state.executionContexts.entries()) {
+                if (contextId === record.executionContextId) {
+                    state.executionContexts.delete(frameId);
+                    state.pendingTitleLoads.delete(frameId);
+                }
+            }
+        });
+        session.handle.onEvent('Page.frameNavigated', (params, meta) => {
+            const frame = parseFrame(params);
+            if (!frame) {
+                return;
+            }
+            const state = getOrCreateFrameState(session.tabId);
+            state.frames.set(frame.frameId, frame);
+            frame.sessionId = meta.sessionId ?? null;
+            if (!frame.parentFrameId) {
+                if (!meta.sessionId) {
+                    state.topFrameId = frame.frameId;
+                    session.url = frame.url;
+                }
+                else if (state.topFrameId == null) {
+                    state.topFrameId = frame.parentFrameId;
+                }
+            }
+            else if (state.executionContexts.has(frame.frameId)) {
+                void refreshFrameTitle(session, frame.frameId);
+            }
+            currentSession = session;
+            if (!frame.parentFrameId && !meta.sessionId) {
+                events.onPageNavigation?.({ url: frame.url, title: session.title ?? null });
+            }
+            if (reconcileTargetSelection(session)) {
+                return;
+            }
+            if ((!frame.parentFrameId && state.activeFrameId == null) || state.activeFrameId === frame.frameId) {
+                emitTargetChanged(session);
+            }
+        });
+        session.handle.onEvent('Page.frameAttached', (params, meta) => {
+            const record = params;
+            if (!record.frameId) {
+                return;
+            }
+            const state = getOrCreateFrameState(session.tabId);
+            state.frames.set(record.frameId, {
+                frameId: record.frameId,
+                parentFrameId: record.parentFrameId ?? state.topFrameId ?? null,
+                url: '',
+                title: null,
+                sessionId: meta.sessionId ?? null,
+            });
+            reconcileTargetSelection(session);
+        });
+        session.handle.onEvent('Page.frameDetached', (params) => {
+            const record = params;
+            if (!record.frameId) {
+                return;
+            }
+            removeFrame(session.tabId, record.frameId);
+            reconcileTargetSelection(session);
+        });
+        session.handle.onEvent('Page.domContentEventFired', () => {
+            events.onPageLoad?.();
+        });
+        session.handle.onEvent('Runtime.consoleAPICalled', (params) => {
+            events.onLog(toConsoleEvent(params, session, { ignoreMatcher, stripUrlPrefixes }));
+        });
+        session.handle.onEvent('Runtime.exceptionThrown', (params) => {
+            events.onLog(toExceptionEvent(params, session, { ignoreMatcher, stripUrlPrefixes }));
+        });
     }
-    if (!ignoreMatcher) {
-        return frames[0] ?? null;
+    function getCurrentTargetContext() {
+        const session = currentSession;
+        if (!session) {
+            return null;
+        }
+        const state = frameStateByTabId.get(session.tabId);
+        if (!state?.activeFrameId) {
+            return { kind: 'page' };
+        }
+        return {
+            kind: 'frame',
+            frameId: state.activeFrameId,
+            executionContextId: state.executionContexts.get(state.activeFrameId) ?? null,
+            sessionId: state.frames.get(state.activeFrameId)?.sessionId ?? null,
+        };
     }
-    for (const frame of frames) {
-        if (frame.url && !ignoreMatcher(frame.url)) {
-            return frame;
+    function getOrCreateFrameState(tabId) {
+        const existing = frameStateByTabId.get(tabId);
+        if (existing) {
+            return existing;
         }
+        const created = createEmptyFrameState();
+        frameStateByTabId.set(tabId, created);
+        return created;
     }
-    // Fall back to first frame if all are ignored
-    return frames[0] ?? null;
-};
-/**
- * Apply strip prefixes to a file URL.
- */
-const applyStripPrefixes = (file, prefixes) => {
-    if (!file || !prefixes || prefixes.length === 0) {
-        return file;
+    function seedFrameState(session) {
+        const state = getOrCreateFrameState(session.tabId);
+        if (state.frames.size > 0 || session.frames.length === 0) {
+            return state;
+        }
+        state.topFrameId = session.topFrameId;
+        for (const frame of session.frames) {
+            state.frames.set(frame.frameId, {
+                frameId: frame.frameId,
+                parentFrameId: frame.parentFrameId,
+                url: frame.url,
+                title: frame.title,
+                sessionId: frame.sessionId,
+            });
+        }
+        return state;
+    }
+    function emitStatus(target, reason) {
+        events.onStatus({
+            attached: Boolean(target),
+            target: target
+                ? {
+                    title: target.title,
+                    url: target.url,
+                    type: target.type ?? 'page',
+                    parentId: target.parentId ?? null,
+                }
+                : null,
+            reason,
+        });
+    }
+    function emitTargetChanged(session) {
+        const target = getSelectedTarget(session);
+        if (!target) {
+            return;
+        }
+        const state = getOrCreateFrameState(session.tabId);
+        if (state.activeAttachedAt == null) {
+            state.activeAttachedAt = Date.now();
+        }
+        emitStatus(target, null);
+        messaging.send({
+            type: 'target_info',
+            targetId: target.id,
+            title: target.title,
+            url: target.url,
+            attachedAt: state.activeAttachedAt,
+        });
+        events.onTargetChanged?.(session.handle, target);
+    }
+    function getSelectedTarget(session) {
+        const state = frameStateByTabId.get(session.tabId);
+        if (!state?.activeFrameId) {
+            return buildPageTarget(session, { attached: true });
+        }
+        const frame = state.frames.get(state.activeFrameId);
+        if (!frame) {
+            return buildPageTarget(session, { attached: true });
+        }
+        return frameToTarget(session.tabId, frame, { attached: true, faviconUrl: session.faviconUrl, topFrameId: state.topFrameId });
+    }
+    function requestTargetSelection(session, frameId) {
+        const state = getOrCreateFrameState(session.tabId);
+        state.requestedFrameId = frameId;
+        reconcileTargetSelection(session);
     }
-    for (const prefix of prefixes) {
-        if (file.startsWith(prefix)) {
-            return file.slice(prefix.length);
+    /**
+     * Popup selection can arrive before the iframe's session is fully bootstrapped.
+     * Keep the request pending until the frame is discovered instead of routing commands
+     * to the parent page and pretending the switch already happened.
+     */
+    function reconcileTargetSelection(session) {
+        const state = getOrCreateFrameState(session.tabId);
+        const nextActiveFrameId = resolveRequestedFrameId(state, state.requestedFrameId);
+        if (state.requestedFrameId == null) {
+            if (state.activeFrameId == null) {
+                if (state.activeAttachedAt == null) {
+                    state.activeAttachedAt = Date.now();
+                    emitTargetChanged(session);
+                    return true;
+                }
+                return false;
+            }
+            state.activeFrameId = null;
+            state.activeAttachedAt = Date.now();
+            emitTargetChanged(session);
+            return true;
+        }
+        if (nextActiveFrameId == null || state.activeFrameId === nextActiveFrameId) {
+            return false;
+        }
+        state.activeFrameId = nextActiveFrameId;
+        state.activeAttachedAt = Date.now();
+        emitTargetChanged(session);
+        return true;
+    }
+    async function refreshFrameTree(session) {
+        const state = getOrCreateFrameState(session.tabId);
+        const frameTree = (await session.handle.sendAndWait('Page.getFrameTree'));
+        collectFrameTree(frameTree.frameTree, state);
+        await Promise.all([...state.executionContexts.keys()].map((frameId) => refreshFrameTitle(session, frameId)));
+    }
+    function removeFrame(tabId, frameId) {
+        const state = getOrCreateFrameState(tabId);
+        const childIds = [...state.frames.values()].filter((frame) => frame.parentFrameId === frameId).map((frame) => frame.frameId);
+        for (const childId of childIds) {
+            removeFrame(tabId, childId);
+        }
+        if (state.requestedFrameId === frameId) {
+            state.requestedFrameId = null;
+        }
+        state.frames.delete(frameId);
+        state.executionContexts.delete(frameId);
+        state.pendingTitleLoads.delete(frameId);
+    }
+    /**
+     * Frame tree metadata does not include the iframe document title, so we resolve it from the
+     * frame's default execution context and cache it alongside the rest of the frame state.
+     */
+    async function refreshFrameTitle(session, frameId, contextId) {
+        const state = getOrCreateFrameState(session.tabId);
+        if (frameId === state.topFrameId || state.pendingTitleLoads.has(frameId)) {
+            return;
+        }
+        const executionContextId = contextId ?? state.executionContexts.get(frameId);
+        if (executionContextId == null) {
+            return;
+        }
+        const frame = state.frames.get(frameId);
+        if (!frame) {
+            return;
+        }
+        state.pendingTitleLoads.add(frameId);
+        try {
+            const evaluated = (await session.handle.sendAndWait('Runtime.evaluate', {
+                expression: 'document.title',
+                contextId: executionContextId,
+                returnByValue: true,
+                silent: true,
+            }, frame.sessionId ? { sessionId: frame.sessionId } : undefined));
+            const title = typeof evaluated.result?.value === 'string' ? evaluated.result.value.trim() : '';
+            const latestFrame = state.frames.get(frameId);
+            if (!latestFrame) {
+                return;
+            }
+            latestFrame.title = title || null;
+            if (state.activeFrameId === frameId) {
+                emitTargetChanged(session);
+            }
+        }
+        catch {
+            // Ignore transient frame-title lookup failures during navigation/bootstrap.
+        }
+        finally {
+            state.pendingTitleLoads.delete(frameId);
         }
     }
-    return file;
+    function createDelegatingSession(config) {
+        const subscriptions = new Set();
+        const rebindSubscriptions = () => {
+            // Delegating sessions are created before a tab may be attached, so event listeners
+            // must follow the active extension session instead of binding once and going stale.
+            for (const subscription of subscriptions) {
+                subscription.unbind();
+                if (!currentSession) {
+                    continue;
+                }
+                subscription.off = currentSession.handle.onEvent(subscription.method, subscription.handler);
+            }
+        };
+        const disposeSubscriptions = () => {
+            for (const subscription of subscriptions) {
+                subscription.unbind();
+            }
+            subscriptions.clear();
+        };
+        const controller = {
+            rebind: rebindSubscriptions,
+            dispose: () => {
+                disposeSubscriptions();
+                delegatingSessions.delete(controller);
+            },
+        };
+        delegatingSessions.add(controller);
+        controller.rebind();
+        return {
+            isAttached: () => currentSession?.handle.isAttached() ?? false,
+            sendAndWait: async (method, params, options) => {
+                const session = getCurrentExtensionSession();
+                const targetContext = config.getTargetContext();
+                const nextParams = config.mapParams ? config.mapParams(method, params) : params;
+                const nextOptions = targetContext.kind === 'frame' && targetContext.sessionId ? { ...(options ?? {}), sessionId: targetContext.sessionId } : options;
+                return session.handle.sendAndWait(method, nextParams, nextOptions);
+            },
+            onEvent: (method, handler) => {
+                const subscription = createDelegatingEventSubscription(method, handler);
+                subscriptions.add(subscription);
+                controller.rebind();
+                return () => {
+                    subscription.unbind();
+                    subscriptions.delete(subscription);
+                };
+            },
+            getTargetContext: config.getTargetContext,
+        };
+    }
 };
+/**
+ * Convert TabInfo to CdpSourceTarget.
+ */
+const tabToTarget = (tab) => ({
+    id: formatPageTargetId(tab.tabId),
+    title: tab.title,
+    url: tab.url,
+    type: 'page',
+    faviconUrl: tab.faviconUrl,
+    attached: tab.attached,
+});
+const createDelegatingEventSubscription = (method, handler) => ({
+    method,
+    handler,
+    off: null,
+    unbind() {
+        this.off?.();
+        this.off = null;
+    },
+});
 //# sourceMappingURL=extension-source.js.map