@memlab/core 1.1.6 → 1.1.10

package/dist/lib/Utils.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -136,10 +136,10 @@ function isDetachedFiberNode(node) {
 // any detached DOM nodes (e.g., HTMLXXElement, IntersectionObserver etc.)
 // that are not internal nodes.
 function isDetachedDOMNode(node, args = {}) {
-    if (!node || typeof node.name !== 'string') {
+    let name = null;
+    if (!node || typeof (name = node.name) !== 'string') {
         return false;
     }
-    const name = node.name;
     if (isFiberNode(node)) {
         return false;
     }
@@ -212,14 +212,28 @@ function isPendingActivityNode(node) {
     }
     return node.type === 'synthetic' && node.name === 'Pending activities';
 }
+// check the node against a curated list of known HTML Elements
+// the list may be incomplete
+function isDOMNodeIncomplete(node) {
+    let name = node.name;
+    const pattern = /^HTML.*Element$/;
+    const detachedPrefix = 'Detached ';
+    if (name.startsWith(detachedPrefix)) {
+        name = name.substring(detachedPrefix.length);
+    }
+    return pattern.test(name);
+}
 function isRootNode(node, opt = {}) {
-    if (!node || !node.name) {
+    if (!node) {
         return false;
     }
     // consider Hermes snapshot GC roots
     if (Config_1.default.jsEngine === 'hermes') {
         return node.name === '(GC roots)' || node.name === '(GC Roots)';
     }
+    if (node.id === 0 || node.id === 1) {
+        return true;
+    }
     // the window object
     if (node.type === 'native' && node.name.indexOf('Window') === 0) {
         return true;
@@ -355,14 +369,16 @@ function getNodesIdSet(snapshot) {
     });
     return set;
 }
-// given a set of nodes S, return a subset S' where
+// given a set of nodes S, return a minimal subset S' where
 // no nodes are dominated by nodes in S
 function getConditionalDominatorIds(ids, snapshot, condCb) {
     const dominatorIds = new Set();
+    const fullDominatorIds = new Set();
     // set all node ids
     applyToNodes(ids, snapshot, node => {
         if (condCb(node)) {
             dominatorIds.add(node.id);
+            fullDominatorIds.add(node.id);
         }
     });
     // traverse the dominators and remove the node
@@ -374,7 +390,7 @@ function getConditionalDominatorIds(ids, snapshot, condCb) {
             if (visited.has(cur.id)) {
                 break;
             }
-            if (dominatorIds.has(cur.id)) {
+            if (fullDominatorIds.has(cur.id)) {
                 dominatorIds.delete(node.id);
                 break;
             }
@@ -390,7 +406,6 @@ function setFiberNodeAttribute(node, flag) {
     if (!node || !isFiberNode(node)) {
         return;
     }
-    // eslint-disable-next-line no-bitwise
     node.attributes |= flag;
 }
 function hasFiberNodeAttribute(node, flag) {
@@ -447,7 +462,6 @@ function filterNodesInPlace(idSet, snapshot, cb) {
 function applyToNodes(idSet, snapshot, cb, options = {}) {
     let ids = Array.from(idSet.keys());
     if (options.shuffle) {
-        // eslint-disable-next-line fb-www/unsafe-math-random
         ids.sort(() => Math.random() - 0.5);
     }
     else if (options.reverse) {
@@ -508,7 +522,6 @@ function loadScenario(filename) {
     }
     let scenario;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         scenario = require(filepath);
         scenario = checkScenarioInstance(scenario);
         if (scenario.name == null) {
@@ -534,6 +547,12 @@ function handleSnapshotError(e) {
 }
 function getSnapshotFromFile(filename, options) {
     return __awaiter(this, void 0, void 0, function* () {
+        const heapConfig = Config_1.default.heapConfig;
+        if (heapConfig &&
+            heapConfig.currentHeapFile === filename &&
+            heapConfig.currentHeap) {
+            return heapConfig.currentHeap;
+        }
         Console_1.default.overwrite('parsing ' + filename + ' ...');
         let ret = null;
         try {
@@ -812,7 +831,6 @@ function loadRunMetaInfo(metaFile = undefined) {
     try {
         const content = fs_1.default.readFileSync(file, 'UTF-8');
         return JSON.parse(content);
-        // eslint-disable-next-line fb-www/no-unused-catch-bindings
     }
     catch (_) {
         throw haltOrThrow('Run info missing. Please make sure `memlab run` is complete.');
@@ -1271,9 +1289,23 @@ function getSnapshotDirForAnalysis() {
     return dir;
 }
 function getSingleSnapshotFileForAnalysis() {
-    const path = Config_1.default.useExternalSnapshot && Config_1.default.externalSnapshotFilePaths[0]
-        ? Config_1.default.externalSnapshotFilePaths[0]
-        : getSnapshotFilePathWithTabType(/(final)|(target)|(baseline)/);
+    let path = null;
+    // if an external snapshot file is specified
+    if (Config_1.default.useExternalSnapshot &&
+        Config_1.default.externalSnapshotFilePaths.length > 0) {
+        path =
+            Config_1.default.externalSnapshotFilePaths[Config_1.default.externalSnapshotFilePaths.length - 1];
+        // if running in interactive heap analysis mode
+    }
+    else if (Config_1.default.heapConfig &&
+        Config_1.default.heapConfig.isCliInteractiveMode &&
+        Config_1.default.heapConfig.currentHeapFile) {
+        path = Config_1.default.heapConfig.currentHeapFile;
+        // search for snapshot labeled as baseline, target, or final
+    }
+    else {
+        path = getSnapshotFilePathWithTabType(/(final)|(target)|(baseline)/);
+    }
     return resolveSnapshotFilePath(path);
 }
 function getSnapshotFilePath(tab) {
@@ -1286,7 +1318,7 @@ function getSnapshotFilePath(tab) {
     }
     return Config_1.default.externalSnapshotFilePaths[tab.idx - 1];
 }
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function equalOrMatch(v1, v2) {
     const t1 = typeof v1;
     const t2 = typeof v2;
@@ -1319,7 +1351,8 @@ function isMeaningfulNode(node) {
     if (!node) {
         return false;
     }
-    if (Config_1.default.nodeNameBlockList.has(node.name)) {
+    const nodeName = node.name;
+    if (Config_1.default.nodeNameBlockList.has(nodeName)) {
         return false;
     }
     if (isFiberNode(node)) {
@@ -1330,13 +1363,13 @@ function isMeaningfulNode(node) {
     }
     // More details in https://github.com/ChromeDevTools/devtools-frontend
     // under front_end/heap_snapshot_worker/HeapSnapshot.ts
-    if (node.name === 'system / NativeContext') {
+    if (nodeName === 'system / NativeContext') {
         return false;
     }
-    if (node.name === 'system / SourcePositionTableWithFrameCache') {
+    if (nodeName === 'system / SourcePositionTableWithFrameCache') {
         return false;
     }
-    if (node.name === '(map descriptors)') {
+    if (nodeName === '(map descriptors)') {
         return false;
     }
     if (node.type === 'code') {
@@ -1351,44 +1384,49 @@ function isMeaningfulEdge(edge, options = {}) {
     if (source.id === node.id) {
         return false;
     }
-    if (typeof edge.name_or_index === 'string' &&
-        Config_1.default.edgeNameBlockList.has(edge.name_or_index)) {
+    const edgeNameOrIndex = edge.name_or_index;
+    if (typeof edgeNameOrIndex === 'string' &&
+        Config_1.default.edgeNameBlockList.has(edgeNameOrIndex)) {
         return false;
     }
+    const edgeType = edge.type;
     // shortcut edge may be meaningful edges
     // --forceUpdate (variable)--->  [native_bind]
     // --bound_argument_0 (shortcut)--->  [FiberNode]
-    if (edge.type === 'weak' /* || edge.type === 'shortcut' */) {
+    if (edgeType === 'weak' /* || edge.type === 'shortcut' */) {
         return false;
     }
     if (options.excludeWeakMapEdge && isWeakMapEdgeToKey(edge)) {
         return false;
     }
-    if (options.visited && options.visited[node.nodeIndex]) {
+    const nodeIndex = node.nodeIndex;
+    if (options.visited && options.visited[nodeIndex]) {
         return false;
     }
-    if (options.queued && options.queued[node.nodeIndex]) {
+    if (options.queued && options.queued[nodeIndex]) {
         return false;
     }
-    if (!options.includeString && node.type === 'string') {
+    const nodeType = node.type;
+    if (!options.includeString && nodeType === 'string') {
         return false;
     }
-    if (edge.type === 'internal' && edge.name_or_index === 'code') {
+    if (edgeType === 'internal' && edgeNameOrIndex === 'code') {
         return false;
     }
     // More details about the following three special cases are available
     // in https://github.com/ChromeDevTools/devtools-frontend
     // under front_end/heap_snapshot_worker/HeapSnapshot.ts
-    if (edge.type === 'hidden' && edge.name_or_index === 'sloppy_function_map') {
+    if (edgeType === 'hidden' && edgeNameOrIndex === 'sloppy_function_map') {
         return false;
     }
-    if (edge.type === 'hidden' && node.name === 'system / NativeContext') {
+    const nodeName = node.name;
+    if (edgeType === 'hidden' && nodeName === 'system / NativeContext') {
         return false;
     }
     // In v8, (map descriptors) are fixed-length descriptors arrays used
     // to hold JS descriptors.
-    if (node.type === 'array' && node.name === '(map descriptors)') {
-        const index = edge.name_or_index;
+    if (edgeType === 'array' && nodeName === '(map descriptors)') {
+        const index = edgeNameOrIndex;
         // only elements at particular indexes of (map descriptors) are holding
         // representative references to objects.
         if (index >= 2 || (typeof index === 'number' && index % 3 === 1)) {
@@ -1401,12 +1439,12 @@ function isMeaningfulEdge(edge, options = {}) {
     if (Config_1.default.jsEngine === 'hermes' && isDirectPropEdge(edge)) {
         return false;
     }
-    if (Config_1.default.ignoreInternalNode && node.name.includes('InternalNode')) {
+    if (Config_1.default.ignoreInternalNode && nodeName.includes('InternalNode')) {
         return false;
     }
     if (Config_1.default.ignoreDevToolsConsoleLeak) {
-        const name = edge.name_or_index;
-        if (typeof name === 'string' && name.includes('DevTools console')) {
+        if (typeof edgeNameOrIndex === 'string' &&
+            edgeNameOrIndex.includes('DevTools console')) {
             return false;
         }
     }
@@ -1421,7 +1459,6 @@ function isURLEqual(url1, url2) {
     try {
         u1 = new URL(url1);
         u2 = new URL(url2);
-        // eslint-disable-next-line fb-www/no-unused-catch-bindings
     }
     catch (_e) {
         return false;
@@ -1709,6 +1746,7 @@ exports.default = {
     isDetachedDOMNode,
     isDirectPropEdge,
     isDocumentDOMTreesRoot,
+    isDOMNodeIncomplete,
     isEssentialEdge,
     isFiberNode,
     isFiberNodeDeletionsEdge,

package/dist/lib/heap-data/HeapEdge.d.ts

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 import type { IHeapEdge } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';

package/dist/lib/heap-data/HeapEdge.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 var __importDefault = (this && this.__importDefault) || function (mod) {

package/dist/lib/heap-data/HeapLocation.d.ts

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 import type { IHeapLocation } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';

package/dist/lib/heap-data/HeapLocation.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/heap-data/HeapNode.d.ts

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
@@ -36,6 +36,7 @@ export default class HeapNode implements IHeapNode {
     findReferrers(predicate: Predicator<IHeapEdge>): IHeapEdge[];
     get referrers(): HeapEdge[];
     forEachReferrer(callback: EdgeIterationCallback): void;
+    get hasPathEdge(): boolean;
     get pathEdge(): Nullable<HeapEdge>;
     set pathEdge(edge: Nullable<HeapEdge>);
     get nodeIndex(): number;

package/dist/lib/heap-data/HeapNode.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -189,6 +189,10 @@ class HeapNode {
             }
         }
     }
+    get hasPathEdge() {
+        const heapSnapshot = this.heapSnapshot;
+        return heapSnapshot._nodeIdxHasPathEdge[this.idx] !== 0;
+    }
     get pathEdge() {
         const heapSnapshot = this.heapSnapshot;
         if (heapSnapshot._nodeIdxHasPathEdge[this.idx] === 0) {

package/dist/lib/heap-data/HeapSnapshot.d.ts

@@ -4,14 +4,15 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 import type { IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
 import HeapNode from './HeapNode';
 export default class HeapSnapshot implements IHeapSnapshot {
     snapshot: RawHeapSnapshot;
+    isProcessed: boolean;
     nodes: IHeapNodes;
     _nodeCount: number;
     edges: IHeapEdges;

package/dist/lib/heap-data/HeapSnapshot.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -18,11 +18,13 @@ const Console_1 = __importDefault(require("../Console"));
 const HeapNode_1 = __importDefault(require("./HeapNode"));
 const HeapEdge_1 = __importDefault(require("./HeapEdge"));
 const HeapUtils_1 = require("./HeapUtils");
+const MemLabTagStore_1 = __importDefault(require("./MemLabTagStore"));
 const EMPTY_UINT8_ARRAY = new Uint8Array(0);
 const EMPTY_UINT32_ARRAY = new Uint32Array(0);
 class HeapSnapshot {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     constructor(snapshot, _options = {}) {
+        this.isProcessed = false;
         this._nodeCount = -1;
         this._edgeCount = -1;
         this._nodeId2NodeIdx = {};
@@ -98,7 +100,7 @@ class HeapSnapshot {
             forEachTraceable(cb) {
                 for (let i = 0; i < this.length; i++) {
                     const node = this.get(i);
-                    if (!node.pathEdge) {
+                    if (!node.hasPathEdge) {
                         continue;
                     }
                     const ret = cb(node, i);
@@ -158,36 +160,7 @@ class HeapSnapshot {
         return detected;
     }
     hasObjectWithTag(tag) {
-        // get tagStore
-        let tagStore = null;
-        this.nodes.forEach((node) => {
-            if (node.name === 'MemLabTaggedStore' && node.type === 'object') {
-                tagStore = node;
-                return false;
-            }
-        });
-        if (tagStore == null) {
-            return false;
-        }
-        const store = tagStore;
-        // get tagStore.taggedObjects
-        const taggedObjects = store.getReferenceNode('taggedObjects', 'property');
-        if (taggedObjects == null) {
-            return false;
-        }
-        // get taggedObjects[tag]
-        const weakSet = taggedObjects.getReferenceNode(tag, 'property');
-        if (weakSet == null) {
-            return false;
-        }
-        // get weakSet.table
-        const table = weakSet.getReferenceNode('table');
-        if (table == null) {
-            return false;
-        }
-        // check if the table has any weak reference to any object
-        const ref = table.findAnyReference((edge) => edge.type === 'weak' && edge.toNode.name !== 'system / Oddball');
-        return ref != null;
+        return MemLabTagStore_1.default.hasObjectWithTag(this, tag);
     }
     getNodeById(id) {
         if (!(id in this._nodeId2NodeIdx)) {

package/dist/lib/heap-data/HeapStringNode.d.ts

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 import type { IHeapStringNode } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';

package/dist/lib/heap-data/HeapStringNode.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -35,6 +35,8 @@ class HeapStringNode extends HeapNode_1.default {
             if (parentNode == null) {
                 throw (0, HeapUtils_1.throwError)(new Error('broken sliced string'));
             }
+            // sliced string in heap snapshot doesn't include
+            // the start index and the end index, so this may be inaccurate
             return parentNode.stringValue;
         }
         return this.name;

package/dist/lib/heap-data/HeapUtils.d.ts

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 export declare const NodeDetachState: {
     Unknown: number;

package/dist/lib/heap-data/HeapUtils.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/heap-data/MemLabTagStore.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall ws_labs
+ */
+import type { AnyValue, IHeapSnapshot } from '../Types';
+declare type AnyObject = Record<AnyValue, AnyValue>;
+/** @internal */
+export default class MemLabTaggedStore {
+    taggedObjects: Record<string, WeakSet<AnyObject>>;
+    private constructor();
+    private static instance;
+    readonly id: string;
+    static getInstance(): MemLabTaggedStore;
+    static tagObject<T extends object>(o: T, tag: string): void;
+    static hasObjectWithTag(heap: IHeapSnapshot, tag: string): boolean;
+}
+export {};
+//# sourceMappingURL=MemLabTagStore.d.ts.map

package/dist/lib/heap-data/MemLabTagStore.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall ws_labs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("../..");
+let uindex = 1;
+function getUniqueID() {
+    const randId = `${Math.random()}`;
+    return `${process.pid}-${Date.now()}-${randId}-${uindex++}`;
+}
+/** @internal */
+class MemLabTaggedStore {
+    constructor() {
+        this.id = getUniqueID();
+        this.taggedObjects = Object.create(null);
+    }
+    // make sure it's a singleton
+    static getInstance() {
+        if (!MemLabTaggedStore.instance) {
+            MemLabTaggedStore.instance = new MemLabTaggedStore();
+        }
+        return MemLabTaggedStore.instance;
+    }
+    // tag an object with a mark
+    static tagObject(o, tag) {
+        const store = MemLabTaggedStore.getInstance();
+        if (!store.taggedObjects[tag]) {
+            store.taggedObjects[tag] = new WeakSet();
+        }
+        store.taggedObjects[tag].add(o);
+    }
+    // check if any object in the heap snapshot has the mark
+    // tagged by this MemLabTaggedStore in this execution context
+    static hasObjectWithTag(heap, tag) {
+        const curContextTagStoreID = MemLabTaggedStore.getInstance().id;
+        let tagStore = null;
+        // get all MemLabTaggedStore instances in the heap snapshot
+        const stores = [];
+        heap.nodes.forEach((node) => {
+            if (node.name === 'MemLabTaggedStore' && node.type === 'object') {
+                stores.push(node);
+            }
+        });
+        // if no tag store found
+        if (stores.length === 0) {
+            return false;
+            // if there is only one store found
+        }
+        else if (stores.length === 1) {
+            tagStore = stores[0];
+            // if there are multiple MemLabTagStore instances
+            // found in the heap snapshot
+        }
+        else if (stores.length > 1) {
+            stores.forEach((node) => {
+                // in case multiple instances of MemLabTaggedStore exists
+                // in the heap snapshot, we need to make sure that the
+                // tag store is the one matching the current execution context
+                let storeID = '';
+                // match tag store id
+                node.forEachReference(edge => {
+                    var _a, _b;
+                    if (edge.name_or_index === 'id' && edge.toNode.isString) {
+                        storeID = (_b = (_a = edge.toNode.toStringNode()) === null || _a === void 0 ? void 0 : _a.stringValue) !== null && _b !== void 0 ? _b : '';
+                        return { stop: true };
+                    }
+                });
+                if (curContextTagStoreID === storeID) {
+                    tagStore = node;
+                }
+            });
+            if (tagStore == null) {
+                throw __1.utils.haltOrThrow('Multiple MemLabTagStore instances found in heap snapshot ' +
+                    'when checking object tags, please make sure only one memlab ' +
+                    'instance is running at a time and double check that memlab is ' +
+                    'not running in Jest concurrent mode.');
+            }
+        }
+        if (tagStore == null) {
+            return false;
+        }
+        const store = tagStore;
+        // get tagStore.taggedObjects
+        const taggedObjects = store.getReferenceNode('taggedObjects', 'property');
+        if (taggedObjects == null) {
+            return false;
+        }
+        // get taggedObjects[tag]
+        const weakSet = taggedObjects.getReferenceNode(tag, 'property');
+        if (weakSet == null) {
+            return false;
+        }
+        // get weakSet.table
+        const table = weakSet.getReferenceNode('table');
+        if (table == null) {
+            return false;
+        }
+        // check if the table has any weak reference to any object
+        const ref = table.findAnyReference((edge) => edge.type === 'weak' && edge.toNode.name !== 'system / Oddball');
+        return ref != null;
+    }
+}
+exports.default = MemLabTaggedStore;

package/dist/lib/leak-filters/BaseLeakFilter.rule.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import type { MemLabConfig } from '../Config';
 import type { HeapNodeIdSet, IHeapNode, IHeapSnapshot } from '../Types';