opera-devtools-mcp 0.2.4 → 0.3.0

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

@@ -642,10 +642,14 @@ class Diff {
     removedCount = 0;
     addedSize = 0;
     removedSize = 0;
-    deletedIndexes = [];
-    addedIndexes = [];
     countDelta;
     sizeDelta;
+    addedIndexes = [];
+    addedIds = [];
+    addedSelfSizes = [];
+    deletedIndexes = [];
+    deletedIds = [];
+    deletedSelfSizes = [];
     constructor(name) {
         this.name = name;
     }
@@ -2806,44 +2810,15 @@ const LAYOUT_LINES_HIGHLIGHT_COLOR = [127, 32, 210];
     Mask: Legacy.fromRGBA([248, 249, 249, 1]),
 });
 
-// Copyright 2025 The Chromium Authors
-class WritableDevToolsContext {
-    #instances = new Map();
-    get(ctor) {
-        const instance = this.#instances.get(ctor);
-        if (!instance) {
-            throw new Error(`No instance for ${ctor.name}. Ensure the bootstrapper creates it.`);
-        }
-        return instance;
-    }
-    has(ctor) {
-        return this.#instances.has(ctor);
-    }
-    set(ctor, instance) {
-        this.#instances.set(ctor, instance);
-    }
-    delete(ctor) {
-        this.#instances.delete(ctor);
-    }
-}
-let gInstance = null;
-function globalInstance() {
-    if (!gInstance) {
-        gInstance = new WritableDevToolsContext();
-    }
-    return gInstance;
-}
-
 // Copyright 2026 The Chromium Authors
 var ExperimentName;
 (function (ExperimentName) {
     ExperimentName["ALL"] = "*";
-    ExperimentName["CAPTURE_NODE_CREATION_STACKS"] = "capture-node-creation-stacks";
     ExperimentName["PROTOCOL_MONITOR"] = "protocol-monitor";
     ExperimentName["INSTRUMENTATION_BREAKPOINTS"] = "instrumentation-breakpoints";
-    ExperimentName["USE_SOURCE_MAP_SCOPES"] = "use-source-map-scopes";
     ExperimentName["DURABLE_MESSAGES"] = "durable-messages";
     ExperimentName["JPEG_XL"] = "jpeg-xl";
+    ExperimentName["PLUS_BUTTON"] = "plus-button";
 })(ExperimentName || (ExperimentName = {}));
 
 // Copyright 2021 The Chromium Authors
