@memlab/core 2.0.4 → 2.0.5

package/dist/__tests__/lib/HeapAnonymizer.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 memory_lab
+ */
+export {};
+//# sourceMappingURL=HeapAnonymizer.test.d.ts.map

package/dist/__tests__/lib/HeapAnonymizer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapAnonymizer.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/lib/HeapAnonymizer.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/__tests__/lib/HeapAnonymizer.test.js

@@ -0,0 +1,377 @@
+"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 memory_lab
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Config_1 = __importDefault(require("../../lib/Config"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const HeapParser_1 = __importDefault(require("../../lib/HeapParser"));
+const HeapAnonymizer_1 = require("../../lib/HeapAnonymizer");
+const NodeHeap_1 = require("../../lib/NodeHeap");
+const HeapSerializer_1 = require("../../lib/HeapSerializer");
+beforeEach(() => {
+    Config_1.default.isTest = true;
+});
+const timeout = 5 * 60 * 1000;
+/**
+ * The canary values are ASSEMBLED AT RUNTIME rather than written as literals.
+ *
+ * This test file's own source text ends up in the snapshot's string table — V8
+ * keeps script sources on the heap like any other string. A literal canary
+ * would therefore be present in the capture twice: once as the object's value,
+ * and once inside the script source. Both get redacted, so the test would still
+ * pass — but it would pass without ever proving that the OBJECT's value was
+ * handled, which is the thing under test. Assembling at runtime means the full
+ * value exists only as a heap string.
+ */
+function canaryValue() {
+    return ['MEMLAB', 'ANON', 'CANARY', 'a7f3c1d9e2b4'].join('-');
+}
+/** An identifier-shaped map key: structurally a label, semantically a payload. */
+function canaryIdKey() {
+    return ['77', '3105482913'].join('');
+}
+/**
+ * Build a canary variant.
+ *
+ * Uses `join` rather than a template literal on purpose. Template
+ * concatenation produces a `concatenated string`, and V8 stores those as a pair
+ * of pointers to their halves — the joined text never becomes an entry in the
+ * string table, so a canary built that way is not actually in the capture and
+ * the positive controls below correctly refuse to pass. `join` flattens.
+ */
+function canaryVariant(suffix) {
+    return [canaryValue(), suffix].join('-');
+}
+class AnonymizerCanaryHolder {
+    constructor(secret, idKey) {
+        this.anonymizerCanaryDescriptiveKey = 'a value under a descriptive name';
+        this.byContactId = {};
+        this.secretValue = secret;
+        this.byContactId[idKey] = 1;
+    }
+}
+test('anonymizing a heap snapshot removes heap string values', () => __awaiter(void 0, void 0, void 0, function* () {
+    const secret = canaryValue();
+    const idKey = canaryIdKey();
+    const holder = new AnonymizerCanaryHolder(secret, idKey);
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    const outputFile = `${sourceFile}.anonymized`;
+    try {
+        // POSITIVE CONTROL. Without this the whole test can pass for the wrong
+        // reason: if the canary were optimized away or collected before the dump,
+        // "absent afterwards" would be trivially true and the assertions below
+        // would prove nothing.
+        const before = fs_1.default.readFileSync(sourceFile, 'utf8');
+        expect(before.includes(secret)).toBe(true);
+        expect(before.includes(idKey)).toBe(true);
+        const heap = yield HeapParser_1.default.parse(sourceFile, {});
+        const report = (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(heap);
+        (0, HeapSerializer_1.serializeHeapSnapshot)(heap, outputFile);
+        // Scan the RAW BYTES rather than the parsed string table, so a value that
+        // survived somewhere unexpected — an edge name, a node name — is caught
+        // too. Absence from the file is the property being claimed.
+        const after = fs_1.default.readFileSync(outputFile, 'utf8');
+        expect(after.includes(secret)).toBe(false);
+        expect(after.includes(idKey)).toBe(false);
+        // ... and it must be redaction, not destruction: the labels a retainer
+        // trace is built from have to survive, or the capture is unanalyzable.
+        expect(after.includes('anonymizerCanaryDescriptiveKey')).toBe(true);
+        expect(after.includes('AnonymizerCanaryHolder')).toBe(true);
+        expect(report.valuesRedacted).toBeGreaterThan(0);
+        // The result still has to be a readable snapshot describing the same
+        // graph — redaction must not change the shape of the heap.
+        const reparsed = yield HeapParser_1.default.parse(outputFile, {});
+        expect(reparsed.nodes.length).toBe(heap.nodes.length);
+        expect(reparsed.edges.length).toBe(heap.edges.length);
+    }
+    finally {
+        // Every run creates its own snapshot directory, and both files are
+        // removed here, so re-running neither accumulates captures nor lets a
+        // previous run's output satisfy this one's assertions.
+        for (const file of [sourceFile, outputFile]) {
+            if (fs_1.default.existsSync(file)) {
+                fs_1.default.unlinkSync(file);
+            }
+        }
+    }
+    // Keep the holder reachable until after the dump; an unreferenced local
+    // can be collected before the snapshot is taken, which would silently
+    // remove the very object being tested.
+    expect(holder.secretValue).toBe(secret);
+}), timeout);
+test('stable mode keeps distinct values distinct, uniform mode does not', () => __awaiter(void 0, void 0, void 0, function* () {
+    const holder = {
+        distinctValues: [
+            canaryVariant('one'),
+            canaryVariant('two'),
+            canaryVariant('six'),
+        ],
+    };
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    try {
+        const before = fs_1.default.readFileSync(sourceFile, 'utf8');
+        expect(before.includes(holder.distinctValues[0])).toBe(true);
+        const stableHeap = yield HeapParser_1.default.parse(sourceFile, {});
+        (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(stableHeap, { mode: 'stable' });
+        const uniformHeap = yield HeapParser_1.default.parse(sourceFile, {});
+        (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(uniformHeap, { mode: 'uniform' });
+        // Same length, three different values. `stable` must map them to three
+        // different tokens; `uniform` collapses them to one, which is exactly the
+        // behaviour that manufactures fake string duplication.
+        const lengths = holder.distinctValues.map(v => v.length);
+        expect(new Set(lengths).size).toBe(1);
+        const tokensOfLength = (heap) => new Set(heap.snapshot.strings.filter(s => s.length === lengths[0]));
+        const stableTokens = tokensOfLength(stableHeap);
+        const uniformTokens = tokensOfLength(uniformHeap);
+        expect(uniformTokens.has('?'.repeat(lengths[0]))).toBe(true);
+        expect(stableTokens.size).toBeGreaterThan(uniformTokens.size);
+    }
+    finally {
+        if (fs_1.default.existsSync(sourceFile)) {
+            fs_1.default.unlinkSync(sourceFile);
+        }
+    }
+}), timeout);
+test('anonymization is deterministic and repeatable for the same input', () => __awaiter(void 0, void 0, void 0, function* () {
+    const holder = { value: canaryVariant('repeatable') };
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    try {
+        expect(fs_1.default.readFileSync(sourceFile, 'utf8').includes(holder.value)).toBe(true);
+        const first = yield HeapParser_1.default.parse(sourceFile, {});
+        const second = yield HeapParser_1.default.parse(sourceFile, {});
+        const firstReport = (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(first, { salt: 'test-salt' });
+        const secondReport = (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(second, { salt: 'test-salt' });
+        expect(secondReport.valuesRedacted).toBe(firstReport.valuesRedacted);
+        expect(first.snapshot.strings).toEqual(second.snapshot.strings);
+        // A different salt must produce different tokens, or the salt is not
+        // doing the one job it has.
+        const third = yield HeapParser_1.default.parse(sourceFile, {});
+        (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(third, { salt: 'another-salt' });
+        expect(third.snapshot.strings).not.toEqual(first.snapshot.strings);
+    }
+    finally {
+        if (fs_1.default.existsSync(sourceFile)) {
+            fs_1.default.unlinkSync(sourceFile);
+        }
+    }
+}), timeout);
+/**
+ * Field names, not computed keys, because only fast-mode properties become
+ * LABELS.
+ *
+ * `obj[key] = v` on a plain object puts it in dictionary mode, where V8 stores
+ * the key as a value inside a name dictionary rather than as a named edge — so
+ * such keys are already covered by the node-type rule and prove nothing about
+ * the callback. A declared field is emitted as a property edge name, which is
+ * the case that needs a caller-supplied decision.
+ */
+class AnonymizerCallbackHolder {
+    constructor() {
+        // An application-private identifier scheme: no digits, not an address, not
+        // base64, not markup. Every built-in rule is blind to it BY DESIGN — memlab
+        // must not ship other people's formats.
+        //
+        // The values are objects, not numbers, and that is load-bearing: V8 emits no
+        // edge for a small-integer property because there is no heap object to point
+        // at, so an `= 1` field name never becomes a label at all and the test would
+        // silently exercise the wrong path.
+        this.ORD_kfmqvzhtbewx = { n: 1 };
+        // ... and one a built-in rule DOES take, to test the other direction: the
+        // callback has to be able to protect as well as redact.
+        this.col_987654321012 = { n: 2 };
+    }
+}
+test('a shouldRedact callback covers a scheme no built-in rule knows', () => __awaiter(void 0, void 0, void 0, function* () {
+    const appKey = 'ORD_kfmqvzhtbewx';
+    const builtInKey = 'col_987654321012';
+    const holder = new AnonymizerCallbackHolder();
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    const defaultOut = `${sourceFile}.default`;
+    const customOut = `${sourceFile}.custom`;
+    try {
+        const before = fs_1.default.readFileSync(sourceFile, 'utf8');
+        expect(before.includes(appKey)).toBe(true);
+        expect(before.includes(builtInKey)).toBe(true);
+        // POSITIVE CONTROL for the callback's reason to exist: with defaults the
+        // app-private key survives because nothing knows it, while the key with a
+        // long digit run does not. If this ever flips, the assertions below stop
+        // proving that the callback reached something the rules could not.
+        const plain = yield HeapParser_1.default.parse(sourceFile, {});
+        (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(plain);
+        (0, HeapSerializer_1.serializeHeapSnapshot)(plain, defaultOut);
+        const plainText = fs_1.default.readFileSync(defaultOut, 'utf8');
+        expect(plainText.includes(appKey)).toBe(true);
+        expect(plainText.includes(builtInKey)).toBe(false);
+        const custom = yield HeapParser_1.default.parse(sourceFile, {});
+        const shapes = [];
+        const report = (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(custom, {
+            shouldRedact: (value, context) => {
+                if (value === appKey) {
+                    shapes.push(context.shape);
+                    return true;
+                }
+                if (value === builtInKey) {
+                    return false;
+                }
+                return undefined;
+            },
+        });
+        (0, HeapSerializer_1.serializeHeapSnapshot)(custom, customOut);
+        const customText = fs_1.default.readFileSync(customOut, 'utf8');
+        expect(customText.includes(appKey)).toBe(false);
+        expect(customText.includes(builtInKey)).toBe(true);
+        expect(report.contentRedactedByRule.some(r => r.rule === 'custom-callback')).toBe(true);
+        // The context has to carry something usable for matching a whole scheme
+        // by shape rather than value by value.
+        expect(shapes.length).toBeGreaterThan(0);
+        expect(shapes[0]).toBe('A_a');
+    }
+    finally {
+        for (const file of [sourceFile, defaultOut, customOut]) {
+            if (fs_1.default.existsSync(file)) {
+                fs_1.default.unlinkSync(file);
+            }
+        }
+    }
+    expect(holder.ORD_kfmqvzhtbewx.n).toBe(1);
+}), timeout);
+test('the file API anonymizes without building the object graph', () => __awaiter(void 0, void 0, void 0, function* () {
+    const secret = canaryVariant('fileapi');
+    const holder = { value: secret };
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    const outputFile = `${sourceFile}.fileapi`;
+    try {
+        expect(fs_1.default.readFileSync(sourceFile, 'utf8').includes(secret)).toBe(true);
+        const audit = yield (0, HeapAnonymizer_1.auditHeapSnapshotFile)(sourceFile);
+        expect(audit.valuesRedacted).toBeGreaterThan(0);
+        // auditing must not write anything, including over the input
+        expect(fs_1.default.existsSync(outputFile)).toBe(false);
+        expect(fs_1.default.readFileSync(sourceFile, 'utf8').includes(secret)).toBe(true);
+        const report = yield (0, HeapAnonymizer_1.anonymizeHeapSnapshotFile)(sourceFile, outputFile);
+        expect(report.valuesRedacted).toBe(audit.valuesRedacted);
+        expect(fs_1.default.readFileSync(outputFile, 'utf8').includes(secret)).toBe(false);
+        // and the file it wrote still has to be a readable snapshot
+        const reparsed = yield HeapParser_1.default.parse(outputFile, {});
+        expect(reparsed.nodes.length).toBeGreaterThan(0);
+    }
+    finally {
+        for (const file of [sourceFile, outputFile]) {
+            if (fs_1.default.existsSync(file)) {
+                fs_1.default.unlinkSync(file);
+            }
+        }
+    }
+    expect(holder.value).toBe(secret);
+}), timeout);
+test('the file API refuses to overwrite its own input, however it is spelled', () => __awaiter(void 0, void 0, void 0, function* () {
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    const dir = path_1.default.dirname(sourceFile);
+    const base = path_1.default.basename(sourceFile);
+    const linkPath = `${sourceFile}.link`;
+    const before = fs_1.default.readFileSync(sourceFile, 'utf8');
+    // Every one of these names the same file as `sourceFile`. A plain string
+    // comparison catches none of them, and the cost of missing one is the only
+    // unredacted copy of the capture.
+    fs_1.default.symlinkSync(sourceFile, linkPath);
+    const aliases = [
+        sourceFile,
+        path_1.default.join(dir, '.', base),
+        path_1.default.join(dir, 'x', '..', base),
+        linkPath,
+    ];
+    try {
+        for (const alias of aliases) {
+            yield expect((0, HeapAnonymizer_1.anonymizeHeapSnapshotFile)(sourceFile, alias)).rejects.toThrow(/same file/);
+        }
+        // and the input is untouched by the refusals
+        expect(fs_1.default.readFileSync(sourceFile, 'utf8')).toBe(before);
+        // a genuinely different path still works
+        const out = `${sourceFile}.out`;
+        yield (0, HeapAnonymizer_1.anonymizeHeapSnapshotFile)(sourceFile, out);
+        expect(fs_1.default.existsSync(out)).toBe(true);
+        fs_1.default.unlinkSync(out);
+    }
+    finally {
+        for (const file of [linkPath, sourceFile]) {
+            if (fs_1.default.existsSync(file) ||
+                fs_1.default.lstatSync(file, { throwIfNoEntry: false })) {
+                fs_1.default.unlinkSync(file);
+            }
+        }
+    }
+}), timeout);
+test('keepPatterns and shouldRedact(false) protect string VALUES, not just labels', () => __awaiter(void 0, void 0, void 0, function* () {
+    // Both options promise an entry is never redacted. The string-VALUE pass
+    // does not consult the content rules, so honouring them only there would
+    // silently break the promise for exactly the entries a caller named.
+    const keptByPattern = canaryVariant('keepme');
+    const keptByCallback = canaryVariant('callbackkeep');
+    const notKept = canaryVariant('notkept');
+    const holder = { a: keptByPattern, b: keptByCallback, c: notKept };
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    const out = `${sourceFile}.kept`;
+    try {
+        const before = fs_1.default.readFileSync(sourceFile, 'utf8');
+        for (const v of [keptByPattern, keptByCallback, notKept]) {
+            expect(before.includes(v)).toBe(true);
+        }
+        const heap = yield HeapParser_1.default.parse(sourceFile, {});
+        (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(heap, {
+            keepPatterns: [new RegExp(`${canaryValue()}-keepme$`)],
+            shouldRedact: value => (value === keptByCallback ? false : undefined),
+        });
+        (0, HeapSerializer_1.serializeHeapSnapshot)(heap, out);
+        const after = fs_1.default.readFileSync(out, 'utf8');
+        expect(after.includes(keptByPattern)).toBe(true);
+        expect(after.includes(keptByCallback)).toBe(true);
+        // the control: an unprotected value of the same shape is still redacted,
+        // so the assertions above cannot pass by anonymization simply not running
+        expect(after.includes(notKept)).toBe(false);
+    }
+    finally {
+        for (const file of [sourceFile, out]) {
+            if (fs_1.default.existsSync(file)) {
+                fs_1.default.unlinkSync(file);
+            }
+        }
+    }
+    expect(holder.a).toBe(keptByPattern);
+}), timeout);
+test('an out-of-range minDigitRunLength is rejected rather than matching everything', () => __awaiter(void 0, void 0, void 0, function* () {
+    const sourceFile = (0, NodeHeap_1.dumpNodeHeapSnapshot)();
+    try {
+        const heap = yield HeapParser_1.default.parse(sourceFile, {});
+        // `\d{0,}` matches every string, so this would redact the entire label
+        // vocabulary and still look like a successful run.
+        for (const bad of [0, -1, 2.5]) {
+            expect(() => (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(heap, { minDigitRunLength: bad })).toThrow(/positive integer/);
+        }
+        // a valid value is still honoured
+        expect(() => (0, HeapAnonymizer_1.anonymizeHeapSnapshot)(heap, { minDigitRunLength: 4 })).not.toThrow();
+    }
+    finally {
+        if (fs_1.default.existsSync(sourceFile)) {
+            fs_1.default.unlinkSync(sourceFile);
+        }
+    }
+}), timeout);

package/dist/__tests__/trace-cluster/MLTraceSimilarityStrategy.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 memory_lab
+ */
+export {};
+//# sourceMappingURL=MLTraceSimilarityStrategy.test.d.ts.map

package/dist/__tests__/trace-cluster/MLTraceSimilarityStrategy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MLTraceSimilarityStrategy.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/trace-cluster/MLTraceSimilarityStrategy.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/__tests__/trace-cluster/MLTraceSimilarityStrategy.test.js

@@ -0,0 +1,50 @@
+"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 memory_lab
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const MLTraceSimilarityStrategy_1 = __importDefault(require("../../trace-cluster/strategies/MLTraceSimilarityStrategy"));
+function newTrace() {
+    return [
+        { kind: 'node', id: 1, name: 'LeakedObject', type: 'object' },
+        { kind: 'edge', name_or_index: 'next', type: 'property' },
+    ];
+}
+function getTotalTraceCount(clusters) {
+    return clusters.reduce((sum, cluster) => sum + cluster.length, 0);
+}
+test('diffTraces includes each trace in a cluster exactly once', () => {
+    const strategy = new MLTraceSimilarityStrategy_1.default();
+    // a single trace still forms one cluster, and the representative trace
+    // must not be duplicated inside it
+    const single = strategy.diffTraces([newTrace()]);
+    expect(getTotalTraceCount(single.allClusters)).toBe(1);
+    // identical traces are clustered together; each trace should appear in
+    // the result exactly once
+    const traces = [newTrace(), newTrace(), newTrace()];
+    const result = strategy.diffTraces(traces);
+    expect(getTotalTraceCount(result.allClusters)).toBe(traces.length);
+    for (const cluster of result.allClusters) {
+        expect(new Set(cluster).size).toBe(cluster.length);
+    }
+});
+test('diffTraces keeps the representative trace at index 0', () => {
+    const strategy = new MLTraceSimilarityStrategy_1.default();
+    const traces = [newTrace(), newTrace(), newTrace()];
+    const { allClusters } = strategy.diffTraces(traces);
+    // HAC labels every trace in a cluster with the largest index in that
+    // cluster, so the representative of these identical traces is the last one.
+    // Downstream code (e.g. NormalizedTrace.clusterPaths) reads cluster[0] as
+    // the representative trace of the cluster.
+    expect(allClusters.length).toBe(1);
+    expect(allClusters[0][0]).toBe(traces[traces.length - 1]);
+});

package/dist/__tests__/utils/Utils.test.js

@@ -57,6 +57,17 @@ test('Check getReadableBytes', () => __awaiter(void 0, void 0, void 0, function*
     expect(Utils_1.default.getReadableBytes(2212312313)).toBe('2.2GB');
     expect(Utils_1.default.getReadableBytes(5432212312313)).toBe('5.4TB');
 }));
+test('Check getNumberAtPercentile', () => __awaiter(void 0, void 0, void 0, function* () {
+    expect(Utils_1.default.getNumberAtPercentile([], 80)).toBe(0);
+    expect(Utils_1.default.getNumberAtPercentile([10, 20, 30, 40, 50], 100)).toBe(50);
+    expect(Utils_1.default.getNumberAtPercentile([7], 100)).toBe(7);
+    expect(Utils_1.default.getNumberAtPercentile([10, 20, 30, 40, 50], 0)).toBe(10);
+    expect(Utils_1.default.getNumberAtPercentile([10, 20, 30, 40, 50], 80)).toBe(50);
+    expect(Utils_1.default.getNumberAtPercentile([5, 3, 1, 4, 2], 50)).toBe(3.5);
+    // out-of-range percentiles are clamped rather than returning undefined/NaN
+    expect(Utils_1.default.getNumberAtPercentile([10, 20, 30, 40, 50], -10)).toBe(10);
+    expect(Utils_1.default.getNumberAtPercentile([10, 20, 30, 40, 50], 120)).toBe(50);
+}));
 test('Check isStackTraceFrame', () => __awaiter(void 0, void 0, void 0, function* () {
     expect(Utils_1.default.isStackTraceFrame(strackTraceFrameNodeMock)).toBe(true);
     expect(Utils_1.default.isStackTraceFrame(oddBallNodeMock)).toBe(false);

package/dist/index.d.ts

@@ -9,6 +9,9 @@
  */
 export * from './lib/Types';
 export * from './lib/NodeHeap';
+export { serializeHeapSnapshot, serializeRawHeapSnapshot, } from './lib/HeapSerializer';
+export { anonymizeHeapSnapshot, anonymizeHeapSnapshotFile, anonymizeRawHeapSnapshot, auditHeapSnapshotFile, resolveForComparison, } from './lib/HeapAnonymizer';
+export type { AnonymizationMode, AnonymizeOptions, AnonymizeReport, AnonymizeRuleCount, RedactionContext, UnclassifiedLabelFamily, } from './lib/HeapAnonymizer';
 /** @internal */
 export declare function registerPackage(): Promise<void>;
 /** @internal */

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAE/B,gBAAgB;AAChB,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAErD;AACD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,MAAM,EAAC,MAAM,cAAc,CAAC;AAC/C,gBAAgB;AAChB,cAAc,2BAA2B,CAAC;AAC1C,gBAAgB;AAChB,cAAc,cAAc,CAAC;AAC7B,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,IAAI,EAAC,MAAM,eAAe,CAAC;AAC9C,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACvD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,KAAK,EAAC,MAAM,aAAa,CAAC;AAC7C,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,mBAAmB,CAAC;AACzD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAC3D,gBAAgB;AAChB,cAAc,mBAAmB,CAAC;AAClC,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACvD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,mBAAmB,CAAC;AACzD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AACvD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACnD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,6BAA6B,CAAC;AACtE,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,KAAK,EAAC,MAAM,sBAAsB,CAAC;AACtD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,sBAAsB,CAAC;AAC/D,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,MAAM,4BAA4B,CAAC;AACxE,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,6BAA6B,CAAC;AACvE,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,mCAAmC,CAAC;AAC9E,gBAAgB;AAChB,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,gBAAgB;AAChB,cAAc,yBAAyB,CAAC;AACxC,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AACrF,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,2BAA2B,EAAC,MAAM,6CAA6C,CAAC;AACnG,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,qBAAqB,CAAC;AAC3D,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kCAAkC,CAAC;AACvE,gBAAgB;AAChB,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,OAAO,EACL,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,sBAAsB,CAAC;AAE9B,gBAAgB;AAChB,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAErD;AACD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,MAAM,EAAC,MAAM,cAAc,CAAC;AAC/C,gBAAgB;AAChB,cAAc,2BAA2B,CAAC;AAC1C,gBAAgB;AAChB,cAAc,cAAc,CAAC;AAC7B,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,IAAI,EAAC,MAAM,eAAe,CAAC;AAC9C,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACvD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,KAAK,EAAC,MAAM,aAAa,CAAC;AAC7C,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,mBAAmB,CAAC;AACzD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAC3D,gBAAgB;AAChB,cAAc,mBAAmB,CAAC;AAClC,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACvD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,mBAAmB,CAAC;AACzD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AACvD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACnD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,6BAA6B,CAAC;AACtE,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,KAAK,EAAC,MAAM,sBAAsB,CAAC;AACtD,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,sBAAsB,CAAC;AAC/D,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,MAAM,4BAA4B,CAAC;AACxE,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,6BAA6B,CAAC;AACvE,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,mCAAmC,CAAC;AAC9E,gBAAgB;AAChB,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,gBAAgB;AAChB,cAAc,yBAAyB,CAAC;AACxC,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AACrF,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,2BAA2B,EAAC,MAAM,6CAA6C,CAAC;AACnG,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,qBAAqB,CAAC;AAC3D,gBAAgB;AAChB,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,kCAAkC,CAAC;AACvE,gBAAgB;AAChB,cAAc,8BAA8B,CAAC"}

package/dist/index.js

@@ -35,12 +35,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumericSet = exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.RunMetaInfoManager = 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 = void 0;
+exports.NumericSet = exports.TraceFinder = exports.MultiIterationSeqClustering = exports.SequentialClustering = exports.RunMetaInfoManager = 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.resolveForComparison = exports.auditHeapSnapshotFile = exports.anonymizeRawHeapSnapshot = exports.anonymizeHeapSnapshotFile = exports.anonymizeHeapSnapshot = exports.serializeRawHeapSnapshot = exports.serializeHeapSnapshot = void 0;
 exports.registerPackage = registerPackage;
 const path_1 = __importDefault(require("path"));
 const PackageInfoLoader_1 = require("./lib/PackageInfoLoader");
 __exportStar(require("./lib/Types"), exports);
 __exportStar(require("./lib/NodeHeap"), exports);
+var HeapSerializer_1 = require("./lib/HeapSerializer");
+Object.defineProperty(exports, "serializeHeapSnapshot", { enumerable: true, get: function () { return HeapSerializer_1.serializeHeapSnapshot; } });
+Object.defineProperty(exports, "serializeRawHeapSnapshot", { enumerable: true, get: function () { return HeapSerializer_1.serializeRawHeapSnapshot; } });
+var HeapAnonymizer_1 = require("./lib/HeapAnonymizer");
+Object.defineProperty(exports, "anonymizeHeapSnapshot", { enumerable: true, get: function () { return HeapAnonymizer_1.anonymizeHeapSnapshot; } });
+Object.defineProperty(exports, "anonymizeHeapSnapshotFile", { enumerable: true, get: function () { return HeapAnonymizer_1.anonymizeHeapSnapshotFile; } });
+Object.defineProperty(exports, "anonymizeRawHeapSnapshot", { enumerable: true, get: function () { return HeapAnonymizer_1.anonymizeRawHeapSnapshot; } });
+Object.defineProperty(exports, "auditHeapSnapshotFile", { enumerable: true, get: function () { return HeapAnonymizer_1.auditHeapSnapshotFile; } });
+Object.defineProperty(exports, "resolveForComparison", { enumerable: true, get: function () { return HeapAnonymizer_1.resolveForComparison; } });
 /** @internal */
 function registerPackage() {
     return __awaiter(this, void 0, void 0, function* () {