@memlab/core 1.1.20 → 1.1.22

package/dist/lib/charts/MemoryBarChart.js

@@ -30,7 +30,7 @@ class MemoryBarChart {
             Console_1.default.warning(`plot data not load correctly: ${Utils_1.default.getError(ex).message}`);
             return;
         }
-        if (plotData.length === 0) {
+        if (!this.isPlotDataValid(plotData)) {
             if (Config_1.default.verbose) {
                 Console_1.default.warning('no memory usage data to plot');
             }
@@ -57,6 +57,21 @@ class MemoryBarChart {
         }));
         Console_1.default.topLevel('');
     }
+    isPlotDataValid(plotData) {
+        if (plotData.length === 0) {
+            return false;
+        }
+        let isEntryValueAllZero = true;
+        for (const entry of plotData) {
+            if (entry.length !== 2) {
+                return false;
+            }
+            if (entry[1] !== 0) {
+                isEntryValueAllZero = false;
+            }
+        }
+        return !isEntryValueAllZero;
+    }
     loadPlotDataFromTabsOrder(tabsOrder) {
         for (const tab of tabsOrder) {
             if (!(tab.JSHeapUsedSize > 0)) {
@@ -82,12 +97,12 @@ class MemoryBarChart {
     }
     loadPlotData(options = {}) {
         // plot data for a single run
-        if (!options.controlWorkDir && !options.treatmentWorkDir) {
+        if (!options.controlWorkDirs && !options.treatmentWorkDir) {
             return this.loadPlotDataFromWorkDir(options);
         }
         // plot data for control and test run
         const controlPlotData = this.loadPlotDataFromWorkDir({
-            workDir: options.controlWorkDir,
+            workDir: options.controlWorkDirs && options.controlWorkDirs[0],
         });
         const testPlotData = this.loadPlotDataFromWorkDir({
             workDir: options.treatmentWorkDir,

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

@@ -21,25 +21,34 @@ class HeapStringNode extends HeapNode_1.default {
     }
     get stringValue() {
         var _a, _b, _c;
-        const type = this.type;
-        if (type === 'concatenated string') {
-            const firstNode = (_a = this.getReferenceNode('first')) === null || _a === void 0 ? void 0 : _a.toStringNode();
-            const secondNode = (_b = this.getReferenceNode('second')) === null || _b === void 0 ? void 0 : _b.toStringNode();
-            if (firstNode == null || secondNode == null) {
-                throw (0, HeapUtils_1.throwError)(new Error('broken concatenated string'));
+        const stack = [this];
+        let ret = '';
+        while (stack.length > 0) {
+            const node = stack.pop();
+            const type = node.type;
+            if (type === 'concatenated string') {
+                const firstNode = (_a = node.getReferenceNode('first')) === null || _a === void 0 ? void 0 : _a.toStringNode();
+                const secondNode = (_b = node.getReferenceNode('second')) === null || _b === void 0 ? void 0 : _b.toStringNode();
+                if (firstNode == null || secondNode == null) {
+                    throw (0, HeapUtils_1.throwError)(new Error('broken concatenated string'));
+                }
+                stack.push(secondNode);
+                stack.push(firstNode);
+                continue;
             }
-            return firstNode.stringValue + secondNode.stringValue;
-        }
-        if (type === 'sliced string') {
-            const parentNode = (_c = this.getReferenceNode('parent')) === null || _c === void 0 ? void 0 : _c.toStringNode();
-            if (parentNode == null) {
-                throw (0, HeapUtils_1.throwError)(new Error('broken sliced string'));
+            if (type === 'sliced string') {
+                const parentNode = (_c = node.getReferenceNode('parent')) === null || _c === void 0 ? void 0 : _c.toStringNode();
+                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
+                ret += `<sliced string of @${parentNode.id}>`;
+                continue;
             }
-            // sliced string in heap snapshot doesn't include
-            // the start index and the end index, so this may be inaccurate
-            return parentNode.stringValue;
+            ret += node.name;
         }
-        return this.name;
+        return ret;
     }
     getJSONifyableObject() {
         const rep = super.getJSONifyableObject();

package/dist/lib/leak-filters/rules/FilterOverSizedNodeAsLeak.rule.js

@@ -8,8 +8,13 @@
  * @format
  * @oncall web_perf_infra
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterOverSizedNodeAsLeakRule = void 0;
+const Utils_1 = __importDefault(require("../../Utils"));
+const Config_1 = require("../../Config");
 const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
 /**
  * trivial nodes are not reported as memory leaks
@@ -17,6 +22,10 @@ const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
 class FilterOverSizedNodeAsLeakRule {
     filter(config, node) {
         if (config.oversizeObjectAsLeak) {
+            // TODO: add support to skip this check
+            if (!isHeapNodeUsefulForLeakTraceDiffing(config, node)) {
+                return BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
+            }
             return node.retainedSize > config.oversizeThreshold
                 ? BaseLeakFilter_rule_1.LeakDecision.LEAK
                 : BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
@@ -25,3 +34,44 @@ class FilterOverSizedNodeAsLeakRule {
     }
 }
 exports.FilterOverSizedNodeAsLeakRule = FilterOverSizedNodeAsLeakRule;
+function isHeapNodeUsefulForLeakTraceDiffing(config, node) {
+    if (config.traceAllObjectsMode === Config_1.TraceObjectMode.Default) {
+        return true;
+    }
+    const name = node.name;
+    if (node.type !== 'object') {
+        return false;
+    }
+    if (name.startsWith('system / ')) {
+        return false;
+    }
+    if (Utils_1.default.isFiberNode(node) && !Utils_1.default.isDetachedFiberNode(node)) {
+        return false;
+    }
+    if (Utils_1.default.isDOMNodeIncomplete(node) && !Utils_1.default.isDetachedDOMNode(node)) {
+        return false;
+    }
+    if (node.getAnyReferrer('__proto__') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('prototype') != null) {
+        return false;
+    }
+    // react internal objects
+    if (node.getAnyReferrer('dependencies') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('memoizedState') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('next') != null) {
+        return false;
+    }
+    if (node.getAnyReferrer('deps') != null) {
+        return false;
+    }
+    if (node.getReference('baseQueue') != null) {
+        return false;
+    }
+    return true;
+}

package/dist/lib/trace-filters/BaseTraceFilter.rule.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { MemLabConfig } from '../Config';
+import type { HeapNodeIdSet, IHeapSnapshot, LeakTracePathItem } from '../Types';
+/**
+ * Every leak trace filter rule needs to give a label
+ * to each leak trace passed to the filter
+ */
+export declare enum TraceDecision {
+    INSIGHTFUL = "insightful",
+    MAYBE_INSIGHTFUL = "maybe-insightful",
+    NOT_INSIGHTFUL = "not-insightful"
+}
+export declare type LeakTraceFilterOptions = {
+    config?: MemLabConfig;
+    snapshot?: IHeapSnapshot;
+    leakedNodeIds?: HeapNodeIdSet;
+};
+export interface ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=BaseTraceFilter.rule.d.ts.map

package/dist/lib/trace-filters/BaseTraceFilter.rule.js

@@ -0,0 +1,22 @@
+"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 web_perf_infra
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceDecision = void 0;
+/**
+ * Every leak trace filter rule needs to give a label
+ * to each leak trace passed to the filter
+ */
+var TraceDecision;
+(function (TraceDecision) {
+    TraceDecision["INSIGHTFUL"] = "insightful";
+    TraceDecision["MAYBE_INSIGHTFUL"] = "maybe-insightful";
+    TraceDecision["NOT_INSIGHTFUL"] = "not-insightful";
+})(TraceDecision = exports.TraceDecision || (exports.TraceDecision = {}));

package/dist/lib/trace-filters/LeakTraceFilter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../Types';
+import type { LeakTraceFilterOptions } from './BaseTraceFilter.rule';
+/**
+ * apply the leak trace filter rules chain and decide
+ * if a leak trace is useful for memory debugging,
+ * by default all leak traces are considered useful
+ */
+export declare class LeakTraceFilter {
+    filter(p: LeakTracePathItem, options: LeakTraceFilterOptions): boolean;
+}
+//# sourceMappingURL=LeakTraceFilter.d.ts.map

package/dist/lib/trace-filters/LeakTraceFilter.js

@@ -0,0 +1,37 @@
+"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 web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeakTraceFilter = void 0;
+const BaseTraceFilter_rule_1 = require("./BaseTraceFilter.rule");
+const TraceFilterRuleList_1 = __importDefault(require("./TraceFilterRuleList"));
+/**
+ * apply the leak trace filter rules chain and decide
+ * if a leak trace is useful for memory debugging,
+ * by default all leak traces are considered useful
+ */
+class LeakTraceFilter {
+    filter(p, options) {
+        for (const rule of TraceFilterRuleList_1.default) {
+            const decision = rule.filter(p, options);
+            if (decision === BaseTraceFilter_rule_1.TraceDecision.INSIGHTFUL) {
+                return true;
+            }
+            if (decision === BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.LeakTraceFilter = LeakTraceFilter;

package/dist/lib/trace-filters/TraceFilterRuleList.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 web_perf_infra
+ */
+import { ILeakTraceFilterRule } from './BaseTraceFilter.rule';
+declare const _default: ILeakTraceFilterRule[];
+export default _default;
+//# sourceMappingURL=TraceFilterRuleList.d.ts.map

package/dist/lib/trace-filters/TraceFilterRuleList.js

@@ -0,0 +1,35 @@
+"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 web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Constant_1 = __importDefault(require("../Constant"));
+const InternalValueSetter_1 = require("../InternalValueSetter");
+const FilterAttachedDOMToDetachedDOMTrace_rule_1 = require("./rules/FilterAttachedDOMToDetachedDOMTrace.rule");
+const FilterCppRootsToDetachedDOMTrace_rule_1 = require("./rules/FilterCppRootsToDetachedDOMTrace.rule");
+const FilterDOMNodeChainTrace_rule_1 = require("./rules/FilterDOMNodeChainTrace.rule");
+const FilterHermesTrace_rule_1 = require("./rules/FilterHermesTrace.rule");
+const FilterInternalNodeTrace_rule_1 = require("./rules/FilterInternalNodeTrace.rule");
+const FilterPendingActivitiesTrace_rule_1 = require("./rules/FilterPendingActivitiesTrace.rule");
+const FilterShadowRootTrace_rule_1 = require("./rules/FilterShadowRootTrace.rule");
+const FilterStyleEngineTrace_rule_1 = require("./rules/FilterStyleEngineTrace.rule");
+const list = [
+    new FilterHermesTrace_rule_1.FilterHermesTraceRule(),
+    new FilterInternalNodeTrace_rule_1.FilterInternalNodeTraceRule(),
+    new FilterShadowRootTrace_rule_1.FilterShadowRootTraceRule(),
+    new FilterStyleEngineTrace_rule_1.FilterStyleEngineTraceRule(),
+    new FilterPendingActivitiesTrace_rule_1.FilterPendingActivitiesTraceRule(),
+    new FilterDOMNodeChainTrace_rule_1.FilterDOMNodeChainTraceRule(),
+    new FilterAttachedDOMToDetachedDOMTrace_rule_1.FilterAttachedDOMToDetachedDOMTraceRule(),
+    new FilterCppRootsToDetachedDOMTrace_rule_1.FilterCppRootsToDetachedDOMTraceRule(),
+];
+exports.default = (0, InternalValueSetter_1.setInternalValue)(list, __filename, Constant_1.default.internalDir);

package/dist/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterAttachedDOMToDetachedDOMTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterAttachedDOMToDetachedDOMTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.js

@@ -0,0 +1,55 @@
+"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 web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterAttachedDOMToDetachedDOMTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterAttachedDOMToDetachedDOMTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path consists of only DOM native nodes/elements
+        if (curConfig.hideBrowserLeak && isAttachedDOMToDetachedDOMChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterAttachedDOMToDetachedDOMTraceRule = FilterAttachedDOMToDetachedDOMTraceRule;
+// check if the path has pattern:
+// [Attached Element] -> [InternalNode | Text]+ -> [Detached Element]
+function isAttachedDOMToDetachedDOMChain(path) {
+    if (!path) {
+        return false;
+    }
+    let p = path;
+    let hasEncounteredAttachedNode = false;
+    // skip the rest InternalNode
+    while (p != null && p.node) {
+        if (Utils_1.default.isDetachedDOMNode(p.node)) {
+            return hasEncounteredAttachedNode;
+        }
+        // else if this is an attached node
+        if (Utils_1.default.isDOMNodeIncomplete(p.node)) {
+            hasEncounteredAttachedNode = true;
+        }
+        else {
+            // else if this not a DOM element
+            hasEncounteredAttachedNode = false;
+        }
+        p = p.next;
+    }
+    return false;
+}

package/dist/lib/trace-filters/rules/FilterCppRootsToDetachedDOMTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterCppRootsToDetachedDOMTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterCppRootsToDetachedDOMTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterCppRootsToDetachedDOMTrace.rule.js

@@ -0,0 +1,44 @@
+"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 web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterCppRootsToDetachedDOMTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterCppRootsToDetachedDOMTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path contains edges from [C++ roots] to detached DOM elements
+        if (curConfig.hideBrowserLeak && hasCppRootsToDetachedDOMNode(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterCppRootsToDetachedDOMTraceRule = FilterCppRootsToDetachedDOMTraceRule;
+function hasCppRootsToDetachedDOMNode(path) {
+    let p = path;
+    // all the reference chain consists of DOM elements/nodes
+    while (p && p.node) {
+        if (Utils_1.default.isCppRootsNode(p.node) &&
+            p.next &&
+            p.next.node &&
+            Utils_1.default.isDOMNodeIncomplete(p.next.node)) {
+            return true;
+        }
+        p = p.next;
+    }
+    return false;
+}

package/dist/lib/trace-filters/rules/FilterDOMNodeChainTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterDOMNodeChainTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterDOMNodeChainTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterDOMNodeChainTrace.rule.js

@@ -0,0 +1,41 @@
+"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 web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterDOMNodeChainTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterDOMNodeChainTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path consists of only DOM native nodes/elements
+        if (curConfig.hideBrowserLeak && isDOMNodeChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterDOMNodeChainTraceRule = FilterDOMNodeChainTraceRule;
+function isDOMNodeChain(path) {
+    let p = path;
+    // all the reference chain consists of DOM elements/nodes
+    while (p && p.node) {
+        if (!Utils_1.default.isRootNode(p.node) && !Utils_1.default.isDOMNodeIncomplete(p.node)) {
+            return false;
+        }
+        p = p.next;
+    }
+    return true;
+}

package/dist/lib/trace-filters/rules/FilterHermesTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterHermesTraceRule implements ILeakTraceFilterRule {
+    filter(_p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterHermesTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterHermesTrace.rule.js

@@ -0,0 +1,29 @@
+"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 web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterHermesTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterHermesTraceRule {
+    filter(_p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // do not filter out paths when analyzing Hermes snapshots
+        if (curConfig.jsEngine === 'hermes') {
+            return BaseTraceFilter_rule_1.TraceDecision.INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterHermesTraceRule = FilterHermesTraceRule;

package/dist/lib/trace-filters/rules/FilterInternalNodeTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterInternalNodeTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterInternalNodeTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterInternalNodeTrace.rule.js

@@ -0,0 +1,57 @@
+"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 web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterInternalNodeTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterInternalNodeTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: Window -> [InternalNode]+ -> DetachedElement
+        if (curConfig.hideBrowserLeak && internalNodeRetainsDetachedElement(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterInternalNodeTraceRule = FilterInternalNodeTraceRule;
+// check if the path has pattern:
+// Window -> [InternalNode | Text]+ -> DetachedElement
+function internalNodeRetainsDetachedElement(path) {
+    var _a, _b;
+    if (!path) {
+        return false;
+    }
+    let p = path;
+    // GC root is not Window
+    if (!p.node || !p.node.name.startsWith('Window')) {
+        return false;
+    }
+    p = p.next;
+    // Window is not poining to InternalNode
+    if (!p || !p.node || p.node.name !== 'InternalNode') {
+        return false;
+    }
+    // skip the rest InternalNode
+    while (((_a = p.node) === null || _a === void 0 ? void 0 : _a.name) === 'InternalNode' || ((_b = p.node) === null || _b === void 0 ? void 0 : _b.name) === 'Text') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    // check if the node is a detached element
+    return p && Utils_1.default.isDetachedDOMNode(p.node);
+}

package/dist/lib/trace-filters/rules/FilterPendingActivitiesTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterPendingActivitiesTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterPendingActivitiesTrace.rule.d.ts.map