@memlab/mcp-server 2.18.1 → 2.86.0

package/dist/guardrail.js

@@ -9,6 +9,7 @@
  */
 import { beginAnalysisBudget, endAnalysisBudget, getAnalysisTimeoutMs, activeElapsedMs, ScanTimeoutError, } from './analysis-budget.js';
 import { toolResult } from './utils.js';
+import { recordToolHandler } from './tool-registry.js';
 /**
  * Install a process-wide wall-clock guardrail around every tool call.
  *
@@ -29,6 +30,18 @@ export function installAnalysisGuardrail(server) {
         const handler = toolArgs[lastIdx];
         if (typeof handler === 'function') {
             const inner = handler;
+            // Index the raw handler plus its zod shape so tools can dispatch to each
+            // other in-process without re-entering the budget, and without losing the
+            // schema defaults the SDK would normally apply (see tool-registry.ts).
+            // Registration is tool(name, description?, shape?, handler): the shape is
+            // whatever plain object sits immediately before the handler.
+            const maybeShape = lastIdx > 0 ? toolArgs[lastIdx - 1] : undefined;
+            const shape = maybeShape != null &&
+                typeof maybeShape === 'object' &&
+                !Array.isArray(maybeShape)
+                ? maybeShape
+                : null;
+            recordToolHandler(name, inner, shape);
             toolArgs[lastIdx] = async (...hArgs) => {
                 // The SDK calls handler(args, extra) for schema tools, handler(extra)
                 // otherwise. Read an optional per-call timeout_ms off the params.

package/dist/guardrail.js.map

@@ -1 +1 @@
-{"version":3,"file":"guardrail.js","sourceRoot":"","sources":["../src/guardrail.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAC,UAAU,EAAC,MAAM,YAAY,CAAC;AAItC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,wBAAwB,CAAC,MAAiB;IACxD,MAAM,QAAQ,GAAI,MAAM,CAAC,IAAc,CAAC,IAAI,CAAC,MAAM,CAAU,CAAC;IAC7D,MAAmC,CAAC,IAAI,GAAG,CAAC,GAAG,QAAmB,EAAE,EAAE;QACrE,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACjC,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;QACpC,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE,CAAC;YAClC,MAAM,KAAK,GAAG,OAAgB,CAAC;YAC/B,QAAQ,CAAC,OAAO,CAAC,GAAG,KAAK,EAAE,GAAG,KAAgB,EAAE,EAAE;gBAChD,sEAAsE;gBACtE,kEAAkE;gBAClE,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;gBACxB,MAAM,QAAQ,GACZ,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,YAAY,IAAI,MAAM;oBAC5D,CAAC,CAAE,MAAiC,CAAC,UAAU;oBAC/C,CAAC,CAAC,SAAS,CAAC;gBAChB,MAAM,SAAS,GAAG,oBAAoB,CACpC,OAAO,QAAQ,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CACpD,CAAC;gBACF,mBAAmB,CAAC,SAAS,CAAC,CAAC;gBAC/B,IAAI,CAAC;oBACH,OAAO,MAAM,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC;gBAC/B,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,IAAI,CAAC,YAAY,gBAAgB,EAAE,CAAC;wBAClC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,GAAG,IAAI,CAAC,CAAC;wBACjD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;wBAC3C,OAAO,UAAU,CACf,yBAAyB,IAAI,mBAAmB,KAAK,qBAAqB,GAAG,2FAA2F;4BACtK,uDAAuD;4BACvD,8GAA8G;4BAC9G,8GAA8G;4BAC9G,2JAA2J;4BAC3J,wIAAwI,KAAK,uBAAuB,CACvK,CAAC;oBACJ,CAAC;oBACD,MAAM,CAAC,CAAC;gBACV,CAAC;wBAAS,CAAC;oBACT,iBAAiB,EAAE,CAAC;gBACtB,CAAC;YACH,CAAC,CAAC;QACJ,CAAC;QACD,OAAO,QAAQ,CAAC,GAAG,QAAQ,CAAC,CAAC;IAC/B,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"guardrail.js","sourceRoot":"","sources":["../src/guardrail.ts"],"names":[],"mappings":"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"}

package/dist/heap-budget.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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
+ */
+import type { IHeapSnapshot } from '@memlab/core';
+import type { ArtifactKind } from './artifact-classes.js';
+import type { DevOnlyTotals, DevRootCategory } from './tools/dev-artifacts.js';
+export interface HeapBudget {
+    total: number;
+    app: number;
+    appNodes: number;
+    bundle: number;
+    code: number;
+    devOnly: number;
+    artifact: number;
+    /** Known-artifact self bytes split by family (warmup / ax / cdp-* / …). */
+    artifactByKind: Map<ArtifactKind, number>;
+    /** Dev-only totals split by root family, or null when no dev roots exist. */
+    devOnlyTotals: DevOnlyTotals | null;
+}
+export declare function computeHeapBudget(snapshot: IHeapSnapshot): HeapBudget;
+export declare function devFamilyBytes(budget: HeapBudget): Array<{
+    family: DevRootCategory;
+    nodes: number;
+    selfBytes: number;
+}>;
+//# sourceMappingURL=heap-budget.d.ts.map

