@memlab/core 1.0.6 → 1.1.0

package/dist/lib/Types.d.ts

@@ -10,20 +10,32 @@
 import { ParsedArgs } from 'minimist';
 import type { LaunchOptions, Page } from 'puppeteer';
 import type { ErrorHandling, MemLabConfig } from './Config';
+/** @internal */
 export declare type AnyValue = any;
+/** @internal */
 export declare type RecordValue = string | number | boolean | null | RecordValue[] | {
     [key: string]: RecordValue;
 };
+/** @internal */
 export declare type Nullable<T> = T | null;
+/** @internal */
 export declare type Optional<T> = Nullable<T> | undefined;
+/** @internal */
 export declare type AnyRecord = Record<string, RecordValue>;
+/** @internal */
 export declare type AnyAyncFunction = (...args: AnyValue[]) => Promise<AnyValue>;
+/** @internal */
 export declare type AnyFunction = (...args: AnyValue[]) => AnyValue;
+/** @internal */
 export declare type AnyOptions = Record<string, unknown>;
+/** @internal */
 export declare type UnusedOptions = Record<string, never>;
+/** @internal */
 export declare type Command = [string, string[], AnyOptions];
 export declare type Predicator<T> = (node: T) => boolean;
-export declare type HeapNodeIdSet = Set<IHeapNode['id']>;
+/** @internal */
+export declare type HeapNodeIdSet = Set<number>;
+/** @internal */
 export declare type HaltOrThrowOptions = {
     printErrorBeforeHalting?: boolean;
     errorHandling?: ErrorHandling;
@@ -31,10 +43,12 @@ export declare type HaltOrThrowOptions = {
     secondaryMessageToPrint?: string;
     printCallback?: () => void;
 };
+/** @internal */
 export declare type CLIOptions = {
     cliArgs: ParsedArgs;
     configFromOptions?: AnyRecord;
 };
+/** @internal */
 export declare type XvfbType = {
     start: (callback: (error: Error) => AnyValue | null) => void;
     stop: (callback: (error: Error) => AnyValue | null) => void;
@@ -42,6 +56,7 @@ export declare type XvfbType = {
     stopSync: () => void;
     display: () => string;
 };
+/** @internal */
 export declare type CLIArgs = {
     verbose: boolean;
     app: string;
@@ -71,11 +86,11 @@ export declare type CLIArgs = {
     'local-puppeteer': boolean;
     'snapshot-dir': string;
 };
-declare type CookieItem = {
+export declare type Cookies = Array<{
     name: string;
     value: string;
-};
-export declare type Cookies = Array<CookieItem>;
+}>;
+/** @internal */
 export interface IE2EScenarioSynthesizer {
     getAppName(): string;
     getOrigin(): Nullable<string>;
@@ -99,9 +114,11 @@ export interface IE2EScenarioSynthesizer {
     getExtraOperationsForStep(_stepInfo: E2EStepInfo): E2EOperation[];
     synthesis(baseline: string, target: string, intermediates: string[], options: E2ESynthesizerOptions): IE2EScenarioVisitPlan;
 }
+/** @internal */
 export interface E2EScenarioSynthesizerConstructor {
     new (config: Config): IE2EScenarioSynthesizer;
 }
+/** @internal */
 export interface IRunningMode {
     setConfig(config: Config): void;
     beforeRunning(visitPlan: IE2EScenarioVisitPlan): void;
@@ -117,37 +134,337 @@ export interface IRunningMode {
     getAdditionalMetrics(page: Page, tabInfo?: E2EStepInfo): Promise<E2EStepInfo['metrics']>;
     postProcessData(visitPlan: IE2EScenarioVisitPlan): void;
 }
+/** @internal */
 export declare type Config = MemLabConfig;
+/** @internal */
 export declare type QuickExperiment = {
     universe: string;
     experiment: string;
     group: string;
 };
+/**
+ * The type for defining custom leak-filtering logic.
+ * * **Examples**:
+ * ```typescript
+ * const scenario = {
+ *
+ * };
+ *
+ * let map = Object.create(null);
+ * const beforeLeakFilter = (snapshot: IHeapSnapshot, _leakedNodeIds: HeapNodeIdSet): void => {
+ *   map = initializeMapUsingSnapshot(snapshot);
+ * };
+ *
+ * // duplicated string with size > 1KB as memory leak
+ * const leakFilter = (node: IHeapNode): boolean => {
+ *   if (node.type !== 'string' || node.retainedSize < 1000) {
+ *     return false;
+ *   }
+ *   const str = utils.getStringNodeValue(node);
+ *   return map[str] > 1;
+ * };
+ *
+ * export default {beforeLeakFilter, leakFilter};
+ * ```
+ */
 export interface ILeakFilter {
     beforeLeakFilter?: InitLeakFilterCallback;
     leakFilter: LeakFilterCallback;
 }
+/**
+ * Lifecycle function callback that is invoked initially once before calling any
+ * leak filter function.
+ *
+ * @param snaphost - heap snapshot see {@link IHeapSnapshot}
+ * @param leakedNodeIds - the set of leaked object (node) ids.
+ */
 export declare type InitLeakFilterCallback = (snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet) => void;
+/**
+ * Callback that can be used to define a logic to filter the
+ * leaked objects. The callback is only called for every node
+ * allocated but not released from the target interaction
+ * in the heap snapshot.
+ *
+ * @param node - the node that is kept alive in the memory in the heap snapshot
+ * @param snapshot - the snapshot of target interaction
+ * @param leakedNodeIds - the set of leaked node ids
+ *
+ * @returns the value indicating whether the given node in the snapshot
+ * should be considered as leaked.
+ * * **Examples**:
+ * ```javascript
+ * // any node in the heap snapshot that is greater than 1MB
+ * function leakFilter(node, _snapshot, _leakedNodeIds) {
+ *  return node.retainedSize > 1000000;
+ * };
+ * ```
+ */
 export declare type LeakFilterCallback = (node: IHeapNode, snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet) => boolean;
+/**
+ * The callback defines browser interactions which are
+ * used by memlab to interact with the web app under test.
+ */
 export declare type InteractionsCallback = (page: Page, args?: OperationArgs) => Promise<void>;
+/**
+ * Test scenario specifies how you want a E2E test to interact with a web browser.
+ * The test scenario can be saved as a `.js` file and passed to the `memlab
+ * run --scenario` command:
+ * ```javascript
+ * // save as test.js and use in terminal:
+ * // $ memlab run --scenario test.js
+ *
+ * module.exports = {
+ *   url: () => 'https://www.npmjs.com/',
+ *   action: async () => ... ,
+ *   back: async () => ... ,
+ * };
+ * ```
+ *
+ * The test scenario instance can also be passed to the
+ * [`run` API](../modules/api_src#run) exported by `@memlab/api`.
+ * ```typescript
+ * const {run} = require('@memlab/api');
+ *
+ * (async function () {
+ *   const scenario = {
+ *     url: () => 'https://www.facebook.com',
+ *     action: async () => ... ,
+ *     back: async () => ... ,
+ *   };
+ *   const leaks = await run({scenario});
+ * })();
+ * ```
+ */
 export interface IScenario {
+    /** @internal */
     name?: () => string;
+    /** @internal */
     app?: () => string;
-    cookies?: () => CookieItem[];
+    /**
+     * If the page you are running memlab against requires authentication or
+     * specific cookie(s) to be set, you can pass them as
+     * a list of <name, value> pairs.
+     * @returns cookie list
+     * * **Examples**:
+     * ```typescript
+     * const scenario = {
+     *   url: () => 'https://www.facebook.com/',
+     *   cookies: () => [
+     *     {"name":"cm_j","value":"none"},
+     *     {"name":"datr","value":"yJvIY..."},
+     *     {"name":"c_user","value":"8917..."},
+     *     {"name":"xs","value":"95:9WQ..."},
+     *     // ...
+     *   ],
+     * };
+     * ```
+     */
+    cookies?: () => Cookies;
+    /**
+     * String value of the initial url of the page.
+     *
+     * @returns the string value of the initial url
+     * * **Examples**:
+     * ```typescript
+     * const scenario = {
+     *   url: () => 'https://www.npmjs.com/',
+     * };
+     * ```
+     * If a test scenario only specifies the `url` callback (without the `action`
+     * callback), memlab will try to detect memory leaks from the initial page
+     * load. All objects allocated by the initial page load will be candidates
+     * for memory leak filtering.
+     */
     url: () => string;
+    /**
+     * `action` is the callback function that defines the interaction
+     * where you want to trigger memory leaks after the initial page load.
+     * All JS objects in browser allocated by the browser interactions triggered
+     * from the `action` callback will be candidates for memory leak filtering.
+     *
+     * * **Parameters**:
+     *   * page: `Page` | the puppeteer [`Page`](https://pptr.dev/api/puppeteer.page)
+     *     object, which provides APIs to interact with the web browser
+     *
+     * * **Examples**:
+     * ```typescript
+     * const scenario = {
+     *   url: () => 'https://www.npmjs.com/',
+     *   action: async (page) => {
+     *     await page.click('a[href="/link"]');
+     *   },
+     *   back: async (page) => {
+     *     await page.click('a[href="/back"]');
+     *   },
+     * }
+     * ```
+     * Note: always clean up external puppeteer references to JS objects
+     *       in the browser context.
+     * ```typescript
+     * const scenario = {
+     *   url: () => 'https://www.npmjs.com/',
+     *   action: async (page) => {
+     *     const elements = await page.$x("//button[contains(., 'Text in Button')]");
+     *     const [button] = elements;
+     *     if (button) {
+     *       await button.click();
+     *     }
+     *     // dispose external references to JS objects in browser context
+     *     await promise.all(elements.map(e => e.dispose()));
+     *   },
+     *   back: async (page) => ... ,
+     * }
+     ```
+     */
     action?: InteractionsCallback;
+    /**
+     * `back` is the callback function that specifies how memlab should
+     * back/revert the `action` callback. Think of it as an undo action.
+     *
+     * * **Examples**:
+     * ```typescript
+     * const scenario = {
+     *   url: () => 'https://www.npmjs.com/',
+     *   action: async (page) => {
+     *     await page.click('a[href="/link"]');
+     *   },
+     *   back: async (page) => {
+     *     await page.click('a[href="/back"]');
+     *   },
+     * }
+     * ```
+     * Check out [this page](/docs/how-memlab-works) on why
+     * memlab needs to undo/revert the `action` callback.
+     */
     back?: InteractionsCallback;
+    /**
+     * Specifies how many **extra** `action` and `back` actions performed by memlab.
+     * * **Examples**:
+     * ```typescript
+     * module.exports = {
+     *   url: () => ... ,
+     *   action: async (page) => ... ,
+     *   back: async (page) => ... ,
+     *   // browser interaction: two additional [ action -> back ]
+     *   // init-load -> action -> back -> action -> back -> action -> back
+     *   repeat: () => 2,
+     * };
+     * ```
+     */
     repeat?: () => number;
+    /**
+     * Optional callback function that checks if the web page is loaded
+     * after for initial page loading and subsequent browser interactions.
+     *
+     * If this callback is not provided, memlab by default
+     * considers a navigation to be finished when there are no network
+     * connections for at least 500ms.
+     *
+     * * **Parameters**:
+     *   * page: `Page` | the puppeteer [`Page`](https://pptr.dev/api/puppeteer.page)
+     *     object, which provides APIs to interact with the web browser
+     * * **Returns**: a boolean value, if it returns `true`, memlab will consider
+     *   the navigation completes, if it returns `false`, memlab will keep calling
+     *   this callback until it returns `true`. This is an async callback, you can
+     *   also `await` and returns `true` until some async logic is resolved.
+     * * **Examples**:
+     * ```typescript
+     * module.exports = {
+     *   url: () => ... ,
+     *   action: async (page) => ... ,
+     *   back: async (page) => ... ,
+     *   isPageLoaded: async (page) => {
+     *     await page.waitForNavigation({
+     *       // consider navigation to be finished when there are
+     *       // no more than 2 network connections for at least 500 ms.
+     *       waitUntil: 'networkidle2',
+     *       // Maximum navigation time in milliseconds
+     *       timeout: 5000,
+     *     });
+     *     return true;
+     *   },
+     * };
+     * ```
+     */
     isPageLoaded?: CheckPageLoadCallback;
+    /**
+     * Lifecycle function callback that is invoked initially once before
+     * the subsequent `leakFilter` function calls. This callback could
+     * be used to initialize some data stores or to do some one-off
+     * preprocessings.
+     *
+     * * **Parameters**:
+     *   * snapshot: `IHeapSnapshot` | the final heap snapshot taken after
+     *     all browser interactions are done.
+     *     Check out {@link IHeapSnapshot} for more APIs that queries the heap snapshot.
+     *   * leakedNodeIds: `Set<number>` | the set of ids of all JS heap objects
+     *     allocated by the `action` call but not released after the `back` call
+     *     in browser.
+     *
+     * * **Examples**:
+     * ```typescript
+     * module.exports = {
+     *   url: () => ... ,
+     *   action: async (page) => ... ,
+     *   back: async (page) => ... ,
+     *   beforeLeakFilter: (snapshot, leakedNodeIds) {
+     *     // initialize some data stores
+     *   },
+     * };
+     * ```
+     */
     beforeLeakFilter?: InitLeakFilterCallback;
+    /**
+     * This callback that defines how you want to filter out the
+     * leaked objects. The callback is called for every node (JS heap
+     * object in browser) allocated by the `action` callback, but not
+     * released after the `back` callback. Those objects could be caches
+     * that are retained in memory on purpose, or they are memory leaks.
+     *
+     * This optional callback allows you to define your own algorithm
+     * to cherry pick memory leaks for specific JS program under test.
+     *
+     * If this optional callback is not defined, memlab will use its
+     * built-in leak filter, which considers detached DOM elements
+     * and unmounted Fiber nodes (detached from React Fiber tree) as
+     * memory leaks.
+     *
+     * * **Parameters**:
+     *   * node: `IHeapNode` | one of the heap object allocated but not released.
+     *   * snapshot: `IHeapSnapshot` | the final heap snapshot taken after
+     *     all browser interactions are done.
+     *     Check out {@link IHeapSnapshot} for more APIs that queries the heap snapshot.
+     *   * leakedNodeIds: `Set<number>` | the set of ids of all JS heap objects
+     *     allocated by the `action` call but not released after the `back` call
+     *     in browser.
+     *
+     * * **Returns**: the boolean value indicating whether the given node in
+     *   the snapshot should be considered as leaked.
+     *
+     * * **Examples**:
+     * ```typescript
+     * module.exports = {
+     *   url: () => ... ,
+     *   action: async (page) => ... ,
+     *   back: async (page) => ... ,
+     *   leakFilter(node, snapshot, leakedNodeIds) {
+     *     // any unreleased node (JS heap object) with 1MB+
+     *     // retained size is considered a memory leak
+     *     return node.retainedSize > 1000000;
+     *   },
+     * };
+     * ```
+     */
     leakFilter?: LeakFilterCallback;
 }
+/** @internal */
 export declare type LeakTracePathItem = {
     node?: IHeapNode;
     edge?: IHeapEdge;
     next?: LeakTracePathItem;
     edgeRetainSize?: number;
 };
+/** @internal */
 export declare type TraceCluster = {
     id?: number;
     path: LeakTracePathItem;
@@ -157,11 +474,13 @@ export declare type TraceCluster = {
     leakedNodeIds?: HeapNodeIdSet;
     clusterMetaInfo?: TraceClusterMetaInfo;
 };
+/** @internal */
 export declare type TraceClusterDiff = {
     staleClusters: TraceCluster[];
     clustersToAdd: TraceCluster[];
     allClusters: TraceCluster[][];
 };
+/** @internal */
 export declare type LeakTraceElement = {
     kind: string;
     id?: number;
@@ -169,12 +488,15 @@ export declare type LeakTraceElement = {
     name_or_index?: string | number;
     type: string;
 };
+/** @internal */
 export declare type LeakTrace = LeakTraceElement[];
+/** @internal */
 export declare type TraceDiff = {
     staleClusters: LeakTrace[];
     clustersToAdd: LeakTrace[];
     allClusters: LeakTrace[][];
 };
+/** @internal */
 export declare type TraceClusterMetaInfo = {
     cluster_id: number;
     creation_time: number;
@@ -189,14 +511,17 @@ export declare type TraceClusterMetaInfo = {
     leak_trace_handle?: string;
     meta_data: string;
 };
+/** @internal */
 export interface E2EInteraction {
     kind: string;
     timeout?: number;
 }
+/** @internal */
 export declare type E2EOperation = E2EInteraction & {
     selector: string;
     act(page: Page, opArgs?: OperationArgs): Promise<void>;
 };
+/** @internal */
 export declare type E2ESynthesizerOptions = {
     name?: string;
     type?: string;
@@ -212,11 +537,17 @@ export declare type E2ESynthesizerOptions = {
     gk_enable?: string[];
     gk_disable?: string[];
 };
+/** @internal */
 export interface IDataBuilder {
     className: string;
     state: Record<string, AnyValue>;
 }
+/**
+ * Callback function to provide if the page is loaded.
+ * @param page - puppeteer's [Page](https://pptr.dev/api/puppeteer.page/) object.
+ */
 export declare type CheckPageLoadCallback = (page: Page) => Promise<boolean>;
+/** @internal */
 export interface IE2EScenarioVisitPlan {
     name: string;
     appName: string;
@@ -230,6 +561,7 @@ export interface IE2EScenarioVisitPlan {
     dataBuilder: Optional<IDataBuilder>;
     isPageLoaded?: CheckPageLoadCallback;
 }
+/** @internal */
 export declare type OperationArgs = {
     isPageLoaded?: CheckPageLoadCallback;
     showProgress?: boolean;
@@ -240,6 +572,7 @@ export declare type OperationArgs = {
     warmup?: boolean;
     noWaitAfterPageLoad?: boolean;
 };
+/** @internal */
 export interface IE2EStepBasic {
     name: string;
     url: string;
@@ -252,6 +585,7 @@ export interface IE2EStepBasic {
     interactions: E2EOperation | Array<E2EOperation | InteractionsCallback>;
     postInteractions?: E2EOperation | Array<E2EOperation | InteractionsCallback>;
 }
+/** @internal */
 export declare type E2EStepInfo = IE2EStepBasic & {
     snapshot: boolean;
     screenshot: boolean;
@@ -260,6 +594,7 @@ export declare type E2EStepInfo = IE2EStepBasic & {
     delay?: number;
     metrics: Record<string, number>;
 };
+/** @internal */
 export interface IBrowserInfo {
     _browserVersion: string;
     _puppeteerConfig: LaunchOptions;
@@ -353,16 +688,27 @@ export interface IHeapNodes {
     forEach(callback: (node: IHeapNode, index: number) => void | boolean): void;
     forEachTraceable(callback: (node: IHeapNode, index: number) => void | boolean): void;
 }
+/** @internal */
 export declare type HeapNodeFields = string[];
+/** @internal */
 export declare type HeapNodeTypes = string[];
+/** @internal */
 export declare type RawHeapNodeTypes = Array<HeapNodeTypes | string>;
+/** @internal */
 export declare type HeapEdgeFields = string[];
+/** @internal */
 export declare type HeapEdgeTypes = string[] | string;
+/** @internal */
 export declare type RawHeapEdgeTypes = Array<HeapEdgeTypes | string>;
+/** @internal */
 export declare type HeapTraceFunctionInfoFields = string[];
+/** @internal */
 export declare type HeapTraceNodeFields = string[];
+/** @internal */
 export declare type HeapSampleFields = string[];
+/** @internal */
 export declare type HeapLocationFields = string[];
+/** @internal */
 export declare type HeapSnapshotMeta = {
     node_fields: HeapNodeFields;
     node_types: RawHeapNodeTypes;
@@ -373,12 +719,14 @@ export declare type HeapSnapshotMeta = {
     sample_fields: HeapSampleFields;
     location_fields: HeapLocationFields;
 };
+/** @internal */
 export declare type HeapSnapshotInfo = {
     meta: HeapSnapshotMeta;
     node_count: number;
     edge_count: number;
     trace_function_count: number;
 };
+/** @internal */
 export declare type RawHeapSnapshot = {
     snapshot: HeapSnapshotInfo;
     nodes: number[];
@@ -389,12 +737,15 @@ export declare type RawHeapSnapshot = {
     locations: number[];
     strings: string[];
 };
+/** @internal */
 export interface ISerializedInfo {
     [key: string]: string | number | boolean | ISerializedInfo;
 }
+/** @internal */
 export declare type NumericDictionary = {
     [index: number]: number;
 };
+/** @internal */
 export interface IOveralHeapInfo {
     fiberNodeSize: number;
     regularFiberNodeSize: number;
@@ -402,31 +753,37 @@ export interface IOveralHeapInfo {
     alternateFiberNodeSize: number;
     error: number;
 }
+/** @internal */
 export interface IOveralLeakInfo extends Partial<IOveralHeapInfo> {
     leakedSize: number;
     leakedFiberNodeSize: number;
     leakedAlternateFiberNodeSize: number;
 }
+/** @internal */
 export interface IMemoryAnalystOptions {
     snapshotDir?: string;
     minSnapshots?: number;
 }
+/** @internal */
 export interface IMemoryAnalystSnapshotDiff {
     leakedHeapNodeIdSet: HeapNodeIdSet;
     snapshot: IHeapSnapshot;
     listOfLeakedHeapNodeIdSet: Array<HeapNodeIdSet>;
 }
+/** @internal */
 export interface IMemoryAnalystHeapNodeLeakSummary extends Pick<IHeapNode, 'name' | 'type' | 'retainedSize'> {
     count: number;
 }
+/** @internal */
 export interface IMemoryAnalystHeapNodeReferrenceStat {
     numberOfEdgesToNode: number;
     source: IHeapNode;
     edge: IHeapEdge;
 }
+/** @internal */
 export interface IClusterStrategy {
     diffTraces: (newLeakTraces: LeakTrace[], existingLeakTraces: LeakTrace[]) => TraceDiff;
 }
+/** @internal */
 export declare type ErrorWithMessage = Pick<Error, 'message'>;
-export {};
 //# sourceMappingURL=Types.d.ts.map

package/dist/lib/Types.js

@@ -8,4 +8,5 @@
  * @emails oncall+ws_labs
  * @format
  */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/Utils.js

@@ -356,7 +356,7 @@ function getNodesIdSet(snapshot) {
     return set;
 }
 // given a set of nodes S, return a subset S' where
-// no nodes are dominaeted by nodes in S
+// no nodes are dominated by nodes in S
 function getConditionalDominatorIds(ids, snapshot, condCb) {
     const dominatorIds = new Set();
     // set all node ids
@@ -863,6 +863,10 @@ function isInterestingPath(p) {
     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;
+    }
     return true;
 }
 // return true if the heap node represents JS object or closure
@@ -923,6 +927,25 @@ function shadowRootRetainsDetachedElement(path) {
     // check if the node is a detached element
     return !!p && isDetachedDOMNode(p.node);
 }
+// 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') {
+        return false;
+    }
+    p = p.next;
+    // check if the InternalNode is pointing to a detached element
+    return !!p && isDetachedDOMNode(p.node);
+}
 function pathHasDetachedHTMLNode(path) {
     if (!path) {
         return false;

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

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { MemLabConfig } from '../Config';
+import type { HeapNodeIdSet, IHeapNode, IHeapSnapshot } from '../Types';
+/**
+ * Every leak object filter rule needs to give a label
+ * to each object passed to the filter
+ */
+export declare enum LeakDecision {
+    LEAK = "leak",
+    MAYBE_LEAK = "maybe-leak",
+    NOT_LEAK = "not-leak"
+}
+export interface ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode, snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet): LeakDecision;
+}
+//# sourceMappingURL=BaseLeakFilter.rule.d.ts.map