@memlab/core 1.1.20 → 1.1.21

package/dist/index.d.ts

@@ -26,6 +26,8 @@ export { default as utils } from './lib/Utils';
 /** @internal */
 export { default as fileManager } from './lib/FileManager';
 /** @internal */
+export { default as runInfoUtils } from './lib/RunInfoUtils';
+/** @internal */
 export * from './lib/FileManager';
 /** @internal */
 export { default as serializer } from './lib/Serializer';

package/dist/index.js

@@ -35,7 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.EvaluationMetric = exports.NormalizedTrace = exports.leakClusterLogger = exports.ProcessManager = exports.modes = exports.memoryBarChart = exports.constant = exports.analysis = exports.browserInfo = exports.serializer = exports.fileManager = exports.utils = exports.BaseOption = exports.info = exports.config = exports.registerPackage = void 0;
+exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.EvaluationMetric = exports.NormalizedTrace = exports.leakClusterLogger = exports.ProcessManager = exports.modes = exports.memoryBarChart = exports.constant = exports.analysis = exports.browserInfo = exports.serializer = exports.runInfoUtils = exports.fileManager = exports.utils = exports.BaseOption = exports.info = exports.config = exports.registerPackage = void 0;
 const path_1 = __importDefault(require("path"));
 const PackageInfoLoader_1 = require("./lib/PackageInfoLoader");
 __exportStar(require("./lib/Types"), exports);