package/dist/heap-budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap-budget.d.ts","sourceRoot":"","sources":["../src/heap-budget.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAY,aAAa,EAAC,MAAM,cAAc,CAAC;AAE3D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,uBAAuB,CAAC;AAMxD,OAAO,KAAK,EAAC,aAAa,EAAE,eAAe,EAAC,MAAM,0BAA0B,CAAC;AAmB7E,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,cAAc,EAAE,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC1C,6EAA6E;IAC7E,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;CACrC;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,aAAa,GAAG,UAAU,CA2DrE;AAED,wBAAgB,cAAc,CAC5B,MAAM,EAAE,UAAU,GACjB,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,CAAC,CAapE"}

package/dist/heap-budget.js

@@ -0,0 +1,90 @@
+/**
+ * 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
+ */
+import { classifyArtifact } from './artifact-classes.js';
+import { collectDevRoots, computeReachableWithoutDevRoots, summarizeDevOnly, } from './tools/dev-artifacts.js';
+/**
+ * The one bucket split of a heap into "app" and the several distinct reasons a
+ * byte might not be the app.
+ *
+ * Extracted so `memlab_app_heap` and `memlab_artifact_budget` cannot drift: they
+ * are two views of the same partition, and two implementations of "what counts
+ * as the app" that disagree by a few percent is worse than either one alone,
+ * because the disagreement is invisible in each tool's own output.
+ */
+const CODE_TYPES = new Set(['code']);
+// Bundle source text and the V8 structures that hold it. These exist because
+// the app was *loaded*, not because it did anything.
+const BUNDLE_NAME_RE = /ExternalStringData|InstructionStream|BytecodeArray|SharedFunctionInfo|ScopeInfo|UncompiledData|FeedbackVector|FeedbackMetadata|FeedbackCell|ClosureFeedbackCellArray|\(constant pool\)|ConstantPool/;
+export function computeHeapBudget(snapshot) {
+    const devRoots = collectDevRoots(snapshot);
+    const reached = devRoots.byId.size > 0
+        ? computeReachableWithoutDevRoots(snapshot, devRoots)
+        : null;
+    let total = 0;
+    let code = 0;
+    let bundle = 0;
+    let devOnly = 0;
+    let artifact = 0;
+    let app = 0;
+    let appNodes = 0;
+    const artifactByKind = new Map();
+    const isDevOnly = (node) => reached != null && reached[node.nodeIndex] === 0;
+    snapshot.nodes.forEach((node) => {
+        if (node.id <= 3)
+            return;
+        const size = node.self_size;
+        total += size;
+        // Precedence matters: a node is counted once, in the most specific bucket
+        // that explains why it is NOT app memory.
+        if (isDevOnly(node)) {
+            devOnly += size;
+            return;
+        }
+        if (CODE_TYPES.has(node.type)) {
+            code += size;
+            return;
+        }
+        if (BUNDLE_NAME_RE.test(node.name)) {
+            bundle += size;
+            return;
+        }
+        const kind = classifyArtifact(node.name);
+        if (kind != null) {
+            artifact += size;
+            artifactByKind.set(kind, (artifactByKind.get(kind) ?? 0) + size);
+            return;
+        }
+        app += size;
+        appNodes++;
+    });
+    return {
+        total,
+        app,
+        appNodes,
+        bundle,
+        code,
+        devOnly,
+        artifact,
+        artifactByKind,
+        devOnlyTotals: reached != null ? summarizeDevOnly(snapshot, devRoots, reached) : null,
+    };
+}
+export function devFamilyBytes(budget) {
+    const out = [];
+    const byCategory = budget.devOnlyTotals?.byCategory;
+    if (byCategory == null)
+        return out;
+    for (const [family, v] of byCategory) {
+        out.push({ family, nodes: v.nodes, selfBytes: v.selfBytes });
+    }
+    out.sort((a, b) => b.selfBytes - a.selfBytes);
+    return out;
+}
+//# sourceMappingURL=heap-budget.js.map

