chrome-devtools-mcp 1.4.0 → 1.5.0

package/build/src/third_party/bundled-packages.json

@@ -1,12 +1,11 @@
 {
   "@modelcontextprotocol/sdk": "1.29.0",
-  "@toon-format/toon": "^2.2.0",
-  "chrome-devtools-frontend": "1.0.1650035",
+  "chrome-devtools-frontend": "1.0.1652307",
   "core-js": "3.49.0",
   "debug": "4.4.3",
   "lighthouse": "13.4.0",
   "semver": "^7.7.4",
   "urlpattern-polyfill": "^10.1.0",
   "yargs": "18.0.0",
-  "puppeteer-core": "25.2.0"
+  "puppeteer-core": "25.2.1"
 }

package/build/src/third_party/devtools-heap-snapshot-worker.js

@@ -5930,6 +5930,9 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     aggregatesWithFilter(filter) {
         return this.callMethodPromise('aggregatesWithFilter', filter);
     }
+    getDuplicateStrings() {
+        return this.callMethodPromise('getDuplicateStrings');
+    }
     aggregatesForDiff(interfaceDefinitions) {
         return this.callMethodPromise('aggregatesForDiff', interfaceDefinitions);
     }
@@ -6712,6 +6715,45 @@ class HeapSnapshotNode {
         value |= detachedness;
         this.#setDetachednessAndClassIndex(value);
     }
+    findInternalEdgeTarget(name) {
+        for (let iter = this.edges(); iter.hasNext(); iter.next()) {
+            const edge = iter.edge;
+            if (!edge.isInternal()) {
+                continue;
+            }
+            if (edge.name() === name) {
+                return edge.node();
+            }
+        }
+        return undefined;
+    }
+    nodeValueAsBool() {
+        if (this.rawType() !== this.snapshot.nodeNumberType) {
+            return undefined;
+        }
+        if (this.rawName() !== 'bool') {
+            return undefined;
+        }
+        const valNode = this.findInternalEdgeTarget('value');
+        if (!valNode) {
+            return undefined;
+        }
+        const rawName = valNode.rawName();
+        if (rawName === 'true') {
+            return true;
+        }
+        if (rawName === 'false') {
+            return false;
+        }
+        return undefined;
+    }
+    nodeIsTruncatedString() {
+        const truncNode = this.findInternalEdgeTarget('truncated');
+        if (!truncNode) {
+            return false;
+        }
+        return truncNode.nodeValueAsBool() === true;
+    }
 }
 class HeapSnapshotNodeIterator {
     node;
@@ -6927,6 +6969,7 @@ class HeapSnapshot {
     nodeSyntheticType;
     nodeClosureType;
     nodeRegExpType;
+    nodeNumberType;
     edgeFieldsCount;
     edgeTypeOffset;
     edgeNameOffset;
@@ -7001,6 +7044,7 @@ class HeapSnapshot {
         this.nodeSyntheticType = this.nodeTypes.indexOf('synthetic');
         this.nodeClosureType = this.nodeTypes.indexOf('closure');
         this.nodeRegExpType = this.nodeTypes.indexOf('regexp');
+        this.nodeNumberType = this.nodeTypes.indexOf('number');
         this.edgeFieldsCount = meta.edge_fields.length;
         this.edgeTypeOffset = meta.edge_fields.indexOf('type');
         this.edgeNameOffset = meta.edge_fields.indexOf('name_or_index');
@@ -7280,6 +7324,43 @@ class HeapSnapshot {
         const key = filter ? filter.key : 'allObjects';
         return this.getAggregatesByClassKey(false, key, filter);
     }
+    getDuplicateStrings() {
+        const filter = this.createNamedFilter('duplicatedStrings');
+        const groupsMap = new Map();
+        const node = this.createNode(0);
+        for (let i = 0; i < this.nodeCount; ++i) {
+            node.nodeIndex = i * this.nodeFieldCount;
+            if (filter(node)) {
+                const name = node.name();
+                const truncated = node.nodeIsTruncatedString();
+                let group = groupsMap.get(name);
+                if (!group) {
+                    group = {
+                        value: name,
+                        count: 0,
+                        totalSelfSize: 0,
+                        totalRetainedSize: 0,
+                        nodes: [],
+                        truncated,
+                    };
+                    groupsMap.set(name, group);
+                }
+                else if (truncated) {
+                    group.truncated = true;
+                }
+                group.count++;
+                group.totalSelfSize += node.selfSize();
+                group.totalRetainedSize += node.retainedSize();
+                group.nodes.push({
+                    id: node.id(),
+                    selfSize: node.selfSize(),
+                    retainedSize: node.retainedSize(),
+                    distance: node.distance(),
+                });
+            }
+        }
+        return Array.from(groupsMap.values()).sort((a, b) => b.totalRetainedSize - a.totalRetainedSize);
+    }
     createNodeIdFilter(minNodeId, maxNodeId) {
         function nodeIdFilter(node) {
             const id = node.id();