chrome-devtools-mcp 1.1.1 → 1.3.0

package/build/src/McpResponse.js

@@ -11,7 +11,7 @@ import { NetworkFormatter } from './formatters/NetworkFormatter.js';
 import { SnapshotFormatter } from './formatters/SnapshotFormatter.js';
 import { UncaughtError } from './PageCollector.js';
 import { TextSnapshot } from './TextSnapshot.js';
-import { DevTools } from './third_party/index.js';
+import { DevTools, toonEncode } from './third_party/index.js';
 import { handleDialog } from './tools/pages.js';
 import { getInsightOutput, getTraceSummary } from './trace-processing/parse.js';
 import { paginate } from './utils/pagination.js';
@@ -61,7 +61,7 @@ export function replaceHtmlElementsWithUids(schema) {
         }
     }
 }
-async function getToolGroup(page) {
+async function getToolGroups(page) {
     // Check if there is a `devtoolstooldiscovery` event listener
     const windowHandle = await page.pptrPage.evaluateHandle(() => window);
     // @ts-expect-error internal API
@@ -70,43 +70,82 @@ async function getToolGroup(page) {
         objectId: windowHandle.remoteObject().objectId,
     });
     if (listeners.find(l => l.type === 'devtoolstooldiscovery') === undefined) {
-        return;
+        return [];
     }
-    const toolGroup = await page.pptrPage.evaluate(() => {
+    const toolGroups = await page.pptrPage.evaluate(() => {
+        if (window.__dtmcp) {
+            window.__dtmcp.toolGroups = [];
+        }
         return new Promise(resolve => {
             const event = new CustomEvent('devtoolstooldiscovery');
+            const groups = [];
             // @ts-expect-error Adding custom property
-            event.respondWith = (toolGroup) => {
+            event.respondWith = toolGroup => {
                 if (!window.__dtmcp) {
                     window.__dtmcp = {};
                 }
-                window.__dtmcp.toolGroup = toolGroup;
+                if (!window.__dtmcp.toolGroups) {
+                    window.__dtmcp.toolGroups = [];
+                }
+                if (typeof toolGroup.name !== 'string' ||
+                    (toolGroup.description &&
+                        typeof toolGroup.description !== 'string') ||
+                    !Array.isArray(toolGroup.tools)) {
+                    console.error('Invalid toolGroup:', toolGroup);
+                    return;
+                }
+                for (const tool of toolGroup.tools) {
+                    if (typeof tool.name !== 'string' ||
+                        typeof tool.description !== 'string' ||
+                        typeof tool.inputSchema !== 'object' ||
+                        typeof tool.execute !== 'function') {
+                        console.error('Invalid tool:', tool);
+                        return;
+                    }
+                }
+                window.__dtmcp.toolGroups.push(toolGroup);
                 // When receiving a toolGroup for the first time, expose a simple execution helper
                 if (!window.__dtmcp.executeTool) {
                     window.__dtmcp.executeTool = async (toolName, args) => {
-                        if (!window.__dtmcp?.toolGroup) {
+                        if (!window.__dtmcp?.toolGroups ||
+                            window.__dtmcp.toolGroups.length === 0) {
                             throw new Error('No tools found on the page');
                         }
-                        const tool = window.__dtmcp.toolGroup.tools.find(t => t.name === toolName);
-                        if (!tool) {
-                            throw new Error(`Tool ${toolName} not found`);
+                        for (const group of window.__dtmcp.toolGroups) {
+                            const tool = group.tools?.find(t => t.name === toolName);
+                            if (tool) {
+                                return await tool.execute(args);
+                            }
                         }
-                        return await tool.execute(args);
+                        throw new Error(`Tool ${toolName} not found`);
                     };
                 }
-                resolve(toolGroup);
+                groups.push(toolGroup);
             };
             window.dispatchEvent(event);
-            // If the page does not synchronously call `event.respondWith`, return instead of timing out
-            setTimeout(() => {
-                resolve(null);
-            }, 0);
+            // If at least one toolGroup was added synchronously, resolve with the array.
+            // Otherwise, use setTimeout to allow for any microtask/asynchronous respondWith calls, or resolve with an empty array.
+            if (groups.length > 0) {
+                resolve(groups);
+            }
+            else {
+                setTimeout(() => {
+                    if (groups.length > 0) {
+                        resolve(groups);
+                    }
+                    else {
+                        resolve([]);
+                    }
+                }, 0);
+            }
         });
     });
-    for (const tool of toolGroup?.tools ?? []) {
-        replaceHtmlElementsWithUids(tool.inputSchema);
+    for (const group of toolGroups) {
+        for (const tool of group.tools ?? []) {
+            replaceHtmlElementsWithUids(tool.inputSchema);
+        }
     }
-    return toolGroup;
+    return toolGroups;
 }
 export class McpResponse {
     #includePages = false;
@@ -134,6 +173,9 @@ export class McpResponse {
     #redactNetworkHeaders = true;
     #error;
     #attachedWaitForResult;
+    get #deviceScope() {
+        return this.#page?.viewport?.isMobile ? 'PHONE' : 'DESKTOP';
+    }
     constructor(args) {
         this.#args = args;
     }
@@ -203,6 +245,7 @@ export class McpResponse {
                 : undefined,
             types: options?.types,
             includePreservedMessages: options?.includePreservedMessages,
+            serviceWorkerId: options?.serviceWorkerId,
         };
     }
     setError(error) {
@@ -291,6 +334,20 @@ export class McpResponse {
             pagination: options,
         };
     }
+    setHeapSnapshotRetainingPaths(retainingPaths) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            retainingPaths,
+        };
+    }
+    setHeapSnapshotDominators(dominators) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            dominators,
+        };
+    }
     attachImage(value) {
         this.#images.push(value);
     }
@@ -306,7 +363,7 @@ export class McpResponse {
     get listWebMcpTools() {
         return this.#listWebMcpTools;
     }
-    async handle(toolName, context) {
+    async handle(toolName, context, useToon = false) {
         if (this.#includePages) {
             await context.createPagesSnapshot();
         }
@@ -383,12 +440,11 @@ export class McpResponse {
         if (this.#listExtensions) {
             extensions = await context.listExtensions();
         }
-        // Null indicates no tools.
-        let thirdPartyDeveloperTools;
+        let thirdPartyDeveloperTools = [];
         if (this.#args.categoryExperimentalThirdParty &&
             this.#listThirdPartyDeveloperTools &&
             this.#page) {
-            thirdPartyDeveloperTools = await getToolGroup(this.#page);
+            thirdPartyDeveloperTools = await getToolGroups(this.#page);
             if (thirdPartyDeveloperTools) {
                 this.#page.thirdPartyDeveloperTools = thirdPartyDeveloperTools;
             }
@@ -401,11 +457,18 @@ export class McpResponse {
         }
         let consoleMessages;
         if (this.#consoleDataOptions?.include) {
-            if (!this.#page) {
-                throw new Error(`Response must have an McpPage`);
+            let messages;
+            let page;
+            if (this.#consoleDataOptions.serviceWorkerId) {
+                messages = context.getServiceWorkerConsoleData(this.#consoleDataOptions.serviceWorkerId);
+            }
+            else {
+                page = this.#page;
+                if (!page) {
+                    throw new Error(`Response must have an McpPage`);
+                }
+                messages = context.getConsoleData(page, this.#consoleDataOptions.includePreservedMessages);
             }
-            const page = this.#page;
-            let messages = context.getConsoleData(this.#page, this.#consoleDataOptions.includePreservedMessages);
             if (this.#consoleDataOptions.types?.length) {
                 const normalizedTypes = new Set(this.#consoleDataOptions.types);
                 messages = messages.filter(message => {
@@ -422,7 +485,9 @@ export class McpResponse {
                 const consoleMessageStableId = context.getConsoleMessageStableId(item);
                 if ('args' in item || item instanceof UncaughtError) {
                     const consoleMessage = item;
-                    const devTools = context.getDevToolsUniverse(page);
+                    const devTools = page
+                        ? context.getDevToolsUniverse(page)
+                        : null;
                     return await ConsoleFormatter.from(consoleMessage, {
                         id: consoleMessageStableId,
                         fetchDetailedData: false,
@@ -479,9 +544,9 @@ export class McpResponse {
             thirdPartyDeveloperTools,
             webmcpTools,
             errorMessage: this.#error?.message,
-        });
+        }, useToon);
     }
-    format(toolName, context, data) {
+    async format(toolName, context, data, useToon) {
         const structuredContent = {};
         const response = [];
         if (this.#textResponseLines.length) {
@@ -561,8 +626,12 @@ Call ${handleDialog.name} to handle it before continuing.`);
                     const contextLabel = isolatedContextName
                         ? ` isolatedContext=${isolatedContextName}`
                         : '';
-                    parts.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
-                    structuredPages.push(createStructuredPage(page, context));
+                    const title = await fetchPageTitle(page);
+                    const pageLabel = title
+                        ? `${truncateTitle(title)} (${page.url()})`
+                        : page.url();
+                    parts.push(`${context.getPageId(page)}: ${pageLabel}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
+                    structuredPages.push(createStructuredPage(page, context, title));
                 }
                 response.push(...parts);
                 structuredContent.pages = structuredPages;
@@ -576,8 +645,12 @@ Call ${handleDialog.name} to handle it before continuing.`);
                         const contextLabel = isolatedContextName
                             ? ` isolatedContext=${isolatedContextName}`
                             : '';
-                        response.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
-                        structuredExtensionPages.push(createStructuredPage(page, context));
+                        const title = await fetchPageTitle(page);
+                        const pageLabel = title
+                            ? `${truncateTitle(title)} (${page.url()})`
+                            : page.url();
+                        response.push(`${context.getPageId(page)}: ${pageLabel}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
+                        structuredExtensionPages.push(createStructuredPage(page, context, title));
                     }
                     structuredContent.extensionPages = structuredExtensionPages;
                 }
@@ -603,7 +676,7 @@ Call ${handleDialog.name} to handle it before continuing.`);
             structuredContent.tabId = this.#tabId;
         }
         if (data.traceSummary) {
-            const summary = getTraceSummary(data.traceSummary);
+            const summary = getTraceSummary(data.traceSummary, this.#deviceScope);
             response.push(summary);
             structuredContent.traceSummary = summary;
             structuredContent.traceInsights = [];
@@ -617,7 +690,7 @@ Call ${handleDialog.name} to handle it before continuing.`);
             }
         }
         if (data.traceInsight) {
-            const insightOutput = getInsightOutput(data.traceInsight.trace, data.traceInsight.insightSetId, data.traceInsight.insightName);
+            const insightOutput = getInsightOutput(data.traceInsight.trace, data.traceInsight.insightSetId, data.traceInsight.insightName, this.#deviceScope);
             if ('error' in insightOutput) {
                 response.push(insightOutput.error);
             }
@@ -651,9 +724,11 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 structuredContent.snapshotFilePath = data.snapshot;
             }
             else {
-                response.push('## Latest page snapshot');
-                response.push(data.snapshot.toString());
                 structuredContent.snapshot = data.snapshot.toJSON();
+                response.push('## Latest page snapshot');
+                response.push(useToon
+                    ? toonEncode(structuredContent.snapshot)
+                    : data.snapshot.toString());
             }
         }
         if (this.#heapSnapshotOptions?.include) {
@@ -678,8 +753,10 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(...paginationData.info);
                 const paginatedRecord = Object.fromEntries(paginationData.items);
                 const formatter = new HeapSnapshotFormatter(paginatedRecord);
-                response.push(formatter.toString());
                 structuredContent.heapSnapshotData = formatter.toJSON();
+                response.push(useToon
+                    ? toonEncode(structuredContent.heapSnapshotData)
+                    : formatter.toString());
             }
             const nodes = this.#heapSnapshotOptions.nodes;
             if (nodes) {
@@ -701,6 +778,36 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(...paginationData.info);
                 structuredContent.heapSnapshotNodes = paginationData.items;
             }
+            const retainingPaths = this.#heapSnapshotOptions.retainingPaths;
+            if (retainingPaths) {
+                response.push('### Retaining Paths');
+                const { paths, limitsReached } = retainingPaths;
+                if (paths.length === 0) {
+                    response.push('No retaining paths found.');
+                }
+                else {
+                    response.push(HeapSnapshotFormatter.formatRetainingPaths(paths));
+                }
+                const reached = Object.entries(limitsReached)
+                    .filter(([, hit]) => hit)
+                    .map(([limit]) => limit);
+                if (reached.length > 0) {
+                    response.push(`Note: results are truncated, the following limits were reached: ${reached.join(', ')}.`);
+                }
+                structuredContent.heapSnapshotRetainingPaths =
+                    retainingPaths;
+            }
+            const dominators = this.#heapSnapshotOptions.dominators;
+            if (dominators) {
+                response.push('### Dominator Chain');
+                if (dominators.length === 0) {
+                    response.push('No dominators found.');
+                }
+                else {
+                    response.push(HeapSnapshotFormatter.formatDominators(dominators));
+                }
+                structuredContent.heapSnapshotDominators = dominators;
+            }
         }
         if (data.detailedNetworkRequest) {
             response.push(data.detailedNetworkRequest.toStringDetailed());
@@ -728,18 +835,11 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(extensionsMessage);
             }
         }
-        if (data.thirdPartyDeveloperTools !== undefined) {
-            if (data.thirdPartyDeveloperTools) {
-                structuredContent.thirdPartyDeveloperTools =
-                    data.thirdPartyDeveloperTools;
-            }
+        if (data.thirdPartyDeveloperTools.length) {
+            structuredContent.thirdPartyDeveloperTools =
+                data.thirdPartyDeveloperTools;
             response.push('## Third-party developer tools');
-            if (data.thirdPartyDeveloperTools === null ||
-                !data.thirdPartyDeveloperTools?.tools) {
-                response.push('No third-party developer tools available.');
-            }
-            else {
-                const toolGroup = data.thirdPartyDeveloperTools;
+            for (const toolGroup of data.thirdPartyDeveloperTools) {
                 response.push(`${toolGroup.name}: ${toolGroup.description}`);
                 response.push('Available tools:');
                 const toolDefinitionsMessage = toolGroup.tools
@@ -778,11 +878,10 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 structuredContent.pagination = paginationData.pagination;
                 response.push(...paginationData.info);
                 if (data.networkRequests) {
-                    structuredContent.networkRequests = [];
-                    for (const formatter of paginationData.items) {
-                        response.push(formatter.toString());
-                        structuredContent.networkRequests.push(formatter.toJSON());
-                    }
+                    structuredContent.networkRequests = paginationData.items.map(i => i.toJSON());
+                    response.push(...(useToon
+                        ? [toonEncode(structuredContent.networkRequests)]
+                        : paginationData.items.map(i => i.toString())));
                 }
             }
             else {
@@ -796,9 +895,14 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 const grouped = ConsoleFormatter.groupConsecutive(messages);
                 const paginationData = this.#dataWithPagination(grouped, this.#consoleDataOptions.pagination);
                 structuredContent.pagination = paginationData.pagination;
-                response.push(...paginationData.info);
-                response.push(...paginationData.items.map(item => item.toString()));
                 structuredContent.consoleMessages = paginationData.items.map(item => item.toJSON());
+                response.push(...paginationData.info);
+                if (useToon) {
+                    response.push(toonEncode(structuredContent.consoleMessages));
+                }
+                else {
+                    response.push(...paginationData.items.map(item => item.toString()));
+                }
             }
             else {
                 response.push('<no console messages found>');
@@ -857,11 +961,25 @@ Call ${handleDialog.name} to handle it before continuing.`);
         this.#textResponseLines = [];
     }
 }
-function createStructuredPage(page, context) {
+function truncateTitle(title, maxLength = 50) {
+    if (title.length <= maxLength) {
+        return title;
+    }
+    return title.slice(0, maxLength - 3) + '...';
+}
+async function fetchPageTitle(page) {
+    return Promise.race([
+        page.title().catch(() => ''),
+        new Promise(resolve => setTimeout(() => resolve(''), 1000)),
+    ]);
+}
+function createStructuredPage(page, context, rawTitle) {
     const isolatedContextName = context.getIsolatedContextName(page);
+    const title = truncateTitle(rawTitle);
     const entry = {
         id: context.getPageId(page),
         url: page.url(),
+        title,
         selected: context.isPageSelected(page),
     };
     if (isolatedContextName) {

package/build/src/PageCollector.js

@@ -3,7 +3,7 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { FakeIssuesManager } from './DevtoolsUtils.js';
+import { FakeIssuesManager } from './devtools/DevtoolsUtils.js';
 import { logger } from './logger.js';
 import { DevTools } from './third_party/index.js';
 import { createIdGenerator, stableIdSymbol, } from './utils/id.js';
@@ -50,7 +50,7 @@ export class PageCollector {
             this.addPage(page);
         }
         catch (err) {
-            logger('Error getting a page for a target onTargetCreated', err);
+            logger?.('Error getting a page for a target onTargetCreated', err);
         }
     };
     #onTargetDestroyed = async (target) => {
@@ -62,7 +62,7 @@ export class PageCollector {
             this.cleanupPageDestroyed(page);
         }
         catch (err) {
-            logger('Error getting a page for a target onTargetDestroyed', err);
+            logger?.('Error getting a page for a target onTargetDestroyed', err);
         }
     };
     addPage(page) {
@@ -136,10 +136,10 @@ export class PageCollector {
             throw new Error('No requests found for selected page');
         }
         const item = this.find(page, item => item[stableIdSymbol] === stableId);
-        if (item) {
-            return item;
+        if (!item) {
+            throw new Error('Request not found for selected page');
         }
-        throw new Error('Request not found for selected page');
+        return item;
     }
     find(page, filter) {
         const navigations = this.storage.get(page);
@@ -241,7 +241,7 @@ class PageEventSubscriber {
             // @ts-expect-error Protocol types diverge.
             inspectorIssue)[0];
             if (!issue) {
-                logger('No issue mapping for for the issue: ', inspectorIssue.code);
+                logger?.('No issue mapping for for the issue: ', inspectorIssue.code);
                 return;
             }
             const primaryKey = issue.primaryKey();
@@ -256,7 +256,7 @@ class PageEventSubscriber {
             });
         }
         catch (error) {
-            logger('Error creating a new issue', error);
+            logger?.('Error creating a new issue', error);
         }
     };
 }

package/build/src/ServiceWorkerCollector.js

@@ -0,0 +1,171 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { UncaughtError } from './PageCollector.js';
+import { createIdGenerator, stableIdSymbol } from './utils/id.js';
+const CHROME_EXTENSION_PREFIX = 'chrome-extension://';
+export class ServiceWorkerSubscriber {
+    #target;
+    #callback;
+    #session;
+    #worker;
+    constructor(target, callback) {
+        this.#target = target;
+        this.#callback = callback;
+    }
+    async subscribe() {
+        this.#session = await this.#target.createCDPSession();
+        await this.#session.send('Runtime.enable');
+        this.#session.on('Runtime.exceptionThrown', this.#onExceptionThrown);
+        this.#worker = (await this.#target.worker()) ?? undefined;
+        if (this.#worker) {
+            this.#worker.on('console', this.#onConsole);
+        }
+    }
+    async unsubscribe() {
+        if (this.#worker) {
+            this.#worker.off('console', this.#onConsole);
+        }
+        await this.#session?.detach();
+    }
+    #onConsole = (message) => {
+        this.#callback(message);
+    };
+    #onExceptionThrown = (event) => {
+        const url = this.#target.url();
+        const extensionId = extractExtensionId(url);
+        if (extensionId) {
+            this.#callback(new UncaughtError(event.exceptionDetails, extensionId));
+        }
+    };
+}
+export class ServiceWorkerConsoleCollector {
+    #storage = new Map();
+    #maxLogs;
+    #browser;
+    #serviceWorkerSubscribers = new Map();
+    #idGenerator = createIdGenerator();
+    constructor(browser, maxLogs = 1000) {
+        this.#browser = browser;
+        this.#maxLogs = maxLogs;
+    }
+    async init(workers) {
+        if (!this.#browser) {
+            return;
+        }
+        this.#browser.on('targetcreated', this.#onTargetCreated);
+        this.#browser.on('targetdestroyed', this.#onTargetDestroyed);
+        for (const worker of workers) {
+            void this.#onTargetCreated(worker.target);
+        }
+    }
+    dispose() {
+        if (!this.#browser) {
+            return;
+        }
+        this.#browser.off('targetcreated', this.#onTargetCreated);
+        this.#browser.off('targetdestroyed', this.#onTargetDestroyed);
+        for (const subscriber of this.#serviceWorkerSubscribers.values()) {
+            subscriber.unsubscribe().catch(err => {
+                if (err instanceof Error &&
+                    !err.message.includes('Target closed') &&
+                    !err.message.includes('Session closed')) {
+                    // Swallow error as we are tearing down the system
+                }
+            });
+        }
+        this.#serviceWorkerSubscribers.clear();
+    }
+    #onTargetCreated = async (target) => {
+        if (this.#serviceWorkerSubscribers.has(target)) {
+            return;
+        }
+        const origin = target.url();
+        if (target.type() === 'service_worker' && isExtensionOrigin(origin)) {
+            const extensionId = extractExtensionId(origin);
+            if (!extensionId) {
+                return;
+            }
+            const subscriber = new ServiceWorkerSubscriber(target, item => {
+                this.addLog(extensionId, item);
+            });
+            try {
+                await subscriber.subscribe();
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    !err.message.includes('Target closed') &&
+                    !err.message.includes('Session closed')) {
+                    throw err;
+                }
+            }
+            this.#serviceWorkerSubscribers.set(target, subscriber);
+        }
+    };
+    #onTargetDestroyed = async (target) => {
+        const subscriber = this.#serviceWorkerSubscribers.get(target);
+        if (subscriber) {
+            try {
+                await subscriber.unsubscribe();
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    !err.message.includes('Target closed') &&
+                    !err.message.includes('Session closed')) {
+                    throw err;
+                }
+            }
+            this.#serviceWorkerSubscribers.delete(target);
+        }
+    };
+    addLog(extensionId, log) {
+        const logs = this.#storage.get(extensionId) ?? [];
+        const withId = log;
+        withId[stableIdSymbol] = this.#idGenerator();
+        logs.push(withId);
+        if (logs.length > this.#maxLogs) {
+            logs.shift();
+        }
+        this.#storage.set(extensionId, logs);
+    }
+    getData(extensionId) {
+        return this.#storage.get(extensionId) ?? [];
+    }
+    getById(extensionId, stableId) {
+        const logs = this.#storage.get(extensionId);
+        if (!logs) {
+            throw new Error('No logs found for selected extension');
+        }
+        const item = logs.find(item => item[stableIdSymbol] === stableId);
+        if (item) {
+            return item;
+        }
+        throw new Error('Log not found for selected extension');
+    }
+    find(extensionId, filter) {
+        const logs = this.#storage.get(extensionId);
+        if (!logs) {
+            return;
+        }
+        return logs.find(filter);
+    }
+    clearLogs(extensionId) {
+        this.#storage.delete(extensionId);
+    }
+}
+function extractExtensionId(origin) {
+    if (!origin || !isExtensionOrigin(origin)) {
+        return null;
+    }
+    const pathPart = origin.substring(CHROME_EXTENSION_PREFIX.length);
+    const slashIndex = pathPart.indexOf('/');
+    // if there's no / it means that pathPart is now the extensionId, otherwise
+    // we take everything until the first /
+    return slashIndex === -1 ? pathPart : pathPart.substring(0, slashIndex);
+}
+function isExtensionOrigin(origin) {
+    return origin.startsWith(CHROME_EXTENSION_PREFIX);
+}
+//# sourceMappingURL=ServiceWorkerCollector.js.map

package/build/src/TextSnapshot.js

@@ -186,7 +186,7 @@ export class TextSnapshot {
                 }
             }
             catch (e) {
-                logger(`Failed to collect descendants for backend node ${backendNodeId}`, e);
+                logger?.(`Failed to collect descendants for backend node ${backendNodeId}`, e);
             }
             return descendantIds;
         };