package/dist/heap-budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap-budget.js","sourceRoot":"","sources":["../src/heap-budget.ts"],"names":[],"mappings":"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"}

package/dist/heap-shapes.d.ts

@@ -0,0 +1,148 @@
+/**
+ * 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
+ */
+/**
+ * V8 elements-backing-store primitives, in one place.
+ *
+ * Reading an object's elements store correctly needs five separate facts, and
+ * each of them was got WRONG once before it was got right. They are stated here
+ * so no tool has to rediscover them:
+ *
+ *   1. A plain `Object` with integer keys emits an `element` edge per non-hole
+ *      slot ON THE OWNER, small-integer values included (they point at a shared
+ *      `smi number` node).
+ *   2. A `JSArray` frequently emits nothing on the owner and instead emits
+ *      `internal` numeric edges ON THE STORE — but only for slots holding a
+ *      heap object, so an all-SMI array reads as empty from there.
+ *   3. Therefore, when both sides read zero the occupancy is UNKNOWABLE: a
+ *      `new Array(34)` of holes and an array of 34 timestamps are byte-identical
+ *      in a snapshot. Scoring those as empty ranked 4,301 all-SMI index arrays
+ *      as the second-largest "finding" in one run.
+ *   4. Capacity is `(storeBytes - 8) / slotBytes`, and `slotBytes` must be
+ *      MEASURED. Wrong by 2x, it either invents slack that does not exist or
+ *      classifies every dense store as a dictionary.
+ *   5. `maxIndex + 1 > capacity` means dictionary mode, where a hole costs
+ *      nothing and "waste" is not defined.
+ */
+import type { IHeapNode, IHeapSnapshot } from '@memlab/core';
+/**
+ * Bytes of the FixedArray header preceding the first slot. Same on a
+ * pointer-compressed and an uncompressed heap (map + length), so only the slot
+ * width has to be calibrated.
+ */
+export declare const STORE_HEADER_BYTES = 8;
+/**
+ * V8 grows an elements store to `n + (n >> 1) + kMinAddedElementsCapacity`,
+ * with `kMinAddedElementsCapacity == 16`, so EVERY array built by `push`
+ * carries up to 16 slots of tail slack no application change can remove.
+ * Charging it turns a one-element array into a "94% empty" finding.
+ *
+ * https://github.com/v8/v8/blob/main/src/objects/js-objects.h
+ */
+export declare const FORGIVEN_TAIL_SLOTS = 16;
+export type SlotBytes = 4 | 8;
+export interface ElementsInfo {
+    storeId: number;
+    storeBytes: number;
+    slotBytes: SlotBytes;
+    /** Slots the backing store is sized for. */
+    capacity: number;
+    /** Slots holding a value. LOWER BOUND — see fact 3 above. */
+    used: number;
+    maxIndex: number;
+    /** `maxIndex + 1` — how far into the store the written keys reach. */
+    span: number;
+    /** Interior holes: written keys are sparse within their own span. */
+    holes: number;
+    /** Raw tail slack past the last written key, before any forgiveness. */
+    slack: number;
+    mode: 'dense' | 'dictionary';
+    /**
+     * `false` when nothing readable is in the store — it may be all holes or all
+     * small integers, and a snapshot cannot tell those apart. Callers must not
+     * count these as waste.
+     */
+    measurable: boolean;
+}
+/** The raw two-sided read, before capacity is derived from a slot width. */
+export interface RawElements {
+    store: IHeapNode;
+    /** Union occupancy: the owner's element edges are a superset of the store's. */
+    used: number;
+    maxIndex: number;
+}
+/** Read a node's elements store and its occupancy, or `null` if it has none. */
+export declare function readRawElements(node: IHeapNode): RawElements | null;
+/**
+ * Decide the slot width from evidence rather than assumption.
+ *
+ * A store whose largest written index fits in `(bytes - 8) / 4` slots but NOT
+ * in `(bytes - 8) / 8` can only be 4-byte-slotted. Dictionary-mode stores
+ * overflow both, so they cannot fake the signal. Pass any collection of
+ * observed `(storeBytes, maxIndex)` pairs; one witness is enough, and a real
+ * browser capture produces thousands.
+ */
+export declare function calibrateSlotBytes(samples: Iterable<{
+    storeBytes: number;
+    maxIndex: number;
+}>): SlotBytes;
+/**
+ * Memoized per-snapshot slot width for tools that do not already make their own
+ * pass. Stops as soon as it has enough witnesses, so on a real heap it reads a
+ * small prefix rather than the whole graph.
+ */
+export declare function getSlotBytes(snapshot: IHeapSnapshot): SlotBytes;
+/** Derive the full picture from a raw read and a slot width. */
+export declare function describeElements(raw: RawElements, slotBytes: SlotBytes): ElementsInfo | null;
+/**
+ * Every node that owns an elements store, as parallel typed arrays.
+ *
+ * Built once per snapshot and memoized. Four tools ask the same structural
+ * questions of the same nodes (does this own an elements store? how many
+ * element edges? what is the largest index? how big is the store?), and each
+ * was paying its own full pass — on a 7.1M-node / 41.7M-edge capture that is
+ * the dominant cost of the call, and tuning one tool's parameters re-pays it
+ * every time.
+ *
+ * Typed arrays rather than objects: on the capture above this is ~370k entries,
+ * which is 6 MB as four typed arrays and several times that as objects. The
+ * index is keyed by the snapshot, so a `keep_previous` A/B keeps one per arm and
+ * both are released when the snapshot is.
+ */
+export interface ElementsIndex {
+    /**
+     * Node ids that own an elements store, ascending by scan order.
+     *
+     * Unsigned: ids, byte counts and occupancies cannot be negative, and a
+     * signed 32-bit lane wraps anything past 2^31-1 to a negative number. For
+     * `ownerIds` that failure is silent rather than loud — `getNodeById(-…)`
+     * returns null, so the entry is skipped by every consumer instead of
+     * throwing. `maxIndex` stays signed because -1 is its "the store holds no
+     * numeric slot" sentinel, and a real element index above 2^31-1 would need a
+     * sparse array indexed past two billion.
+     *
+     * The unsigned lanes have their own ceiling at 2^32-1, and it is assumed
+     * rather than checked: V8 hands out snapshot node ids by increment, so
+     * exceeding it means one isolate allocated over four billion objects — far
+     * past the point where the snapshot itself is loadable here. A capture that
+     * did would truncate an id and quietly drop that entry, so if this ever needs
+     * to hold arbitrarily large captures, widen to `Float64Array` (ids stay exact
+     * to 2^53) rather than adding a guard.
+     */
+    ownerIds: Uint32Array;
+    storeBytes: Uint32Array;
+    used: Uint32Array;
+    maxIndex: Int32Array;
+    slotBytes: SlotBytes;
+    count: number;
+}
+export declare function getElementsIndex(snapshot: IHeapSnapshot): ElementsIndex;
+/** One-shot read for a single node, calibrating the snapshot if needed. */
+export declare function readElements(snapshot: IHeapSnapshot, node: IHeapNode): ElementsInfo | null;
+//# sourceMappingURL=heap-shapes.d.ts.map