@@ -67,6 +67,9 @@ Object.defineProperty(exports, "utils", { enumerable: true, get: function () { r
 var FileManager_1 = require("./lib/FileManager");
 Object.defineProperty(exports, "fileManager", { enumerable: true, get: function () { return __importDefault(FileManager_1).default; } });
 /** @internal */
+var RunInfoUtils_1 = require("./lib/RunInfoUtils");
+Object.defineProperty(exports, "runInfoUtils", { enumerable: true, get: function () { return __importDefault(RunInfoUtils_1).default; } });
+/** @internal */
 __exportStar(require("./lib/FileManager"), exports);
 /** @internal */
 var Serializer_1 = require("./lib/Serializer");

package/dist/lib/Config.d.ts

@@ -99,6 +99,7 @@ export declare class MemLabConfig {
     dataBuilderDataDir: string;
     unclassifiedClusterDir: string;
     externalCookiesFile: Optional<string>;
+    extraRunInfoMap: Map<string, string>;
     heapConfig: Optional<IHeapConfig>;
     puppeteerConfig: LaunchOptions & BrowserLaunchArgumentOptions & BrowserConnectOptions;
     openDevtoolsConsole: boolean;
@@ -225,6 +226,7 @@ export declare class MemLabConfig {
     setDevice(deviceName: string, options?: {
         manualOverride?: boolean;
     }): void;
+    setRunInfo(key: string, value: string): void;
     private removeFromSet;
     private addToSet;
     enableXvfb(display: string): void;

package/dist/lib/Config.js

@@ -176,6 +176,12 @@ class MemLabConfig {
         // if true, split dataset into trunks
         // with random order for sequential clustering
         this.seqClusteringIsRandomChunks = false;
+        // extra E2E run info (other than the fields defined in
+        // RunMetaInfo like app, interaction, browserInfo).
+        // Information saved in this map will be
+        // auto-serialized to run-meta.json when the file is saved
+        // and auto-deserialized from run-meta.json when the file is loaded
+        this.extraRunInfoMap = new Map();
     }
     // initialize configurable parameters
     init(options = {}) {
@@ -507,6 +513,9 @@ class MemLabConfig {
         this.puppeteerConfig.defaultViewport = null;
         this.defaultUserAgent = null;
     }
+    setRunInfo(key, value) {
+        this.extraRunInfoMap.set(key, value);
+    }
     removeFromSet(set, list) {
         for (const v of list) {
             set.delete(v);

package/dist/lib/FileManager.d.ts

@@ -10,6 +10,8 @@
 import type { MemLabConfig } from './Config';
 import type { AnyValue, FileOption } from './Types';
 /** @internal */
+export declare function joinAndProcessDir(options: FileOption, ...args: AnyValue[]): string;
+/** @internal */
 export declare class FileManager {
     private memlabConfigCache;
     getDefaultWorkDir(): string;
@@ -75,6 +77,7 @@ export declare class FileManager {
     rmWorkDir(options?: FileOption): void;
     isWithinInternalDirectory(filePath: string): boolean;
     createDefaultVisitOrderMetaFile(options?: FileOption): void;
+    createDefaultVisitOrderMetaFileWithSingleSnapshot(options: FileOption | undefined, snapshotFile: string): void;
     initDirs(config: MemLabConfig, options?: FileOption): void;
 }
 declare const _default: FileManager;

package/dist/lib/FileManager.js

@@ -12,13 +12,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileManager = void 0;
+exports.FileManager = exports.joinAndProcessDir = void 0;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const Console_1 = __importDefault(require("./Console"));
 const Constant_1 = __importDefault(require("./Constant"));
 const Utils_1 = __importDefault(require("./Utils"));
+/** @internal */
 function joinAndProcessDir(options, ...args) {
     const filepath = path_1.default.join(...args);
     if (!fs_extra_1.default.existsSync(filepath)) {
@@ -34,6 +35,7 @@ function joinAndProcessDir(options, ...args) {
     }
     return filepath;
 }
+exports.joinAndProcessDir = joinAndProcessDir;
 /** @internal */
 class FileManager {
     constructor() {
@@ -310,6 +312,9 @@ class FileManager {
         }
     }
     isDirectory(file) {
+        if (!fs_extra_1.default.existsSync(file)) {
+            return false;
+        }
         const stats = fs_extra_1.default.statSync(file);
         return stats.isDirectory();
     }
@@ -356,6 +361,10 @@ class FileManager {
         }
         // If there is at least one snapshot, create a snap-seq.json file.
         // First, get the meta file for leak detection in a single heap snapshot
+        this.createDefaultVisitOrderMetaFileWithSingleSnapshot(options, snapshotFile);
+    }
+    createDefaultVisitOrderMetaFileWithSingleSnapshot(options = FileManager.defaultFileOption, snapshotFile) {
+        const snapshotSeqMetaFile = this.getSnapshotSequenceMetaFile(options);
         const codeDataDir = this.getCodeDataDir();
         const singleSnapshotMetaFile = path_1.default.join(codeDataDir, 'visit-order-single-snapshot.json');
         const visitOrder = JSON.parse(fs_extra_1.default.readFileSync(singleSnapshotMetaFile, 'UTF-8'));

package/dist/lib/HeapAnalyzer.d.ts

@@ -16,6 +16,10 @@ declare type DiffSnapshotsOptions = {
 declare type WorkDirOptions = {
     workDir?: string;
 };
+declare type GetTraceOptions = {
+    workDir?: string;
+    printConsoleOnly?: boolean;
+};
 declare class MemoryAnalyst {
     checkLeak(): Promise<ISerializedInfo[]>;
     diffLeakByWorkDir(options: DiffLeakOptions): Promise<ISerializedInfo[]>;
@@ -50,7 +54,7 @@ declare class MemoryAnalyst {
     serializeClusterUpdate(clusters: TraceCluster[], options?: {
         reclusterOnly?: boolean;
     }): Promise<void>;
-    dumpPathByNodeId(leakedIdSet: HeapNodeIdSet, snapshot: IHeapSnapshot, nodeIdsInSnapshots: Array<HeapNodeIdSet>, id: number, pathLoaderFile: string, summaryFile: string, options?: WorkDirOptions): void;
+    dumpPathByNodeId(leakedIdSet: HeapNodeIdSet, snapshot: IHeapSnapshot, nodeIdsInSnapshots: Array<HeapNodeIdSet>, id: number, pathLoaderFile: string, summaryFile: string, options?: GetTraceOptions): void;
 }
 declare const _default: MemoryAnalyst;
 export default _default;

package/dist/lib/HeapAnalyzer.js

@@ -34,6 +34,7 @@ const TraceFinder_1 = __importDefault(require("../paths/TraceFinder"));
 const TraceBucket_1 = __importDefault(require("../trace-cluster/TraceBucket"));
 const LeakObjectFilter_1 = require("./leak-filters/LeakObjectFilter");
 const MLTraceSimilarityStrategy_1 = __importDefault(require("../trace-cluster/strategies/MLTraceSimilarityStrategy"));
+const LeakTraceFilter_1 = require("./trace-filters/LeakTraceFilter");
 class MemoryAnalyst {
     checkLeak() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -44,14 +45,14 @@ class MemoryAnalyst {
     }
     diffLeakByWorkDir(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const controlSnapshotDir = FileManager_1.default.getCurDataDir({
-                workDir: options.controlWorkDir,
-            });
+            const controlSnapshotDirs = options.controlWorkDirs.map(controlWorkDir => FileManager_1.default.getCurDataDir({
+                workDir: controlWorkDir,
+            }));
             const treatmentSnapshotDir = FileManager_1.default.getCurDataDir({
                 workDir: options.treatmentWorkDir,
             });
             // check control working dir
-            Utils_1.default.checkSnapshots({ snapshotDir: controlSnapshotDir });
+            controlSnapshotDirs.forEach(controlSnapshotDir => Utils_1.default.checkSnapshots({ snapshotDir: controlSnapshotDir }));
             // check treatment working dir
             Utils_1.default.checkSnapshots({ snapshotDir: treatmentSnapshotDir });
             // display control and treatment memory
@@ -63,31 +64,37 @@ class MemoryAnalyst {
     diffMemoryLeakTraces(options) {
         return __awaiter(this, void 0, void 0, function* () {
             Config_1.default.dumpNodeInfo = false;
-            // diff snapshots and get control raw paths
-            let snapshotDiff = yield this.diffSnapshots({
-                loadAllSnapshots: true,
-                workDir: options.controlWorkDir,
-            });
-            const controlLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.controlWorkDir });
-            const controlSnapshot = snapshotDiff.snapshot;
+            // diff snapshots from control dirs and get control raw paths array
+            const controlSnapshots = [];
+            const leakPathsFromControlRuns = [];
+            for (const controlWorkDir of options.controlWorkDirs) {
+                const snapshotDiff = yield this.diffSnapshots({
+                    loadAllSnapshots: true,
+                    workDir: controlWorkDir,
+                });
+                leakPathsFromControlRuns.push(this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: controlWorkDir }));
+                controlSnapshots.push(snapshotDiff.snapshot);
+            }
             // diff snapshots and get treatment raw paths
-            snapshotDiff = yield this.diffSnapshots({
+            const snapshotDiff = yield this.diffSnapshots({
                 loadAllSnapshots: true,
                 workDir: options.treatmentWorkDir,
             });
-            const treatmentLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.controlWorkDir });
+            const treatmentLeakPaths = this.filterLeakPaths(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, { workDir: options.treatmentWorkDir });
             const treatmentSnapshot = snapshotDiff.snapshot;
-            Console_1.default.topLevel(`${controlLeakPaths.length} traces from control group`);
+            const controlPathCounts = JSON.stringify(leakPathsFromControlRuns.map(leakPaths => leakPaths.length));
+            Console_1.default.topLevel(`${controlPathCounts} traces from control group`);
             Console_1.default.topLevel(`${treatmentLeakPaths.length} traces from treatment group`);
-            const result = TraceBucket_1.default.clusterControlTreatmentPaths(controlLeakPaths, controlSnapshot, treatmentLeakPaths, treatmentSnapshot, Utils_1.default.aggregateDominatorMetrics, {
+            const result = TraceBucket_1.default.clusterControlTreatmentPaths(leakPathsFromControlRuns, controlSnapshots, treatmentLeakPaths, treatmentSnapshot, Utils_1.default.aggregateDominatorMetrics, {
                 strategy: Config_1.default.isMLClustering
                     ? new MLTraceSimilarityStrategy_1.default()
                     : undefined,
             });
             Console_1.default.midLevel(`MemLab found ${result.treatmentOnlyClusters.length} new leak(s) in the treatment group`);
             yield this.serializeClusterUpdate(result.treatmentOnlyClusters);
-            // TODO (lgong): log leak traces
-            return [];
+            // serialize JSON file with detailed leak trace information
+            const treatmentOnlyPaths = result.treatmentOnlyClusters.map(c => c.path);
+            return LeakTraceDetailsLogger_1.default.logTraces(snapshotDiff.leakedHeapNodeIdSet, snapshotDiff.snapshot, snapshotDiff.listOfLeakedHeapNodeIdSet, treatmentOnlyPaths, Config_1.default.traceJsonOutDir);
         });
     }
     // find all unique pattern of leaks
@@ -124,7 +131,7 @@ class MemoryAnalyst {
                 snapshotLeakedHeapNodeIdSet = snapshotDiff.leakedHeapNodeIdSet;
                 snapshot = snapshotDiff.snapshot;
             }
-            this.dumpPathByNodeId(snapshotLeakedHeapNodeIdSet, snapshot, nodeIdsInSnapshots, Config_1.default.focusFiberNodeId, Config_1.default.viewJsonFile, Config_1.default.singleReportSummary);
+            this.dumpPathByNodeId(snapshotLeakedHeapNodeIdSet, snapshot, nodeIdsInSnapshots, Config_1.default.focusFiberNodeId, Config_1.default.viewJsonFile, Config_1.default.singleReportSummary, { printConsoleOnly: true });
         });
     }
     shouldLoadCompleteSnapshot(tabsOrder, tab) {
@@ -348,6 +355,7 @@ class MemoryAnalyst {
         this.printHeapAndLeakInfo(leakedNodeIds, snapshot, options);
         // get all leaked objects
         this.filterLeakedObjects(leakedNodeIds, snapshot);
+        const leakTraceFilter = new LeakTraceFilter_1.LeakTraceFilter();
         const nodeIdInPaths = new Set();
         const paths = [];
         let numOfLeakedObjects = 0;
@@ -359,7 +367,8 @@ class MemoryAnalyst {
             }
             // BFS search for path from the leaked node to GC roots
             const p = finder.getPathToGCRoots(snapshot, node);
-            if (!p || !Utils_1.default.isInterestingPath(p)) {
+            if (p == null ||
+                !leakTraceFilter.filter(p, { config: Config_1.default, leakedNodeIds, snapshot })) {
                 return;
             }
             ++numOfLeakedObjects;
@@ -451,10 +460,13 @@ class MemoryAnalyst {
                 return;
             }
             LeakTraceDetailsLogger_1.default.logTrace(leakedIdSet, snapshot, nodeIdsInSnapshots, path, pathLoaderFile);
-            const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
-            const interactionSummary = Serializer_1.default.summarizeTabsOrder(tabsOrder);
             let pathSummary = Serializer_1.default.summarizePath(path, nodeIdInPaths, snapshot, { color: true });
             Console_1.default.topLevel(pathSummary);
+            if (options.printConsoleOnly) {
+                return;
+            }
+            const tabsOrder = Utils_1.default.loadTabsOrder(FileManager_1.default.getSnapshotSequenceMetaFile(options));
+            const interactionSummary = Serializer_1.default.summarizeTabsOrder(tabsOrder);
             pathSummary = Serializer_1.default.summarizePath(path, nodeIdInPaths, snapshot);
             const summary = `Page Interaction: \n${interactionSummary}\n\n` +
                 `Path from GC Root to Leaked Object:\n${pathSummary}`;

package/dist/lib/RunInfoUtils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { Nullable, Optional, RunMetaInfo } from './Types';
+export declare class RunMetaInfoManager {
+    getRunMetaFilePath(options?: {
+        workDir?: Optional<string>;
+    }): string;
+    saveRunMetaInfo(runMetaInfo: RunMetaInfo, options?: {
+        workDir?: Optional<string>;
+        extraRunInfo?: Map<string, string>;
+    }): string;
+    private loadRunMetaInfoFromFile;
+    loadRunMetaInfo(options?: {
+        metaFile?: Optional<string>;
+        workDir?: Optional<string>;
+    }): RunMetaInfo;
+    loadRunMetaInfoSilentFail(options?: {
+        metaFile?: Optional<string>;
+        workDir?: Optional<string>;
+    }): Nullable<RunMetaInfo>;
+    loadRunMetaExternalTemplate(): RunMetaInfo;
+    setConfigFromRunMeta(options?: {
+        workDir?: Optional<string>;
+        silentFail?: boolean;
+    }): void;
+}
+declare const runInfoUtils: {
+    runMetaInfoManager: RunMetaInfoManager;
+};
+/** @internal */
+export default runInfoUtils;
+//# sourceMappingURL=RunInfoUtils.d.ts.map

package/dist/lib/RunInfoUtils.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunMetaInfoManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const BrowserInfo_1 = __importDefault(require("./BrowserInfo"));
+const Config_1 = __importDefault(require("./Config"));
+const Constant_1 = __importDefault(require("./Constant"));
+const FileManager_1 = __importDefault(require("./FileManager"));
+const Utils_1 = __importDefault(require("./Utils"));
+const InternalValueSetter_1 = require("./InternalValueSetter");
+class RunMetaInfoManager {
+    getRunMetaFilePath(options) {
+        if ((options === null || options === void 0 ? void 0 : options.workDir) != null) {
+            return FileManager_1.default.getRunMetaFile({ workDir: options.workDir });
+        }
+        if (Config_1.default.useExternalSnapshot) {
+            return Config_1.default.externalRunMetaFile;
+        }
+        if (Config_1.default.runMetaFile != null) {
+            return Config_1.default.runMetaFile;
+        }
+        return FileManager_1.default.getRunMetaFile();
+    }
+    saveRunMetaInfo(runMetaInfo, options) {
+        var _a;
+        const runMetaFile = this.getRunMetaFilePath(options);
+        const serializable = Object.assign(Object.assign({}, runMetaInfo), { extraInfo: Object.assign(Object.assign({}, Utils_1.default.mapToObject(Config_1.default.extraRunInfoMap)), Utils_1.default.mapToObject((_a = options === null || options === void 0 ? void 0 : options.extraRunInfo) !== null && _a !== void 0 ? _a : new Map())) });
+        fs_1.default.writeFileSync(runMetaFile, JSON.stringify(serializable, null, 2), 'UTF-8');
+        return runMetaFile;
+    }
+    loadRunMetaInfoFromFile(file) {
+        const content = fs_1.default.readFileSync(file, 'UTF-8');
+        const runMetaInfo = JSON.parse(content);
+        if (runMetaInfo && runMetaInfo.extraInfo) {
+            Config_1.default.extraRunInfoMap = Utils_1.default.objectToMap(runMetaInfo.extraInfo);
+        }
+        return runMetaInfo;
+    }
+    loadRunMetaInfo(options) {
+        const file = (options === null || options === void 0 ? void 0 : options.metaFile) || this.getRunMetaFilePath(options);
+        try {
+            return this.loadRunMetaInfoFromFile(file);
+        }
+        catch (_) {
+            throw Utils_1.default.haltOrThrow('Run info missing. Please make sure `memlab run` is complete.');
+        }
+    }
+    loadRunMetaInfoSilentFail(options) {
+        const file = (options === null || options === void 0 ? void 0 : options.metaFile) || this.getRunMetaFilePath(options);
+        try {
+            return this.loadRunMetaInfoFromFile(file);
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    loadRunMetaExternalTemplate() {
+        const runMetaTemplateFile = FileManager_1.default.getRunMetaExternalTemplateFile();
+        return JSON.parse(fs_1.default.readFileSync(runMetaTemplateFile, 'UTF-8'));
+    }
+    setConfigFromRunMeta(options = {}) {
+        const meta = (options === null || options === void 0 ? void 0 : options.silentFail)
+            ? this.loadRunMetaInfoSilentFail(options)
+            : this.loadRunMetaInfo(options);
+        if (meta == null) {
+            return;
+        }
+        if ((meta === null || meta === void 0 ? void 0 : meta.app) == null || (meta === null || meta === void 0 ? void 0 : meta.interaction) == null) {
+            if (options === null || options === void 0 ? void 0 : options.silentFail) {
+                return;
+            }
+            throw Utils_1.default.haltOrThrow('No app or interaction infomation');
+        }
+        Config_1.default.targetApp = meta.app;
+        Config_1.default.targetTab = meta.interaction;
+        BrowserInfo_1.default.load(meta.browserInfo);
+    }
+}
+exports.RunMetaInfoManager = RunMetaInfoManager;
+const runInfoUtils = { runMetaInfoManager: new RunMetaInfoManager() };
+(0, InternalValueSetter_1.setInternalValue)(runInfoUtils, __filename, Constant_1.default.internalDir);
+/** @internal */
+exports.default = runInfoUtils;

package/dist/lib/Types.d.ts

@@ -23,6 +23,8 @@ export declare type Optional<T> = Nullable<T> | undefined;
 /** @internal */
 export declare type AnyRecord = Record<string, RecordValue>;
 /** @internal */
+export declare type StringRecord = Record<string, string>;
+/** @internal */
 export declare type AnyAyncFunction = (...args: AnyValue[]) => Promise<AnyValue>;
 /** @internal */
 export declare type AnyFunction = (...args: AnyValue[]) => AnyValue;
@@ -66,6 +68,7 @@ export declare type XvfbType = {
 export declare type ShellOptions = {
     dir?: Optional<string>;
     ignoreError?: Optional<boolean>;
+    throwError?: Optional<boolean>;
     disconnectStdio?: Optional<boolean>;
 };
 /** @internal */
@@ -942,6 +945,8 @@ export declare type RunMetaInfo = {
      * output data from the browser
      */
     browserInfo: IBrowserInfo;
+    /** @internal */
+    extraInfo?: StringRecord;
 };
 /**
  * A heap snapshot is generally a graph where graph nodes are JS heap objects
@@ -1924,12 +1929,12 @@ export interface IOveralLeakInfo extends Partial<IOveralHeapInfo> {
 }
 /** @internal */
 export declare type DiffLeakOptions = {
-    controlWorkDir: string;
+    controlWorkDirs: string[];
     treatmentWorkDir: string;
 };
 /** @internal */
 export declare type PlotMemoryOptions = {
-    controlWorkDir?: string;
+    controlWorkDirs?: string[];
     treatmentWorkDir?: string;
     workDir?: string;
 } & IMemoryAnalystOptions;

package/dist/lib/Utils.d.ts

@@ -7,13 +7,15 @@
  * @format
  * @oncall web_perf_infra
  */
-import type { HaltOrThrowOptions, HeapNodeIdSet, ShellOptions } from './Types';
+import type { HaltOrThrowOptions, HeapNodeIdSet, ShellOptions, StringRecord } from './Types';
 import type { Browser, Page } from 'puppeteer';
-import type { AnyAyncFunction, AnyOptions, E2EStepInfo, IHeapSnapshot, IHeapNode, IHeapEdge, IScenario, ILeakFilter, LeakTracePathItem, RunMetaInfo, RawHeapSnapshot, Nullable, Optional } from './Types';
+import type { AnyAyncFunction, AnyOptions, E2EStepInfo, IHeapSnapshot, IHeapNode, IHeapEdge, IScenario, ILeakFilter, LeakTracePathItem, RawHeapSnapshot, Nullable, Optional } from './Types';
 declare function isHermesInternalObject(node: IHeapNode): boolean;
 declare function isStackTraceFrame(node: IHeapNode): boolean;
 declare function isFiberNode(node: Optional<IHeapNode>): boolean;
 declare function isDetachedFiberNode(node: IHeapNode): boolean;
+declare function isDOMInternalNode(node: Optional<IHeapNode>): boolean;
+declare function isGlobalHandlesNode(node: Optional<IHeapNode>): boolean;
 declare function isDetachedDOMNode(node: Optional<IHeapNode>, args?: AnyOptions): boolean;
 declare function isWeakMapEdge(edge: IHeapEdge): boolean;
 declare function isWeakMapEdgeToKey(edge: IHeapEdge): boolean;
@@ -23,6 +25,9 @@ declare function isFiberNodeDeletionsEdge(edge: IHeapEdge): boolean;
 declare function isBlinkRootNode(node: IHeapNode): boolean;
 declare function isPendingActivityNode(node: IHeapNode): boolean;
 declare function isDOMNodeIncomplete(node: IHeapNode): boolean;
+declare function isXMLDocumentNode(node: IHeapNode): boolean;
+declare function isHTMLDocumentNode(node: IHeapNode): boolean;
+declare function isDOMTextNode(node: IHeapNode): boolean;
 declare function isRootNode(node: IHeapNode, opt?: AnyOptions): boolean;
 declare function isDirectPropEdge(edge: IHeapEdge): boolean;
 declare function isReturnEdge(edge: IHeapEdge): boolean;
@@ -64,12 +69,8 @@ declare function getBooleanNodeValue(node: IHeapNode): Nullable<boolean>;
 declare function getToNodeByEdge(node: Nullable<IHeapNode>, propName: string, propType?: string): Nullable<IHeapNode>;
 declare function extractHTMLElementNodeInfo(node: IHeapNode): string;
 declare function hasOnlyWeakReferrers(node: IHeapNode): boolean;
-declare function getRunMetaFilePath(): string;
-declare function loadRunMetaInfo(metaFile?: Optional<string>): RunMetaInfo;
-declare function loadTargetInfoFromRunMeta(): void;
 declare function getSnapshotSequenceFilePath(): string;
 declare function loadTabsOrder(metaFile?: Optional<string>): E2EStepInfo[];
-declare function isInterestingPath(p: LeakTracePathItem): boolean;
 declare function isObjectNode(node: IHeapNode): boolean;
 declare function isPlainJSObjectNode(node: IHeapNode): boolean;
 declare function pathHasDetachedHTMLNode(path: LeakTracePathItem): boolean;
@@ -129,14 +130,16 @@ declare function getRetainedSize(node: IHeapNode): number;
 declare function aggregateDominatorMetrics(ids: HeapNodeIdSet, snapshot: IHeapSnapshot, checkNodeCb: (node: IHeapNode) => boolean, nodeMetricsCb: (node: IHeapNode) => number): number;
 declare function getLeakTracePathLength(path: LeakTracePathItem): number;
 declare function getNumberAtPercentile(arr: number[], percentile: number): number;
+declare function mapToObject(map: Map<string, string>): StringRecord;
+declare function objectToMap(object: StringRecord): Map<string, string>;
 declare const _default: {
     aggregateDominatorMetrics: typeof aggregateDominatorMetrics;
     applyToNodes: typeof applyToNodes;
     callAsync: typeof callAsync;
     camelCaseToReadableString: typeof camelCaseToReadableString;
+    checkIsChildOfParent: typeof checkIsChildOfParent;
     checkSnapshots: typeof checkSnapshots;
     checkUninstalledLibrary: typeof checkUninstalledLibrary;
-    checkIsChildOfParent: typeof checkIsChildOfParent;
     closePuppeteer: typeof closePuppeteer;
     dumpSnapshot: typeof dumpSnapshot;
     equalOrMatch: typeof equalOrMatch;
@@ -145,13 +148,14 @@ declare const _default: {
     extractHTMLElementNodeInfo: typeof extractHTMLElementNodeInfo;
     filterNodesInPlace: typeof filterNodesInPlace;
     getAllDominators: typeof getAllDominators;
+    getBooleanNodeValue: typeof getBooleanNodeValue;
     getClosureSourceUrl: typeof getClosureSourceUrl;
     getConditionalDominatorIds: typeof getConditionalDominatorIds;
-    getError: typeof getError;
     getEdgeByNameAndType: typeof getEdgeByNameAndType;
+    getError: typeof getError;
     getLastNodeId: typeof getLastNodeId;
-    getLeakedNode: typeof getLeakedNode;
     getLeakTracePathLength: typeof getLeakTracePathLength;
+    getLeakedNode: typeof getLeakedNode;
     getNodesIdSet: typeof getNodesIdSet;
     getNumberAtPercentile: typeof getNumberAtPercentile;
     getNumberNodeValue: typeof getNumberNodeValue;
@@ -159,17 +163,16 @@ declare const _default: {
     getReadablePercent: typeof getReadablePercent;
     getReadableTime: typeof getReadableTime;
     getRetainedSize: typeof getRetainedSize;
-    getRunMetaFilePath: typeof getRunMetaFilePath;
     getScenarioName: typeof getScenarioName;
     getSingleSnapshotFileForAnalysis: typeof getSingleSnapshotFileForAnalysis;
     getSnapshotDirForAnalysis: typeof getSnapshotDirForAnalysis;
-    getSnapshotFilesInDir: typeof getSnapshotFilesInDir;
+    getSnapshotFilePath: typeof getSnapshotFilePath;
+    getSnapshotFilePathWithTabType: typeof getSnapshotFilePathWithTabType;
     getSnapshotFilesFromTabsOrder: typeof getSnapshotFilesFromTabsOrder;
+    getSnapshotFilesInDir: typeof getSnapshotFilesInDir;
     getSnapshotFromFile: typeof getSnapshotFromFile;
     getSnapshotNodeIdsFromFile: typeof getSnapshotNodeIdsFromFile;
     getSnapshotSequenceFilePath: typeof getSnapshotSequenceFilePath;
-    getSnapshotFilePath: typeof getSnapshotFilePath;
-    getSnapshotFilePathWithTabType: typeof getSnapshotFilePathWithTabType;
     getStringNodeValue: typeof getStringNodeValue;
     getToNodeByEdge: typeof getToNodeByEdge;
     getUniqueID: typeof getUniqueID;
@@ -180,18 +183,21 @@ declare const _default: {
     hasReactEdges: typeof hasReactEdges;
     isAlternateNode: typeof isAlternateNode;
     isBlinkRootNode: typeof isBlinkRootNode;
+    isDOMInternalNode: typeof isDOMInternalNode;
+    isDOMNodeIncomplete: typeof isDOMNodeIncomplete;
+    isDOMTextNode: typeof isDOMTextNode;
     isDebuggableNode: typeof isDebuggableNode;
-    isDetachedFiberNode: typeof isDetachedFiberNode;
     isDetachedDOMNode: typeof isDetachedDOMNode;
+    isDetachedFiberNode: typeof isDetachedFiberNode;
     isDirectPropEdge: typeof isDirectPropEdge;
     isDocumentDOMTreesRoot: typeof isDocumentDOMTreesRoot;
-    isDOMNodeIncomplete: typeof isDOMNodeIncomplete;
     isEssentialEdge: typeof isEssentialEdge;
     isFiberNode: typeof isFiberNode;
     isFiberNodeDeletionsEdge: typeof isFiberNodeDeletionsEdge;
+    isGlobalHandlesNode: typeof isGlobalHandlesNode;
+    isHTMLDocumentNode: typeof isHTMLDocumentNode;
     isHermesInternalObject: typeof isHermesInternalObject;
     isHostRoot: typeof isHostRoot;
-    isInterestingPath: typeof isInterestingPath;
     isMeaningfulEdge: typeof isMeaningfulEdge;
     isMeaningfulNode: typeof isMeaningfulNode;
     isNodeDominatedByDeletionsArray: typeof isNodeDominatedByDeletionsArray;
@@ -210,17 +216,18 @@ declare const _default: {
     isWeakMapEdge: typeof isWeakMapEdge;
     isWeakMapEdgeToKey: typeof isWeakMapEdgeToKey;
     isWeakMapEdgeToValue: typeof isWeakMapEdgeToValue;
+    isXMLDocumentNode: typeof isXMLDocumentNode;
     iterateChildFiberNodes: typeof iterateChildFiberNodes;
     iterateDescendantFiberNodes: typeof iterateDescendantFiberNodes;
-    loadRunMetaInfo: typeof loadRunMetaInfo;
     loadLeakFilter: typeof loadLeakFilter;
     loadScenario: typeof loadScenario;
     loadTabsOrder: typeof loadTabsOrder;
-    loadTargetInfoFromRunMeta: typeof loadTargetInfoFromRunMeta;
+    mapToObject: typeof mapToObject;
     markAllDetachedFiberNode: typeof markAllDetachedFiberNode;
     markAlternateFiberNode: typeof markAlternateFiberNode;
     memCache: Record<string, any>;
     normalizeBaseUrl: typeof normalizeBaseUrl;
+    objectToMap: typeof objectToMap;
     pathHasDetachedHTMLNode: typeof pathHasDetachedHTMLNode;
     pathHasEdgeWithIndex: typeof pathHasEdgeWithIndex;
     repeat: typeof repeat;
@@ -233,7 +240,6 @@ declare const _default: {
     shuffleArray: typeof shuffleArray;
     throwError: typeof throwError;
     upperCaseFirstCharacter: typeof upperCaseFirstCharacter;
-    getBooleanNodeValue: typeof getBooleanNodeValue;
 };
 export default _default;
 //# sourceMappingURL=Utils.d.ts.map