@memlab/core 1.1.20 → 1.1.22

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;
@@ -1966,4 +1971,9 @@ export interface IHeapConfig {
 }
 /** @internal */
 export declare type ErrorWithMessage = Pick<Error, 'message'>;
+/** @internal */
+export declare type CommandOptionExample = string | {
+    description?: string;
+    cliOptionExample: string;
+};
 //# sourceMappingURL=Types.d.ts.map

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,10 @@ 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 isCppRootsNode(node: IHeapNode): boolean;
 declare function isRootNode(node: IHeapNode, opt?: AnyOptions): boolean;
 declare function isDirectPropEdge(edge: IHeapEdge): boolean;
 declare function isReturnEdge(edge: IHeapEdge): boolean;
@@ -64,16 +70,14 @@ 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;
 declare function pathHasEdgeWithIndex(path: LeakTracePathItem, idx: number): boolean;
+declare function pathHasEdgeWithName(path: LeakTracePathItem, edgeName: string): boolean;
+declare function pathHasNodeOrEdgeWithName(path: LeakTracePathItem, name: Optional<string>): boolean;
 declare function getLastNodeId(path: LeakTracePathItem): number;
 declare function getReadablePercent(num: number): string;
 declare function getReadableBytes(bytes: Optional<number>): string;
@@ -129,14 +133,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 +151,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 +166,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 +186,22 @@ declare const _default: {
     hasReactEdges: typeof hasReactEdges;
     isAlternateNode: typeof isAlternateNode;
     isBlinkRootNode: typeof isBlinkRootNode;
+    isCppRootsNode: typeof isCppRootsNode;
+    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,19 +220,22 @@ 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;
+    pathHasEdgeWithName: typeof pathHasEdgeWithName;
+    pathHasNodeOrEdgeWithName: typeof pathHasNodeOrEdgeWithName;
     repeat: typeof repeat;
     resolveFilePath: typeof resolveFilePath;
     resolveSnapshotFilePath: typeof resolveSnapshotFilePath;
@@ -233,7 +246,6 @@ declare const _default: {
     shuffleArray: typeof shuffleArray;
     throwError: typeof throwError;
     upperCaseFirstCharacter: typeof upperCaseFirstCharacter;
-    getBooleanNodeValue: typeof getBooleanNodeValue;
 };
 export default _default;
 //# sourceMappingURL=Utils.d.ts.map

package/dist/lib/Utils.js

@@ -53,7 +53,6 @@ const Config_1 = __importStar(require("./Config"));
 const Console_1 = __importDefault(require("./Console"));
 const Constant_1 = __importDefault(require("./Constant"));
 const HeapParser_1 = __importDefault(require("./HeapParser"));
-const BrowserInfo_1 = __importDefault(require("./BrowserInfo"));
 const memCache = Object.create(null);
 const FileManager_1 = __importDefault(require("./FileManager"));
 const __1 = require("..");
@@ -133,6 +132,21 @@ function isFiberNode(node) {
 function isDetachedFiberNode(node) {
     return isFiberNode(node) && isDetached(node);
 }
+// return true if this node is InternalNode (native)
+function isDOMInternalNode(node) {
+    if (node == null) {
+        return false;
+    }
+    return (node.type === 'native' &&
+        (node.name === 'InternalNode' || node.name === 'Detached InternalNode'));
+}
+// return true the the nodee is a global handles node
+function isGlobalHandlesNode(node) {
+    if (node == null) {
+        return false;
+    }
+    return node.name === '(Global handles)' && node.type === 'synthetic';
+}
 // this function returns a more general sense of DOM nodes. Specifically,
 // any detached DOM nodes (e.g., HTMLXXElement, IntersectionObserver etc.)
 // that are not internal nodes.
@@ -211,18 +225,55 @@ function isPendingActivityNode(node) {
     if (!node || !node.name) {
         return false;
     }
-    return node.type === 'synthetic' && node.name === 'Pending activities';
+    if (node.type !== 'synthetic' && node.type !== 'native') {
+        return false;
+    }
+    return node.name === 'Pending activities';
 }
+const htmlElementRegex = /^HTML.*Element$/;
+const svgElementRegex = /^SVG.*Element$/;
+const htmlCollectionRegex = /^HTML.*Collection$/;
+const cssElementRegex = /^CSS/;
+const styleSheetRegex = /StyleSheet/;
+// special DOM element names that are not
+// included in the previous regex definitions
+const domElementSpecialNames = new Set([
+    'DOMTokenList',
+    'HTMLDocument',
+    'InternalNode',
+    'Text',
+    'XMLDocument',
+]);
 // check the node against a curated list of known HTML Elements
 // the list may be incomplete
 function isDOMNodeIncomplete(node) {
+    if (node.type !== 'native') {
+        return false;
+    }
     let name = node.name;
-    const pattern = /^HTML.*Element$/;
     const detachedPrefix = 'Detached ';
     if (name.startsWith(detachedPrefix)) {
         name = name.substring(detachedPrefix.length);
     }
-    return pattern.test(name);
+    return (htmlElementRegex.test(name) ||
+        svgElementRegex.test(name) ||
+        cssElementRegex.test(name) ||
+        styleSheetRegex.test(name) ||
+        htmlCollectionRegex.test(name) ||
+        domElementSpecialNames.has(name));
+}
+function isXMLDocumentNode(node) {
+    return node.type === 'native' && node.name === 'XMLDocument';
+}
+function isHTMLDocumentNode(node) {
+    return node.type === 'native' && node.name === 'HTMLDocument';
+}
+function isDOMTextNode(node) {
+    return node.type === 'native' && node.name === 'Text';
+}
+// check if this is a [C++ roots] (synthetic) node
+function isCppRootsNode(node) {
+    return node.name === 'C++ roots' && node.type === 'synthetic';
 }
 function isRootNode(node, opt = {}) {
     if (!node) {
@@ -452,7 +503,7 @@ function hasHostRoot(node) {
     return false;
 }
 function filterNodesInPlace(idSet, snapshot, cb) {
-    const ids = Array.from(idSet.keys());
+    const ids = Array.from(idSet);
     for (const id of ids) {
         const node = snapshot.getNodeById(id);
         if (node && !cb(node, snapshot)) {
@@ -461,7 +512,7 @@ function filterNodesInPlace(idSet, snapshot, cb) {
     }
 }
 function applyToNodes(idSet, snapshot, cb, options = {}) {
-    let ids = Array.from(idSet.keys());
+    let ids = Array.from(idSet);
     if (options.shuffle) {
         ids.sort(() => Math.random() - 0.5);
     }
@@ -471,7 +522,9 @@ function applyToNodes(idSet, snapshot, cb, options = {}) {
     for (const id of ids) {
         const node = snapshot.getNodeById(id);
         if (!node) {
-            Console_1.default.warning(`node @${id} is not found`);
+            if (Config_1.default.verbose) {
+                Console_1.default.warning(`node @${id} is not found`);
+            }
             return;
         }
         cb(node, snapshot);
@@ -831,27 +884,6 @@ function hasOnlyWeakReferrers(node) {
     (edge) => edge.type !== 'weak' && edge.type !== 'shortcut');
     return referrer == null;
 }
-function getRunMetaFilePath() {
-    return Config_1.default.useExternalSnapshot
-        ? Config_1.default.externalRunMetaFile
-        : Config_1.default.runMetaFile;
-}
-function loadRunMetaInfo(metaFile = undefined) {
-    const file = metaFile || getRunMetaFilePath();
-    try {
-        const content = fs_1.default.readFileSync(file, 'UTF-8');
-        return JSON.parse(content);
-    }
-    catch (_) {
-        throw haltOrThrow('Run info missing. Please make sure `memlab run` is complete.');
-    }
-}
-function loadTargetInfoFromRunMeta() {
-    const meta = loadRunMetaInfo();
-    Config_1.default.targetApp = meta.app;
-    Config_1.default.targetTab = meta.interaction;
-    BrowserInfo_1.default.load(meta.browserInfo);
-}
 function getSnapshotSequenceFilePath() {
     if (!Config_1.default.useExternalSnapshot) {
         // load the snapshot sequence meta file from the default location
@@ -870,7 +902,9 @@ function getSnapshotSequenceFilePath() {
 // this should be called only after exploration
 function loadTabsOrder(metaFile = undefined) {
     try {
-        const file = metaFile || getSnapshotSequenceFilePath();
+        const file = metaFile != null && fs_1.default.existsSync(metaFile)
+            ? metaFile
+            : getSnapshotSequenceFilePath();
         const content = fs_1.default.readFileSync(file, 'UTF-8');
         return JSON.parse(content);
     }
@@ -878,31 +912,6 @@ function loadTabsOrder(metaFile = undefined) {
         throw haltOrThrow('snapshot meta data invalid or missing');
     }
 }
-// if true the leak trace is will be reported
-function isInterestingPath(p) {
-    // do not filter paths when analyzing Hermes snapshots
-    if (Config_1.default.jsEngine === 'hermes') {
-        return true;
-    }
-    // if the path has pattern: Window -> [InternalNode]+ -> DetachedElement
-    if (Config_1.default.hideBrowserLeak && internalNodeRetainsDetachedElement(p)) {
-        return false;
-    }
-    // if the path has pattern: ShadowRoot -> DetachedElement
-    if (Config_1.default.hideBrowserLeak && shadowRootRetainsDetachedElement(p)) {
-        return false;
-    }
-    // if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
-    if (Config_1.default.hideBrowserLeak && styleEngineRetainsDetachedElement(p)) {
-        return false;
-    }
-    // if the path has pattern: Pending activitiies -> DetachedElement
-    if (Config_1.default.hideBrowserLeak &&
-        pendingActivitiesRetainsDetachedElementChain(p)) {
-        return false;
-    }
-    return true;
-}
 // return true if the heap node represents JS object or closure
 function isObjectNode(node) {
     if (isPlainJSObjectNode(node)) {
@@ -920,109 +929,53 @@ function isPlainJSObjectNode(node) {
     }
     return node.name === 'Object';
 }
-// check if the path has pattern:
-// Window -> [InternalNode | Text]+ -> DetachedElement
-function internalNodeRetainsDetachedElement(path) {
-    var _a, _b;
+function pathHasDetachedHTMLNode(path) {
     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;
+    while (p) {
+        if (p.node && isDetachedDOMNode(p.node)) {
+            return true;
         }
-    }
-    // check if the node is a detached element
-    return p && isDetachedDOMNode(p.node);
-}
-// check if the path has pattern: ShadowRoot -> DetachedElement
-function shadowRootRetainsDetachedElement(path) {
-    let p = path;
-    // find the ShadowRoot
-    while (p && p.node && p.node.name !== 'ShadowRoot') {
         p = p.next;
-        if (!p) {
-            return false;
-        }
     }
-    p = p.next;
-    // check if the node is a detached element
-    return !!p && isDetachedDOMNode(p.node);
+    return false;
 }
-// check if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
-function styleEngineRetainsDetachedElement(path) {
-    let p = path;
-    // find the StyleEngine
-    while (p && p.node && p.node.name !== 'StyleEngine') {
-        p = p.next;
-        if (!p) {
-            return false;
-        }
-    }
-    p = p.next;
-    // StyleEngine is not poining to InternalNode
-    if (!p || !p.node || p.node.name !== 'InternalNode') {
+function pathHasEdgeWithIndex(path, idx) {
+    if (!path || typeof idx !== 'number') {
         return false;
     }
-    p = p.next;
-    // check if the InternalNode is pointing to a detached element
-    return !!p && isDetachedDOMNode(p.node);
-}
-function pendingActivitiesRetainsDetachedElementChain(path) {
     let p = path;
-    // find the Pending activities
-    while (p && p.node && !isPendingActivityNode(p.node)) {
-        p = p.next;
-        if (!p) {
-            return false;
-        }
-    }
-    p = p.next;
-    if (!p || !p.node) {
-        return false;
-    }
-    // all the following reference chain is detached DOM elements
-    // pointing to other detached DOM elements
-    while (p && p.node) {
-        if (!isDetachedDOMNode(p.node)) {
-            return false;
+    while (p) {
+        if (p.edge && p.edge.edgeIndex === idx) {
+            return true;
         }
         p = p.next;
     }
-    return true;
+    return false;
 }
-function pathHasDetachedHTMLNode(path) {
-    if (!path) {
-        return false;
-    }
+function pathHasEdgeWithName(path, edgeName) {
     let p = path;
     while (p) {
-        if (p.node && isDetachedDOMNode(p.node)) {
+        if (p.edge && p.edge.name_or_index === edgeName) {
             return true;
         }
         p = p.next;
     }
     return false;
 }
-function pathHasEdgeWithIndex(path, idx) {
-    if (!path || typeof idx !== 'number') {
-        return false;
+function pathHasNodeOrEdgeWithName(path, name) {
+    if (name == null) {
+        return true;
     }
+    name = name.toLowerCase();
     let p = path;
     while (p) {
-        if (p.edge && p.edge.edgeIndex === idx) {
+        if (p.edge && `${p.edge.name_or_index}`.toLowerCase().includes(name)) {
+            return true;
+        }
+        if (p.node && `${p.node.name}`.toLowerCase().includes(name)) {
             return true;
         }
         p = p.next;
@@ -1772,16 +1725,22 @@ function runShell(command, options = {}) {
         execOptions.shell = '/bin/bash';
     }
     let ret = null;
+    if (Config_1.default.verbose || Config_1.default.isContinuousTest) {
+        Console_1.default.lowLevel(`running shell command: ${command}`);
+    }
     try {
         ret = child_process_1.default.execSync(command, execOptions);
     }
     catch (ex) {
-        if (Config_1.default.verbose) {
+        if (Config_1.default.verbose || Config_1.default.isContinuousTest) {
             if (ex instanceof Error) {
                 Console_1.default.lowLevel(ex.message);
                 Console_1.default.lowLevel((_c = ex.stack) !== null && _c !== void 0 ? _c : '');
             }
         }
+        if (options.throwError) {
+            throw ex;
+        }
         if (options.ignoreError === true) {
             return '';
         }
@@ -1824,14 +1783,28 @@ function getNumberAtPercentile(arr, percentile) {
     }
     return arr[indexInt];
 }
+function mapToObject(map) {
+    const ret = Object.create(null);
+    map.forEach((v, k) => {
+        ret[k] = v;
+    });
+    return ret;
+}
+function objectToMap(object) {
+    const ret = new Map();
+    for (const k of Object.keys(object)) {
+        ret.set(k, object[k]);
+    }
+    return ret;
+}
 exports.default = {
     aggregateDominatorMetrics,
     applyToNodes,
     callAsync,
     camelCaseToReadableString,
+    checkIsChildOfParent,
     checkSnapshots,
     checkUninstalledLibrary,
-    checkIsChildOfParent,
     closePuppeteer,
     dumpSnapshot,
     equalOrMatch,
@@ -1840,13 +1813,14 @@ exports.default = {
     extractHTMLElementNodeInfo,
     filterNodesInPlace,
     getAllDominators,
+    getBooleanNodeValue,
     getClosureSourceUrl,
     getConditionalDominatorIds,
-    getError,
     getEdgeByNameAndType,
+    getError,
     getLastNodeId,
-    getLeakedNode,
     getLeakTracePathLength,
+    getLeakedNode,
     getNodesIdSet,
     getNumberAtPercentile,
     getNumberNodeValue,
@@ -1854,17 +1828,16 @@ exports.default = {
     getReadablePercent,
     getReadableTime,
     getRetainedSize,
-    getRunMetaFilePath,
     getScenarioName,
     getSingleSnapshotFileForAnalysis,
     getSnapshotDirForAnalysis,
-    getSnapshotFilesInDir,
+    getSnapshotFilePath,
+    getSnapshotFilePathWithTabType,
     getSnapshotFilesFromTabsOrder,
+    getSnapshotFilesInDir,
     getSnapshotFromFile,
     getSnapshotNodeIdsFromFile,
     getSnapshotSequenceFilePath,
-    getSnapshotFilePath,
-    getSnapshotFilePathWithTabType,
     getStringNodeValue,
     getToNodeByEdge,
     getUniqueID,
@@ -1875,18 +1848,22 @@ exports.default = {
     hasReactEdges,
     isAlternateNode,
     isBlinkRootNode,
+    isCppRootsNode,
+    isDOMInternalNode,
+    isDOMNodeIncomplete,
+    isDOMTextNode,
     isDebuggableNode,
-    isDetachedFiberNode,
     isDetachedDOMNode,
+    isDetachedFiberNode,
     isDirectPropEdge,
     isDocumentDOMTreesRoot,
-    isDOMNodeIncomplete,
     isEssentialEdge,
     isFiberNode,
     isFiberNodeDeletionsEdge,
+    isGlobalHandlesNode,
+    isHTMLDocumentNode,
     isHermesInternalObject,
     isHostRoot,
-    isInterestingPath,
     isMeaningfulEdge,
     isMeaningfulNode,
     isNodeDominatedByDeletionsArray,
@@ -1905,19 +1882,22 @@ exports.default = {
     isWeakMapEdge,
     isWeakMapEdgeToKey,
     isWeakMapEdgeToValue,
+    isXMLDocumentNode,
     iterateChildFiberNodes,
     iterateDescendantFiberNodes,
-    loadRunMetaInfo,
     loadLeakFilter,
     loadScenario,
     loadTabsOrder,
-    loadTargetInfoFromRunMeta,
+    mapToObject,
     markAllDetachedFiberNode,
     markAlternateFiberNode,
     memCache,
     normalizeBaseUrl,
+    objectToMap,
     pathHasDetachedHTMLNode,
     pathHasEdgeWithIndex,
+    pathHasEdgeWithName,
+    pathHasNodeOrEdgeWithName,
     repeat,
     resolveFilePath,
     resolveSnapshotFilePath,
@@ -1928,5 +1908,4 @@ exports.default = {
     shuffleArray,
     throwError,
     upperCaseFirstCharacter,
-    getBooleanNodeValue,
 };

package/dist/lib/charts/MemoryBarChart.d.ts

@@ -10,6 +10,7 @@
 import type { PlotMemoryOptions } from '../Types';
 declare class MemoryBarChart {
     plotMemoryBarChart(options?: PlotMemoryOptions): void;
+    private isPlotDataValid;
     private loadPlotDataFromTabsOrder;
     private loadPlotDataFromWorkDir;
     private loadPlotData;