@@ -4798,7 +4773,7 @@ function lockedLazyString(str) {
 // Copyright 2014 The Chromium Authors
 const UIStrings$2 = {
     elementsPanel: 'Elements panel',
-    stylesSidebar: 'styles sidebar',
+    stylesSidebar: 'Styles sidebar',
     changesDrawer: 'Changes drawer',
     issuesView: 'Issues view',
     networkPanel: 'Network panel',
@@ -4807,50 +4782,12 @@ const UIStrings$2 = {
     sourcesPanel: 'Sources panel',
     timelinePanel: 'Performance panel',
     memoryInspectorPanel: 'Memory inspector panel',
-    developerResourcesPanel: 'Developer Resources panel',
+    developerResourcesPanel: 'Developer resources panel',
     animationsPanel: 'Animations panel',
+    lighthousePanel: 'Lighthouse panel',
 };
 const str_$2 = registerUIStrings('core/common/Revealer.ts', UIStrings$2);
 const i18nLazyString$1 = getLazilyComputedLocalizedString.bind(undefined, str_$2);
-let revealerRegistry;
-class RevealerRegistry {
-    registeredRevealers = [];
-    static instance() {
-        if (revealerRegistry === undefined) {
-            revealerRegistry = new RevealerRegistry();
-        }
-        return revealerRegistry;
-    }
-    static removeInstance() {
-        revealerRegistry = undefined;
-    }
-    register(registration) {
-        this.registeredRevealers.push(registration);
-    }
-    async reveal(revealable, omitFocus) {
-        const revealers = await Promise.all(this.getApplicableRegisteredRevealers(revealable).map(registration => registration.loadRevealer()));
-        if (revealers.length < 1) {
-            throw new Error(`No revealers found for ${revealable}`);
-        }
-        if (revealers.length > 1) {
-            throw new Error(`Conflicting reveals found for ${revealable}`);
-        }
-        return await revealers[0].reveal(revealable, omitFocus);
-    }
-    getApplicableRegisteredRevealers(revealable) {
-        return this.registeredRevealers.filter(registration => {
-            for (const contextType of registration.contextTypes()) {
-                if (revealable instanceof contextType) {
-                    return true;
-                }
-            }
-            return false;
-        });
-    }
-}
-async function reveal(revealable, omitFocus = false) {
-    await RevealerRegistry.instance().reveal(revealable, omitFocus);
-}
 ({
     DEVELOPER_RESOURCES_PANEL: i18nLazyString$1(UIStrings$2.developerResourcesPanel),
     ELEMENTS_PANEL: i18nLazyString$1(UIStrings$2.elementsPanel),
@@ -4864,44 +4801,10 @@ async function reveal(revealable, omitFocus = false) {
     SOURCES_PANEL: i18nLazyString$1(UIStrings$2.sourcesPanel),
     MEMORY_INSPECTOR_PANEL: i18nLazyString$1(UIStrings$2.memoryInspectorPanel),
     ANIMATIONS_PANEL: i18nLazyString$1(UIStrings$2.animationsPanel),
+    LIGHTHOUSE_PANEL: i18nLazyString$1(UIStrings$2.lighthousePanel),
 });
 
 // Copyright 2014 The Chromium Authors
-class Console extends ObjectWrapper {
-    #messages = [];
-    static instance(opts) {
-        if (!globalInstance().has(Console) || opts?.forceNew) {
-            globalInstance().set(Console, new Console());
-        }
-        return globalInstance().get(Console);
-    }
-    static removeInstance() {
-        globalInstance().delete(Console);
-    }
-    addMessage(text, level = "info" , show = false, source) {
-        const message = new Message(text, level, Date.now(), show, source);
-        this.#messages.push(message);
-        this.dispatchEventToListeners("messageAdded" , message);
-    }
-    log(text) {
-        this.addMessage(text, "info" );
-    }
-    warn(text, source) {
-        this.addMessage(text, "warning" , undefined, source);
-    }
-    error(text, show = true) {
-        this.addMessage(text, "error" , show);
-    }
-    messages() {
-        return this.#messages;
-    }
-    show() {
-        void this.showPromise();
-    }
-    showPromise() {
-        return reveal(this);
-    }
-}
 var FrontendMessageSource;
 (function (FrontendMessageSource) {
     FrontendMessageSource["CSS"] = "css";
@@ -4909,22 +4812,6 @@ var FrontendMessageSource;
     FrontendMessageSource["ISSUE_PANEL"] = "issue-panel";
     FrontendMessageSource["SELF_XSS"] = "self-xss";
 })(FrontendMessageSource || (FrontendMessageSource = {}));
-class Message {
-    text;
-    level;
-    timestamp;
-    show;
-    source;
-    constructor(text, level, timestamp, show, source) {
-        this.text = text;
-        this.level = level;
-        this.timestamp = (typeof timestamp === 'number') ? timestamp : Date.now();
-        this.show = show;
-        if (source) {
-            this.source = source;
-        }
-    }
-}
 
 // Copyright 2012 The Chromium Authors
 function normalizePath(path) {
@@ -5328,7 +5215,11 @@ class ParsedURL {
             return 'data:';
         }
         const scheme = this.isBlobURL() ? this.blobInnerScheme : this.scheme;
-        return scheme + '://' + this.domain();
+        const domain = this.domain();
+        if (!scheme && !domain) {
+            return '';
+        }
+        return scheme + '://' + domain;
     }
     urlWithoutScheme() {
         if (this.scheme && this.url.startsWith(this.scheme + '://')) {
@@ -5725,7 +5616,6 @@ const UIStrings = {
     extension: 'Extension',
     adorner: 'Adorner',
     account: 'Account',
-    privacy: 'Privacy',
 };
 const str_ = registerUIStrings('core/common/SettingRegistration.ts', UIStrings);
 getLocalizedString.bind(undefined, str_);
@@ -5733,6 +5623,7 @@ getLocalizedString.bind(undefined, str_);
 // Copyright 2011 The Chromium Authors
 class HeapSnapshotWorkerProxy extends ObjectWrapper {
     eventHandler;
+    #console;
     nextObjectId = 1;
     nextCallId = 1;
     callbacks = new Map();
@@ -5740,13 +5631,17 @@ class HeapSnapshotWorkerProxy extends ObjectWrapper {
     worker;
     interval;
     workerUrl;
-    constructor(eventHandler, workerUrl) {
+    constructor(eventHandler, console, workerUrl) {
         super();
         this.eventHandler = eventHandler;
+        this.#console = console;
         this.workerUrl = workerUrl;
         this.worker = HOST_RUNTIME.createWorker(workerUrl ?? import.meta.resolve('../../entrypoints/heap_snapshot_worker/heap_snapshot_worker-entrypoint.js'));
         this.worker.onmessage = this.messageReceived.bind(this);
     }
+    get console() {
+        return this.#console;
+    }
     createLoader(profileUid, snapshotReceivedCallback) {
         const objectId = this.nextObjectId++;
         const proxy = new HeapSnapshotLoaderProxy(this, objectId, profileUid, snapshotReceivedCallback);
@@ -5814,7 +5709,7 @@ class HeapSnapshotWorkerProxy extends ObjectWrapper {
             return;
         }
         this.checkLongRunningCalls();
-        this.interval = window.setInterval(this.checkLongRunningCalls.bind(this), 300);
+        this.interval = globalThis.setInterval(this.checkLongRunningCalls.bind(this), 300);
     }
     checkLongRunningCalls() {
         for (const callId of this.previousCallbacks) {
@@ -5849,8 +5744,8 @@ class HeapSnapshotWorkerProxy extends ObjectWrapper {
             return;
         }
         if (data.error) {
-            Console.instance().error(`An error occurred when a call to method '${data.errorMethodName}' was requested`);
-            Console.instance().error(data['errorCallStack']);
+            this.#console.error(`An error occurred when a call to method '${data.errorMethodName}' was requested`);
+            this.#console.error(data['errorCallStack']);
             this.callbacks.delete(data.callId);
             return;
         }
@@ -5898,7 +5793,7 @@ class HeapSnapshotLoaderProxy extends HeapSnapshotProxyObject {
     }
     async close() {
         await this.callMethodPromise('close');
-        const secondWorker = new HeapSnapshotWorkerProxy(() => { }, this.worker.workerUrl);
+        const secondWorker = new HeapSnapshotWorkerProxy(() => { }, this.worker.console, this.worker.workerUrl);
         const channel = new MessageChannel();
         await secondWorker.setupForSecondaryInit(channel.port2);
         const snapshotProxy = await this.callFactoryMethodPromise('buildSnapshot', HeapSnapshotProxy, [channel.port1]);
@@ -5922,9 +5817,18 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     interfaceDefinitions() {
         return this.callMethodPromise('interfaceDefinitions');
     }
+    getNativeContextSizes() {
+        return this.callMethodPromise('getNativeContextSizes');
+    }
+    getRetainedByContextSummary() {
+        return this.callMethodPromise('getRetainedByContextSummary');
+    }
     aggregatesWithFilter(filter) {
         return this.callMethodPromise('aggregatesWithFilter', filter);
     }
+    getDuplicateStrings() {
+        return this.callMethodPromise('getDuplicateStrings');
+    }
     aggregatesForDiff(interfaceDefinitions) {
         return this.callMethodPromise('aggregatesForDiff', interfaceDefinitions);
     }
@@ -5934,8 +5838,14 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     nodeClassKey(snapshotObjectId) {
         return this.callMethodPromise('nodeClassKey', snapshotObjectId);
     }
-    createEdgesProvider(nodeIndex) {
-        return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
+    nodeIndexForId(nodeId) {
+        return this.callMethodPromise('nodeIndexForId', nodeId);
+    }
+    getObjectInfo(nodeIndex) {
+        return this.callMethodPromise('getObjectInfo', nodeIndex);
+    }
+    createEdgesProvider(nodeIndex, options) {
+        return this.callFactoryMethod('createEdgesProvider', HeapSnapshotProviderProxy, nodeIndex, options);
     }
     createRetainingEdgesProvider(nodeIndex) {
         return this.callFactoryMethod('createRetainingEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
@@ -5952,6 +5862,9 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     createNodesProviderForClass(classKey, nodeFilter) {
         return this.callFactoryMethod('createNodesProviderForClass', HeapSnapshotProviderProxy, classKey, nodeFilter);
     }
+    queryObjects(queryOptions) {
+        return this.callFactoryMethod('queryObjects', HeapSnapshotProviderProxy, queryOptions);
+    }
     allocationTracesTops() {
         return this.callMethodPromise('allocationTracesTops');
     }
@@ -5991,6 +5904,12 @@ class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     ignoreNodeInRetainersView(nodeIndex) {
         return this.callMethodPromise('ignoreNodeInRetainersView', nodeIndex);
     }
+    getRetainingPaths(nodeIndex, maxDepth, maxNodes, maxSiblings) {
+        return this.callMethodPromise('getRetainingPaths', nodeIndex, maxDepth, maxNodes, maxSiblings);
+    }
+    getDominatorsOf(nodeIndex) {
+        return this.callMethodPromise('getDominatorsOf', nodeIndex);
+    }
     unignoreNodeInRetainersView(nodeIndex) {
         return this.callMethodPromise('unignoreNodeInRetainersView', nodeIndex);
     }
@@ -6673,21 +6592,10 @@ class HeapSnapshotNode {
         return false;
     }
     #detachednessAndClassIndex() {
-        const { snapshot, nodeIndex } = this;
-        const nodeDetachednessAndClassIndexOffset = snapshot.nodeDetachednessAndClassIndexOffset;
-        return nodeDetachednessAndClassIndexOffset !== -1 ?
-            snapshot.nodes.getValue(nodeIndex + nodeDetachednessAndClassIndexOffset) :
-            snapshot.detachednessAndClassIndexArray[nodeIndex / snapshot.nodeFieldCount];
+        return this.snapshot.detachednessAndClassIndexArray[this.nodeIndex / this.snapshot.nodeFieldCount];
     }
     #setDetachednessAndClassIndex(value) {
-        const { snapshot, nodeIndex } = this;
-        const nodeDetachednessAndClassIndexOffset = snapshot.nodeDetachednessAndClassIndexOffset;
-        if (nodeDetachednessAndClassIndexOffset !== -1) {
-            snapshot.nodes.setValue(nodeIndex + nodeDetachednessAndClassIndexOffset, value);
-        }
-        else {
-            snapshot.detachednessAndClassIndexArray[nodeIndex / snapshot.nodeFieldCount] = value;
-        }
+        this.snapshot.detachednessAndClassIndexArray[this.nodeIndex / this.snapshot.nodeFieldCount] = value;
     }
     detachedness() {
         return this.#detachednessAndClassIndex() & BITMASK_FOR_DOM_LINK_STATE;
@@ -6698,6 +6606,67 @@ 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;
+    }
+    nodeValueAsInt() {
+        if (this.rawType() !== this.snapshot.nodeNumberType) {
+            return undefined;
+        }
+        if (this.rawName() !== 'int') {
+            return undefined;
+        }
+        const valNode = this.findInternalEdgeTarget('value');
+        if (!valNode) {
+            return undefined;
+        }
+        const value = parseInt(valNode.rawName(), 10);
+        return isNaN(value) ? undefined : value;
+    }
+    nodeStringLength() {
+        const lengthNode = this.findInternalEdgeTarget('length');
+        return lengthNode ? lengthNode.nodeValueAsInt() : undefined;
+    }
+    nodeStringHash() {
+        const hashNode = this.findInternalEdgeTarget('hash');
+        return hashNode ? hashNode.nodeValueAsInt() : undefined;
+    }
+    nodeIsTruncatedString() {
+        const truncNode = this.findInternalEdgeTarget('truncated');
+        if (!truncNode) {
+            return false;
+        }
+        return truncNode.nodeValueAsBool() === true;
+    }
 }
 class HeapSnapshotNodeIterator {
     node;
@@ -6848,7 +6817,7 @@ class SecondaryInitManager {
                 ...retainers,
                 essentialEdges: createBitVector(argsStep2.essentialEdgesBuffer),
                 port,
-                nodeSelfSizesPromise: this.getNodeSelfSizes()
+                nodeSelfSizesPromise: this.getNodeSelfSizes(),
             };
             const dominatorsAndRetainedSizes = await HeapSnapshot.calculateDominatorsAndRetainedSizes(args);
             const dominatedNodesOutputs = HeapSnapshot.buildDominatedNodes({ ...args, ...dominatorsAndRetainedSizes });
@@ -6878,6 +6847,8 @@ const MIN_INTERFACE_PROPERTY_COUNT = 1;
 const MAX_INTERFACE_NAME_LENGTH = 120;
 const MIN_OBJECT_COUNT_PER_INTERFACE = 2;
 const MIN_OBJECT_PROPORTION_PER_INTERFACE = 1000;
+const NO_NATIVE_CONTEXT = -1;
+const SHARED_NATIVE_CONTEXT = -2;
 class HeapSnapshot {
     nodes;
     containmentEdges;
@@ -6913,6 +6884,7 @@ class HeapSnapshot {
     nodeSyntheticType;
     nodeClosureType;
     nodeRegExpType;
+    nodeNumberType;
     edgeFieldsCount;
     edgeTypeOffset;
     edgeNameOffset;
@@ -6949,6 +6921,9 @@ class HeapSnapshot {
     #nodeDistancesForRetainersView;
     #edgeNamesThatAreNotWeakMaps;
     detachednessAndClassIndexArray;
+    nodeNativeContextAttribution;
+    #nativeContextSizes;
+    #nativeContextOrdinals;
     #interfaceNames = new Map();
     #interfaceDefinitions;
     constructor(profile, progress) {
@@ -6987,6 +6962,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');
@@ -7014,6 +6990,7 @@ class HeapSnapshot {
         this.#progress.updateStatus('Building retainers…');
         const resultsFromSecondWorker = this.startInitStep1InSecondThread(secondWorker);
         this.#progress.updateStatus('Propagating DOM state…');
+        this.initDetachednessAndClassIndex();
         this.propagateDOMState();
         this.#progress.updateStatus('Calculating node flags…');
         this.calculateFlags();
@@ -7033,8 +7010,11 @@ class HeapSnapshot {
         this.buildSamples();
         this.#progress.updateStatus('Building locations…');
         this.buildLocationMap();
+        this.#progress.updateStatus('Calculating native context attribution…');
+        this.calculateNativeContextAttribution();
         this.#progress.updateStatus('Calculating retained sizes…');
         await this.installResultsFromSecondThread(resultsFromSecondWorker);
+        this.calculateNativeContextSizes();
         this.#progress.updateStatus('Calculating statistics…');
         this.calculateStatistics();
         if (this.profile.snapshot.trace_function_count) {
@@ -7059,6 +7039,36 @@ class HeapSnapshot {
         }
         this.#progress.updateStatus('Finished processing.');
     }
+    nodeIndexForId(nodeId) {
+        const nodesLength = this.nodes.length;
+        const { nodes, nodeFieldCount, nodeIdOffset } = this;
+        for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+            if (nodes.getValue(nodeIndex + nodeIdOffset) === nodeId) {
+                return nodeIndex;
+            }
+        }
+        return undefined;
+    }
+    getObjectInfo(nodeIndex) {
+        const nodesLength = this.nodes.length;
+        const nodeFieldCount = this.nodeFieldCount;
+        if (!Number.isInteger(nodeIndex) || nodeIndex < 0 || nodeIndex >= nodesLength || nodeIndex % nodeFieldCount !== 0) {
+            throw new Error('Invalid nodeIndex ' + nodeIndex);
+        }
+        const node = this.createNode(nodeIndex);
+        return {
+            id: node.id(),
+            name: node.name(),
+            type: node.type(),
+            nodeIndex,
+            detachedness: node.detachedness(),
+            selfSize: node.selfSize(),
+            retainedSize: node.retainedSize(),
+            distance: node.distance(),
+            edgeCount: node.edgesCount(),
+            retainerCount: node.retainersCount(),
+        };
+    }
     startInitStep1InSecondThread(secondWorker) {
         const resultsFromSecondWorker = new Promise((resolve, reject) => {
             const listener = (e) => {
@@ -7256,6 +7266,79 @@ class HeapSnapshot {
         const key = filter ? filter.key : 'allObjects';
         return this.getAggregatesByClassKey(false, key, filter);
     }
+    getDuplicateStrings() {
+        const filter = this.createNamedFilter('duplicatedStrings');
+        const untruncatedGroups = new Map();
+        const truncatedGroups = 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();
+                if (truncated) {
+                    const length = node.nodeStringLength();
+                    const hash = node.nodeStringHash();
+                    let groups = truncatedGroups.get(name);
+                    if (!groups) {
+                        groups = [];
+                        truncatedGroups.set(name, groups);
+                    }
+                    let group = groups.find(g => g.length === length && g.hash === hash);
+                    if (!group) {
+                        group = {
+                            value: name,
+                            count: 0,
+                            totalSelfSize: 0,
+                            totalRetainedSize: 0,
+                            nodes: [],
+                            truncated: true,
+                            length,
+                            hash,
+                        };
+                        groups.push(group);
+                    }
+                    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(),
+                    });
+                }
+                else {
+                    let group = untruncatedGroups.get(name);
+                    if (!group) {
+                        group = {
+                            value: name,
+                            count: 0,
+                            totalSelfSize: 0,
+                            totalRetainedSize: 0,
+                            nodes: [],
+                            truncated: false,
+                        };
+                        untruncatedGroups.set(name, group);
+                    }
+                    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(),
+                    });
+                }
+            }
+        }
+        const allGroups = [
+            ...untruncatedGroups.values(),
+            ...Array.from(truncatedGroups.values()).flat(),
+        ];
+        return allGroups.sort((a, b) => b.totalRetainedSize - a.totalRetainedSize);
+    }
     createNodeIdFilter(minNodeId, maxNodeId) {
         function nodeIdFilter(node) {
             const id = node.id();
@@ -7310,6 +7393,12 @@ class HeapSnapshot {
             }
         };
         switch (filterName) {
+            case 'objectsRetainedByContexts':
+                traverse((_node, edge) => {
+                    return !this.isContextObject(edge.node());
+                });
+                markUnreachableNodes();
+                return (node) => !getBit(node);
             case 'objectsRetainedByDetachedDomNodes':
                 traverse((_node, edge) => {
                     return edge.node().detachedness() !== 2 ;
@@ -7322,29 +7411,8 @@ class HeapSnapshot {
                 });
                 markUnreachableNodes();
                 return (node) => !getBit(node);
-            case 'duplicatedStrings': {
-                const stringToNodeIndexMap = new Map();
-                const node = this.createNode(0);
-                for (let i = 0; i < this.nodeCount; ++i) {
-                    node.nodeIndex = i * this.nodeFieldCount;
-                    const rawType = node.rawType();
-                    if (rawType === this.nodeStringType || rawType === this.nodeConsStringType) {
-                        if (node.isFlatConsString()) {
-                            continue;
-                        }
-                        const name = node.name();
-                        const alreadyVisitedNodeIndex = stringToNodeIndexMap.get(name);
-                        if (alreadyVisitedNodeIndex === undefined) {
-                            stringToNodeIndexMap.set(name, node.nodeIndex);
-                        }
-                        else {
-                            bitmap.setBit(alreadyVisitedNodeIndex / this.nodeFieldCount);
-                            bitmap.setBit(node.nodeIndex / this.nodeFieldCount);
-                        }
-                    }
-                }
-                return getBit;
-            }
+            case 'duplicatedStrings':
+                return this.createDuplicatedStringsFilter(bitmap);
             case 'objectsRetainedByEventHandlers': {
                 const node = this.createNode(0);
                 const nodeFieldCount = this.nodeFieldCount;
@@ -7383,9 +7451,79 @@ class HeapSnapshot {
                 markUnreachableNodes();
                 return (node) => !getBit(node);
             }
+            case 'sharedNativeContext':
+                return (node) => {
+                    const ordinal = node.nodeIndex / this.nodeFieldCount;
+                    return this.nodeNativeContextAttribution[ordinal] === SHARED_NATIVE_CONTEXT;
+                };
+            case 'noNativeContext':
+                return (node) => {
+                    const ordinal = node.nodeIndex / this.nodeFieldCount;
+                    return this.nodeNativeContextAttribution[ordinal] === NO_NATIVE_CONTEXT;
+                };
+            default:
+                if (filterName.startsWith('nativeContext_')) {
+                    const targetNodeIndex = Number(filterName.substring('nativeContext_'.length));
+                    const targetOrdinal = targetNodeIndex / this.nodeFieldCount;
+                    return (node) => {
+                        const ordinal = node.nodeIndex / this.nodeFieldCount;
+                        return this.nodeNativeContextAttribution[ordinal] === targetOrdinal;
+                    };
+                }
         }
         throw new Error('Invalid filter name');
     }
+    createDuplicatedStringsFilter(bitmap) {
+        const untruncatedStringToNodeIndexMap = new Map();
+        const truncatedStringToNodeIndexesMap = new Map();
+        const node = this.createNode(0);
+        for (let i = 0; i < this.nodeCount; ++i) {
+            node.nodeIndex = i * this.nodeFieldCount;
+            const rawType = node.rawType();
+            if (rawType !== this.nodeStringType && rawType !== this.nodeConsStringType) {
+                continue;
+            }
+            if (node.isFlatConsString()) {
+                continue;
+            }
+            if (node.selfSize() === 0) {
+                continue;
+            }
+            const name = node.name();
+            const truncated = node.nodeIsTruncatedString();
+            if (truncated) {
+                const length = node.nodeStringLength();
+                const hash = node.nodeStringHash();
+                let entries = truncatedStringToNodeIndexesMap.get(name);
+                if (!entries) {
+                    entries = [];
+                    truncatedStringToNodeIndexesMap.set(name, entries);
+                }
+                const match = entries.find(e => e.length === length && e.hash === hash);
+                if (match) {
+                    bitmap.setBit(match.nodeIndex / this.nodeFieldCount);
+                    bitmap.setBit(node.nodeIndex / this.nodeFieldCount);
+                }
+                else {
+                    entries.push({ nodeIndex: node.nodeIndex, length, hash });
+                }
+            }
+            else {
+                const alreadyVisitedNodeIndex = untruncatedStringToNodeIndexMap.get(name);
+                if (alreadyVisitedNodeIndex === undefined) {
+                    untruncatedStringToNodeIndexMap.set(name, node.nodeIndex);
+                }
+                else {
+                    bitmap.setBit(alreadyVisitedNodeIndex / this.nodeFieldCount);
+                    bitmap.setBit(node.nodeIndex / this.nodeFieldCount);
+                }
+            }
+        }
+        return (node) => {
+            const ordinal = node.nodeIndex / this.nodeFieldCount;
+            return bitmap.getBit(ordinal);
+        };
+    }
     getAggregatesByClassKey(sortedIndexes, key, filter) {
         let aggregates;
         if (key && this.#aggregates[key]) {
@@ -7453,6 +7591,9 @@ class HeapSnapshot {
     isUserRoot(_node) {
         return true;
     }
+    isContextObject(_node) {
+        return false;
+    }
     calculateShallowSizes() {
     }
     calculateDistances(isForRetainersView, filter) {
@@ -7701,7 +7842,7 @@ class HeapSnapshot {
         return true;
     }
     static async calculateDominatorsAndRetainedSizes(inputs) {
-        const { nodeCount, firstEdgeIndexes, edgeFieldsCount, nodeFieldCount, firstRetainerIndex, retainingEdges, retainingNodes, edgeToNodeOrdinals, rootNodeOrdinal, essentialEdges, nodeSelfSizesPromise, port } = inputs;
+        const { nodeCount, firstEdgeIndexes, edgeFieldsCount, nodeFieldCount, firstRetainerIndex, retainingEdges, retainingNodes, edgeToNodeOrdinals, rootNodeOrdinal, essentialEdges, nodeSelfSizesPromise, port, } = inputs;
         function isEssentialEdge(edgeIndex) {
             return essentialEdges.getBit(edgeIndex / edgeFieldsCount);
         }
@@ -7885,9 +8026,6 @@ class HeapSnapshot {
     }
     calculateObjectNames() {
         const { nodes, nodeCount, nodeNameOffset, nodeNativeType, nodeHiddenType, nodeObjectType, nodeCodeType, nodeClosureType, nodeRegExpType, } = this;
-        if (this.nodeDetachednessAndClassIndexOffset === -1) {
-            this.detachednessAndClassIndexArray = new Uint32Array(nodeCount);
-        }
         const stringTable = new Map();
         const getIndexForString = (s) => {
             let index = stringTable.get(s);
@@ -7940,6 +8078,215 @@ class HeapSnapshot {
             node.nodeIndex = node.nextNodeIndex();
         }
     }
+    calculateNativeContextAttribution() {
+        const attribution = new Int32Array(this.nodeCount).fill(NO_NATIVE_CONTEXT);
+        const isFixed = createBitVector(this.nodeCount);
+        const edgeTargets = this.buildInitEdgeTargets();
+        this.#nativeContextOrdinals = [];
+        for (let ordinal = 0; ordinal < this.nodeCount; ordinal++) {
+            if (this.isNativeContext(ordinal)) {
+                this.#nativeContextOrdinals.push(ordinal);
+                attribution[ordinal] = ordinal;
+                isFixed.setBit(ordinal);
+            }
+            else {
+                const owner = this.inferFixedNativeContextForOrdinal(ordinal, edgeTargets);
+                if (owner >= 0) {
+                    attribution[ordinal] = owner;
+                    isFixed.setBit(ordinal);
+                }
+            }
+        }
+        this.propagateNativeContextAttribution(attribution, isFixed);
+        this.nodeNativeContextAttribution = attribution;
+    }
+    calculateNativeContextSizes() {
+        const nodeFieldCount = this.nodeFieldCount;
+        const node = this.createNode(0);
+        const nativeContexts = [];
+        const ordinalToInfo = new Map();
+        for (const ordinal of this.#nativeContextOrdinals) {
+            node.nodeIndex = ordinal * nodeFieldCount;
+            const info = {
+                nodeId: node.id(),
+                nodeIndex: node.nodeIndex,
+                nodeName: node.name(),
+                attributedSize: 0,
+                retainedSize: node.retainedSize(),
+                selfSize: node.selfSize(),
+            };
+            nativeContexts.push(info);
+            ordinalToInfo.set(ordinal, info);
+        }
+        let sharedSize = 0;
+        let noAttributionSize = 0;
+        const selfSizeOffset = this.nodeSelfSizeOffset;
+        const nodes = this.nodes;
+        for (let i = 0; i < this.nodeCount; ++i) {
+            const ownerOrdinal = this.nodeNativeContextAttribution[i];
+            const selfSize = nodes.getValue(i * nodeFieldCount + selfSizeOffset);
+            if (ownerOrdinal === SHARED_NATIVE_CONTEXT) {
+                sharedSize += selfSize;
+            }
+            else if (ownerOrdinal === NO_NATIVE_CONTEXT) {
+                noAttributionSize += selfSize;
+            }
+            else {
+                console.assert(ownerOrdinal >= 0, 'ownerOrdinal should be >= 0');
+                const info = ordinalToInfo.get(ownerOrdinal);
+                console.assert(info !== undefined, 'info should exist');
+                if (info) {
+                    info.attributedSize += selfSize;
+                }
+            }
+        }
+        this.#nativeContextSizes = {
+            nativeContexts,
+            sharedSize,
+            noAttributionSize,
+        };
+    }
+    buildInitEdgeTargets() {
+        const { nodeCount, nodeFieldCount, containmentEdges, edgeFieldsCount, edgeTypeOffset, edgeNameOffset, edgeToNodeOffset, edgeInternalType, firstEdgeIndexes, strings, } = this;
+        const nativeContext = new Int32Array(nodeCount).fill(-1);
+        const map = new Int32Array(nodeCount).fill(-1);
+        const nativeContextIdx = strings.indexOf('native_context');
+        const mapIdx = strings.indexOf('map');
+        for (let ordinal = 0; ordinal < nodeCount; ordinal++) {
+            const first = firstEdgeIndexes[ordinal];
+            const last = firstEdgeIndexes[ordinal + 1];
+            for (let edgeIndex = first; edgeIndex < last; edgeIndex += edgeFieldsCount) {
+                const edgeType = containmentEdges.getValue(edgeIndex + edgeTypeOffset);
+                if (edgeType !== edgeInternalType) {
+                    continue;
+                }
+                const nameIdx = containmentEdges.getValue(edgeIndex + edgeNameOffset);
+                const childNodeIndex = containmentEdges.getValue(edgeIndex + edgeToNodeOffset);
+                const childOrdinal = childNodeIndex / nodeFieldCount;
+                if (nameIdx === nativeContextIdx && nativeContext[ordinal] === -1 && this.isNativeContext(childOrdinal)) {
+                    nativeContext[ordinal] = childOrdinal;
+                }
+                else if (nameIdx === mapIdx && map[ordinal] === -1) {
+                    map[ordinal] = childOrdinal;
+                }
+            }
+        }
+        return { nativeContext, map };
+    }
+    inferFixedNativeContextForOrdinal(ordinal, edgeTargets) {
+        const mapOrdinal = edgeTargets.map[ordinal];
+        if (mapOrdinal >= 0) {
+            const metaMapOrdinal = edgeTargets.map[mapOrdinal];
+            if (metaMapOrdinal >= 0) {
+                const mapNativeContextOrdinal = edgeTargets.nativeContext[metaMapOrdinal];
+                if (mapNativeContextOrdinal >= 0) {
+                    return mapNativeContextOrdinal;
+                }
+            }
+        }
+        return NO_NATIVE_CONTEXT;
+    }
+    mergeNativeContextOwner(current, incoming) {
+        console.assert(incoming !== NO_NATIVE_CONTEXT, 'Incoming owner should not be NO_NATIVE_CONTEXT');
+        if (current === SHARED_NATIVE_CONTEXT || incoming === SHARED_NATIVE_CONTEXT) {
+            return SHARED_NATIVE_CONTEXT;
+        }
+        if (current === NO_NATIVE_CONTEXT) {
+            return incoming;
+        }
+        if (current === incoming) {
+            return current;
+        }
+        return SHARED_NATIVE_CONTEXT;
+    }
+    propagateNativeContextAttribution(attribution, isFixed) {
+        const { nodeCount, containmentEdges, edgeFieldsCount, edgeTypeOffset, edgeToNodeOffset, edgeShortcutType, edgeWeakType, nodeFieldCount, firstEdgeIndexes, } = this;
+        const queue = [];
+        for (let ordinal = 0; ordinal < nodeCount; ordinal++) {
+            if (isFixed.getBit(ordinal)) {
+                queue.push(ordinal);
+            }
+        }
+        let queueIndex = 0;
+        while (queueIndex < queue.length) {
+            const ordinal = queue[queueIndex];
+            queueIndex++;
+            const current = attribution[ordinal];
+            console.assert(current !== NO_NATIVE_CONTEXT, 'Queue should not contain unattributed nodes');
+            const first = firstEdgeIndexes[ordinal];
+            const last = firstEdgeIndexes[ordinal + 1];
+            for (let edgeIndex = first; edgeIndex < last; edgeIndex += edgeFieldsCount) {
+                const edgeType = containmentEdges.getValue(edgeIndex + edgeTypeOffset);
+                if (edgeType === edgeShortcutType || edgeType === edgeWeakType) {
+                    continue;
+                }
+                const childNodeIndex = containmentEdges.getValue(edgeIndex + edgeToNodeOffset);
+                const childOrdinal = childNodeIndex / nodeFieldCount;
+                if (childOrdinal === ordinal || isFixed.getBit(childOrdinal)) {
+                    continue;
+                }
+                const merged = this.mergeNativeContextOwner(attribution[childOrdinal], current);
+                if (merged !== attribution[childOrdinal]) {
+                    attribution[childOrdinal] = merged;
+                    queue.push(childOrdinal);
+                }
+            }
+        }
+    }
+    getNativeContextSizes() {
+        return this.#nativeContextSizes;
+    }
+    getRetainedByContextSummary() {
+        const isRetainedByContext = this.createNamedFilter('objectsRetainedByContexts');
+        let contextCount = 0;
+        let retainedByContextSize = 0;
+        let retainedByContextCount = 0;
+        let notRetainedByContextSize = 0;
+        let notRetainedByContextCount = 0;
+        const node = this.rootNode();
+        const { nodes, nodeFieldCount, nodeSelfSizeOffset: selfSizeOffset } = this;
+        const nodesLength = nodes.length;
+        for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+            const selfSize = nodes.getValue(nodeIndex + selfSizeOffset);
+            if (!selfSize) {
+                continue;
+            }
+            node.nodeIndex = nodeIndex;
+            if (isRetainedByContext(node)) {
+                retainedByContextCount++;
+                retainedByContextSize += selfSize;
+            }
+            else {
+                notRetainedByContextCount++;
+                notRetainedByContextSize += selfSize;
+            }
+            if (this.isContextObject(node)) {
+                contextCount++;
+            }
+        }
+        return {
+            contextCount,
+            retainedByContextSize,
+            retainedByContextCount,
+            notRetainedByContextSize,
+            notRetainedByContextCount,
+            totalSize: retainedByContextSize + notRetainedByContextSize,
+        };
+    }
+    nodeNativeContext(nodeIndex) {
+        const ordinal = nodeIndex / this.nodeFieldCount;
+        const nativeContextOrdinal = this.nodeNativeContextAttribution[ordinal];
+        if (nativeContextOrdinal < 0) {
+            return nativeContextOrdinal;
+        }
+        return nativeContextOrdinal * this.nodeFieldCount;
+    }
+    isNativeContext(nodeOrdinal) {
+        const nameIdx = this.nodes.getValue(nodeOrdinal * this.nodeFieldCount + this.nodeNameOffset);
+        const name = this.strings[nameIdx];
+        return name === 'system / NativeContext' || name.startsWith('system / NativeContext / ') ||
+            name === 'Detached system / NativeContext' || name.startsWith('Detached system / NativeContext / ');
+    }
     interfaceDefinitions() {
         return JSON.stringify(this.#interfaceDefinitions ?? []);
     }
@@ -8114,11 +8461,32 @@ class HeapSnapshot {
         }
         return null;
     }
+    initDetachednessAndClassIndex() {
+        this.detachednessAndClassIndexArray = new Uint32Array(this.nodeCount);
+        if (this.nodeDetachednessAndClassIndexOffset !== -1) {
+            const { nodeFieldCount, nodeDetachednessAndClassIndexOffset: offset } = this;
+            for (let i = 0; i < this.nodeCount; ++i) {
+                this.detachednessAndClassIndexArray[i] = Number(this.nodes.getValue(i * nodeFieldCount + offset));
+            }
+        }
+        else {
+            const node = this.rootNode();
+            const nodesLength = this.nodes.length;
+            const { nodeFieldCount, nodeNativeType, nodeTypeOffset } = this;
+            for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
+                if (this.nodes.getValue(nodeIndex + nodeTypeOffset) === nodeNativeType) {
+                    node.nodeIndex = nodeIndex;
+                    if (node.name().startsWith('Detached ')) {
+                        node.setDetachedness(2 );
+                    }
+                }
+            }
+        }
+    }
     propagateDOMState() {
         if (this.nodeDetachednessAndClassIndexOffset === -1) {
             return;
         }
-        console.time('propagateDOMState');
         const visited = new Uint8Array(this.nodeCount);
         const attached = [];
         const detached = [];
@@ -8177,7 +8545,6 @@ class HeapSnapshot {
             }
             propagateState(this, nodeOrdinal, 2 );
         }
-        console.timeEnd('propagateDOMState');
     }
     buildSamples() {
         const samples = this.#rawSamples;
@@ -8282,6 +8649,8 @@ class HeapSnapshot {
             const nodeAId = baseIds[i];
             if (nodeAId < nodeB.id()) {
                 diff.deletedIndexes.push(baseIndexes[i]);
+                diff.deletedIds.push(nodeAId);
+                diff.deletedSelfSizes.push(baseSelfSizes[i]);
                 diff.removedCount++;
                 diff.removedSize += baseSelfSizes[i];
                 ++i;
@@ -8289,6 +8658,8 @@ class HeapSnapshot {
             else if (nodeAId >
                 nodeB.id()) {
                 diff.addedIndexes.push(indexes[j]);
+                diff.addedIds.push(nodeB.id());
+                diff.addedSelfSizes.push(nodeB.selfSize());
                 diff.addedCount++;
                 diff.addedSize += nodeB.selfSize();
                 nodeB.nodeIndex = indexes[++j];
@@ -8300,12 +8671,16 @@ class HeapSnapshot {
         }
         while (i < l) {
             diff.deletedIndexes.push(baseIndexes[i]);
+            diff.deletedIds.push(baseIds[i]);
+            diff.deletedSelfSizes.push(baseSelfSizes[i]);
             diff.removedCount++;
             diff.removedSize += baseSelfSizes[i];
             ++i;
         }
         while (j < m) {
             diff.addedIndexes.push(indexes[j]);
+            diff.addedIds.push(nodeB.id());
+            diff.addedSelfSizes.push(nodeB.selfSize());
             diff.addedCount++;
             diff.addedSize += nodeB.selfSize();
             nodeB.nodeIndex = indexes[++j];
@@ -8335,11 +8710,54 @@ class HeapSnapshot {
         }
         return null;
     }
-    createEdgesProvider(nodeIndex) {
+    createEdgesProvider(nodeIndex, options) {
         const node = this.createNode(nodeIndex);
-        const filter = this.containmentEdgesFilter();
+        const defaultFilter = this.containmentEdgesFilter();
+        const minRetainedSize = options?.minRetainedSize;
+        const excludePrimitives = options?.excludePrimitives ?? false;
+        let filter = defaultFilter;
+        if (minRetainedSize !== undefined || excludePrimitives) {
+            filter = (edge) => {
+                if (defaultFilter && !defaultFilter(edge)) {
+                    return false;
+                }
+                const targetNode = edge.node();
+                if (minRetainedSize !== undefined && targetNode.retainedSize() < minRetainedSize) {
+                    return false;
+                }
+                if (excludePrimitives) {
+                    const rawType = targetNode.rawType();
+                    if (rawType === this.nodeNumberType) {
+                        return false;
+                    }
+                    if (rawType === this.nodeNativeType) {
+                        const targetName = targetNode.rawName();
+                        if (targetName === 'undefined' || targetName === 'null' || targetName === 'true' ||
+                            targetName === 'false') {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            };
+        }
         const indexProvider = new HeapSnapshotEdgeIndexProvider(this);
-        return new HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
+        const provider = new HeapSnapshotEdgesProvider(this, filter, node.edges(), indexProvider);
+        if (options?.sortBy) {
+            const sortBy = options.sortBy;
+            let comparator;
+            if (sortBy === 'selfSize') {
+                comparator = new ComparatorConfig('selfSize', false, '!edgeName', true);
+            }
+            else if (sortBy === 'name') {
+                comparator = new ComparatorConfig('!edgeName', true, 'retainedSize', false);
+            }
+            else {
+                comparator = new ComparatorConfig('retainedSize', false, '!edgeName', true);
+            }
+            provider.sortAndRewind(comparator);
+        }
+        return provider;
     }
     createEdgesProviderForTest(nodeIndex, filter) {
         const node = this.createNode(nodeIndex);
@@ -8358,6 +8776,133 @@ class HeapSnapshot {
         const indexProvider = new HeapSnapshotRetainerEdgeIndexProvider(this);
         return new HeapSnapshotEdgesProvider(this, filter, node.retainers(), indexProvider);
     }
+    getRetainingPaths(nodeIndex, maxDepth = 30, maxNodes = 5000, maxSiblings = 100) {
+        const { nodeFieldCount, firstRetainerIndex, retainingNodes, retainingEdges, edgeTypeOffset, edgeWeakType, containmentEdges, } = this;
+        const distances = this.#nodeDistancesForRetainersView ?? this.nodeDistances;
+        let traversedNodesCount = 0;
+        const visiting = new Set();
+        const visited = new Map();
+        const rootDistance = 2;
+        const limitsReached = {};
+        const buildForest = (currentIndex, currentDepth) => {
+            traversedNodesCount++;
+            if (traversedNodesCount > maxNodes) {
+                limitsReached.nodes = true;
+                return [];
+            }
+            if (currentDepth >= maxDepth) {
+                limitsReached.depth = true;
+                return [];
+            }
+            const ordinal = currentIndex / nodeFieldCount;
+            const currentDistance = distances[ordinal];
+            if (currentDistance <= rootDistance) {
+                return [];
+            }
+            if (visiting.has(currentIndex)) {
+                return [];
+            }
+            const cachedDepth = visited.get(currentIndex);
+            if (cachedDepth !== undefined) {
+                if (currentDepth >= cachedDepth) {
+                    return [];
+                }
+            }
+            visiting.add(currentIndex);
+            const beginRetainerIndex = firstRetainerIndex[ordinal];
+            const endRetainerIndex = firstRetainerIndex[ordinal + 1];
+            const retainers = [];
+            for (let retainerIndex = beginRetainerIndex; retainerIndex < endRetainerIndex; ++retainerIndex) {
+                const retainerNodeIndex = retainingNodes[retainerIndex];
+                const retainerNodeOrdinal = retainerNodeIndex / nodeFieldCount;
+                const dist = distances[retainerNodeOrdinal];
+                const globalEdgeIndex = retainingEdges[retainerIndex];
+                if (this.isEdgeIgnoredInRetainersView(globalEdgeIndex)) {
+                    continue;
+                }
+                const edgeType = containmentEdges.getValue(globalEdgeIndex + edgeTypeOffset);
+                if (edgeType === edgeWeakType) {
+                    continue;
+                }
+                if (dist >= 0) {
+                    const remainingDepth = maxDepth - currentDepth;
+                    const neededDepth = dist - rootDistance;
+                    if (neededDepth < remainingDepth) {
+                        retainers.push({ retainerIndex, dist, nodeIndex: retainerNodeIndex });
+                    }
+                    else {
+                        limitsReached.depth = true;
+                    }
+                }
+            }
+            retainers.sort((a, b) => a.dist - b.dist);
+            const length = Math.min(retainers.length, maxSiblings);
+            if (retainers.length > maxSiblings) {
+                limitsReached.siblings = true;
+            }
+            const forest = [];
+            for (let i = 0; i < length; i++) {
+                const retainer = retainers[i];
+                const edge = this.createRetainingEdge(retainer.retainerIndex);
+                const globalEdgeIndex = retainingEdges[retainer.retainerIndex];
+                const isRoot = retainer.dist === rootDistance;
+                let children = [];
+                if (isRoot) {
+                    traversedNodesCount++;
+                    if (traversedNodesCount > maxNodes) {
+                        limitsReached.nodes = true;
+                        break;
+                    }
+                }
+                else {
+                    children = buildForest(retainer.nodeIndex, currentDepth + 1);
+                    if (children.length === 0) {
+                        continue;
+                    }
+                }
+                const retainerNode = this.createNode(retainer.nodeIndex);
+                forest.push({
+                    edgeIndex: globalEdgeIndex,
+                    edgeName: edge.name(),
+                    edgeType: edge.type(),
+                    nodeId: retainerNode.id(),
+                    nodeIndex: retainer.nodeIndex,
+                    nodeName: retainerNode.name(),
+                    distance: retainer.dist,
+                    children,
+                });
+            }
+            visiting.delete(currentIndex);
+            visited.set(currentIndex, currentDepth);
+            return forest;
+        };
+        const paths = buildForest(nodeIndex, 0);
+        return { paths, limitsReached };
+    }
+    getDominatorsOf(nodeIndex) {
+        const chain = [];
+        let currentIndex = nodeIndex;
+        const rootIndex = this.rootNodeIndex;
+        while (currentIndex !== undefined) {
+            const node = this.createNode(currentIndex);
+            chain.push({
+                nodeId: node.id(),
+                nodeIndex: currentIndex,
+                nodeName: node.name(),
+                retainedSize: node.retainedSize(),
+                selfSize: node.selfSize(),
+            });
+            if (currentIndex === rootIndex) {
+                break;
+            }
+            const nextIndex = node.dominatorIndex();
+            if (nextIndex === currentIndex) {
+                break;
+            }
+            currentIndex = nextIndex;
+        }
+        return chain;
+    }
     createAddedNodesProvider(baseSnapshotId, classKey) {
         const snapshotDiff = this.#snapshotDiffs[baseSnapshotId];
         const diffForClass = snapshotDiff[classKey];
@@ -8369,6 +8914,85 @@ class HeapSnapshot {
     createNodesProviderForClass(classKey, nodeFilter) {
         return new HeapSnapshotNodesProvider(this, this.aggregatesWithFilter(nodeFilter)[classKey].idxs);
     }
+    queryObjects(queryOptions) {
+        const { nodes, nodeFieldCount, retainedSizes } = this;
+        const nodesLength = nodes.length;
+        const matchingIndexes = [];
+        const classNamePattern = queryOptions.className ? new RegExp(queryOptions.className, 'i') : null;
+        const propertyNamePattern = queryOptions.propertyName ? new RegExp(queryOptions.propertyName, 'i') : null;
+        const targetNodeType = queryOptions.nodeType ? queryOptions.nodeType.toLowerCase() : null;
+        const node = this.rootNode();
+        for (let nodeIndex = 0, ordinal = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount, ordinal++) {
+            node.nodeIndex = nodeIndex;
+            if (queryOptions.minSelfSize !== undefined && node.selfSize() < queryOptions.minSelfSize) {
+                continue;
+            }
+            if (queryOptions.maxSelfSize !== undefined && node.selfSize() > queryOptions.maxSelfSize) {
+                continue;
+            }
+            const retainedSize = retainedSizes[ordinal];
+            if (queryOptions.minRetainedSize !== undefined && retainedSize < queryOptions.minRetainedSize) {
+                continue;
+            }
+            if (queryOptions.maxRetainedSize !== undefined && retainedSize > queryOptions.maxRetainedSize) {
+                continue;
+            }
+            if (queryOptions.isDetached !== undefined) {
+                const isDetached = node.detachedness() === 2 ;
+                if (isDetached !== queryOptions.isDetached) {
+                    continue;
+                }
+            }
+            if (classNamePattern) {
+                const name = node.name();
+                if (!classNamePattern.test(name)) {
+                    continue;
+                }
+            }
+            if (targetNodeType) {
+                const typeStr = node.type();
+                if (typeStr.toLowerCase() !== targetNodeType) {
+                    continue;
+                }
+            }
+            if (propertyNamePattern) {
+                let propMatch = false;
+                for (const iter = node.edges(); iter.hasNext(); iter.next()) {
+                    if (propertyNamePattern.test(iter.edge.name())) {
+                        propMatch = true;
+                        break;
+                    }
+                }
+                if (!propMatch) {
+                    continue;
+                }
+            }
+            matchingIndexes.push(nodeIndex);
+        }
+        const sortBy = queryOptions.sortBy ?? 'retainedSize';
+        if (sortBy === 'retainedSize') {
+            matchingIndexes.sort((a, b) => retainedSizes[b / nodeFieldCount] - retainedSizes[a / nodeFieldCount]);
+        }
+        else if (sortBy === 'selfSize') {
+            matchingIndexes.sort((a, b) => {
+                node.nodeIndex = b;
+                const sizeB = node.selfSize();
+                node.nodeIndex = a;
+                const sizeA = node.selfSize();
+                return sizeB - sizeA;
+            });
+        }
+        else if (sortBy === 'id') {
+            matchingIndexes.sort((a, b) => {
+                node.nodeIndex = b;
+                const idB = node.id();
+                node.nodeIndex = a;
+                const idA = node.id();
+                return idA - idB;
+            });
+        }
+        return new HeapSnapshotNodesProvider(this, matchingIndexes);
+    }
     maxJsNodeId() {
         const nodeFieldCount = this.nodeFieldCount;
         const nodes = this.nodes;
@@ -8852,6 +9476,10 @@ class JSHeapSnapshot extends HeapSnapshot {
     isUserRoot(node) {
         return node.isUserRoot() || node.isDocumentDOMTreesRoot();
     }
+    isContextObject(node) {
+        const name = node.rawName();
+        return name === 'system / Context' || name.startsWith('system / Context / ');
+    }
     userObjectsMapAndFlag() {
         return { map: this.flags, flag: this.nodeFlags.pageObject };
     }
@@ -8872,7 +9500,7 @@ class JSHeapSnapshot extends HeapSnapshot {
                 continue;
             }
             node.nodeIndex = nodeIndex;
-            if (node.name().startsWith('Detached ')) {
+            if (node.detachedness() === 2 ) {
                 this.flags[ordinal] |= flag;
             }
         }
@@ -9026,7 +9654,7 @@ class JSHeapSnapshot extends HeapSnapshot {
                 jsArrays: sizeJSArrays,
                 strings: sizeStrings,
                 system: sizeSystem,
-            }
+            },
         };
     }
     calculateArraySize(node) {
@@ -9708,4 +10336,3 @@ class HeapSnapshotWorkerDispatcher {
 const dispatcher = new HeapSnapshotWorkerDispatcher(HOST_RUNTIME.workerScope.postMessage.bind(HOST_RUNTIME.workerScope));
 HOST_RUNTIME.workerScope.onmessage = dispatcher.dispatchMessage.bind(dispatcher);
 HOST_RUNTIME.workerScope.postMessage('workerReady');
-//# sourceMappingURL=devtools-heap-snapshot-worker.js.map