package/dist/heap-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap-shapes.d.ts","sourceRoot":"","sources":["../src/heap-shapes.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAC,SAAS,EAAE,aAAa,EAAC,MAAM,cAAc,CAAC;AAE3D;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AAEpC;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,CAAC;AAE9B,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb,qEAAqE;IACrE,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,GAAG,YAAY,CAAC;IAC7B;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,4EAA4E;AAC5E,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,SAAS,CAAC;IACjB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI,CA4BnE;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,QAAQ,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAAC,GACxD,SAAS,CAWX;AAOD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS,CA6B/D;AAED,gEAAgE;AAChE,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,SAAS,GACnB,YAAY,GAAG,IAAI,CAmBrB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,WAAW,CAAC;IACxB,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC;IACrB,SAAS,EAAE,SAAS,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;AAID,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,CA4CvE;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,SAAS,GACd,YAAY,GAAG,IAAI,CAIrB"}

package/dist/heap-shapes.js

@@ -0,0 +1,193 @@
+/**
+ * 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
+ */
+/**
+ * Bytes of the FixedArray header preceding the first slot. Same on a
+ * pointer-compressed and an uncompressed heap (map + length), so only the slot
+ * width has to be calibrated.
+ */
+export const STORE_HEADER_BYTES = 8;
+/**
+ * V8 grows an elements store to `n + (n >> 1) + kMinAddedElementsCapacity`,
+ * with `kMinAddedElementsCapacity == 16`, so EVERY array built by `push`
+ * carries up to 16 slots of tail slack no application change can remove.
+ * Charging it turns a one-element array into a "94% empty" finding.
+ *
+ * https://github.com/v8/v8/blob/main/src/objects/js-objects.h
+ */
+export const FORGIVEN_TAIL_SLOTS = 16;
+/** Read a node's elements store and its occupancy, or `null` if it has none. */
+export function readRawElements(node) {
+    let store = null;
+    let ownerSlots = 0;
+    let maxIndex = -1;
+    for (const edge of node.references) {
+        if (edge.type === 'element') {
+            ownerSlots++;
+            const index = Number(edge.name_or_index);
+            if (index > maxIndex)
+                maxIndex = index;
+        }
+        else if (edge.type === 'internal' &&
+            String(edge.name_or_index) === 'elements') {
+            store = edge.toNode;
+        }
+    }
+    if (!store)
+        return null;
+    let storeSlots = 0;
+    for (const edge of store.references) {
+        const name = String(edge.name_or_index);
+        // Numeric edge names on the store are slot indices; `map` and friends are
+        // header fields, not contents.
+        if (!/^\d+$/.test(name))
+            continue;
+        storeSlots++;
+        const index = Number(name);
+        if (index > maxIndex)
+            maxIndex = index;
+    }
+    return { store, used: Math.max(ownerSlots, storeSlots), maxIndex };
+}
+/**
+ * Decide the slot width from evidence rather than assumption.
+ *
+ * A store whose largest written index fits in `(bytes - 8) / 4` slots but NOT
+ * in `(bytes - 8) / 8` can only be 4-byte-slotted. Dictionary-mode stores
+ * overflow both, so they cannot fake the signal. Pass any collection of
+ * observed `(storeBytes, maxIndex)` pairs; one witness is enough, and a real
+ * browser capture produces thousands.
+ */
+export function calibrateSlotBytes(samples) {
+    for (const s of samples) {
+        const slots = s.maxIndex + 1;
+        if (slots <= 0)
+            continue;
+        const at8 = (s.storeBytes - STORE_HEADER_BYTES) / 8;
+        const at4 = (s.storeBytes - STORE_HEADER_BYTES) / 4;
+        if (slots > at8 && slots <= at4)
+            return 4;
+    }
+    // Default to 4: every browser capture is pointer-compressed, and a heap with
+    // no witness either way is one where the difference changes no ranking.
+    return 4;
+}
+/** Witnesses needed before the scan stops early; more than enough to be sure. */
+const CALIBRATION_WITNESSES = 32;
+const slotBytesBySnapshot = new WeakMap();
+/**
+ * Memoized per-snapshot slot width for tools that do not already make their own
+ * pass. Stops as soon as it has enough witnesses, so on a real heap it reads a
+ * small prefix rather than the whole graph.
+ */
+export function getSlotBytes(snapshot) {
+    const cached = slotBytesBySnapshot.get(snapshot);
+    if (cached != null)
+        return cached;
+    const samples = [];
+    snapshot.nodes.forEach(node => {
+        // `false` is memlab's documented stop signal for this walk; a bare `return`
+        // only skips the current node, so returning undefined here kept iterating
+        // all 7M nodes of a large capture long after the 32nd witness. Every other
+        // `return` below is a per-node skip and must stay undefined.
+        if (samples.length >= CALIBRATION_WITNESSES)
+            return false;
+        if (node.type !== 'object' &&
+            node.type !== 'array' &&
+            node.type !== 'hidden')
+            return;
+        const raw = readRawElements(node);
+        if (!raw || raw.maxIndex < 0)
+            return;
+        const bytes = raw.store.self_size;
+        if (bytes <= STORE_HEADER_BYTES)
+            return;
+        const slots = raw.maxIndex + 1;
+        // Only witnesses that DISCRIMINATE are worth collecting.
+        if (slots > (bytes - STORE_HEADER_BYTES) / 8) {
+            samples.push({ storeBytes: bytes, maxIndex: raw.maxIndex });
+        }
+    });
+    const resolved = calibrateSlotBytes(samples);
+    slotBytesBySnapshot.set(snapshot, resolved);
+    return resolved;
+}
+/** Derive the full picture from a raw read and a slot width. */
+export function describeElements(raw, slotBytes) {
+    const storeBytes = raw.store.self_size;
+    if (storeBytes <= STORE_HEADER_BYTES)
+        return null;
+    const capacity = Math.floor((storeBytes - STORE_HEADER_BYTES) / slotBytes);
+    const span = raw.maxIndex + 1;
+    const dictionary = span > capacity;
+    return {
+        storeId: raw.store.id,
+        storeBytes,
+        slotBytes,
+        capacity,
+        used: raw.used,
+        maxIndex: raw.maxIndex,
+        span,
+        holes: dictionary ? 0 : Math.max(0, span - raw.used),
+        slack: dictionary ? 0 : Math.max(0, capacity - span),
+        mode: dictionary ? 'dictionary' : 'dense',
+        measurable: raw.used > 0,
+    };
+}
+const elementsIndexBySnapshot = new WeakMap();
+export function getElementsIndex(snapshot) {
+    const cached = elementsIndexBySnapshot.get(snapshot);
+    if (cached != null)
+        return cached;
+    const ownerIds = [];
+    const storeBytes = [];
+    const used = [];
+    const maxIndex = [];
+    snapshot.nodes.forEach(node => {
+        if (node.type !== 'object' &&
+            node.type !== 'array' &&
+            node.type !== 'hidden') {
+            return;
+        }
+        const raw = readRawElements(node);
+        if (!raw)
+            return;
+        const bytes = raw.store.self_size;
+        if (bytes <= STORE_HEADER_BYTES)
+            return;
+        ownerIds.push(node.id);
+        storeBytes.push(bytes);
+        used.push(raw.used);
+        maxIndex.push(raw.maxIndex);
+    });
+    const index = {
+        ownerIds: Uint32Array.from(ownerIds),
+        storeBytes: Uint32Array.from(storeBytes),
+        used: Uint32Array.from(used),
+        maxIndex: Int32Array.from(maxIndex),
+        // Calibrating from the entries just collected costs nothing extra and is
+        // strictly better evidence than the early-exit prefix scan.
+        slotBytes: calibrateSlotBytes(ownerIds.map((_, i) => ({
+            storeBytes: storeBytes[i],
+            maxIndex: maxIndex[i],
+        }))),
+        count: ownerIds.length,
+    };
+    elementsIndexBySnapshot.set(snapshot, index);
+    slotBytesBySnapshot.set(snapshot, index.slotBytes);
+    return index;
+}
+/** One-shot read for a single node, calibrating the snapshot if needed. */
+export function readElements(snapshot, node) {
+    const raw = readRawElements(node);
+    if (!raw)
+        return null;
+    return describeElements(raw, getSlotBytes(snapshot));
+}
+//# sourceMappingURL=heap-shapes.js.map

package/dist/heap-shapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap-shapes.js","sourceRoot":"","sources":["../src/heap-shapes.ts"],"names":[],"mappings":"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"}