@memlab/mcp-server 2.18.1 → 2.86.0

package/dist/tools/what-if.js

@@ -0,0 +1,285 @@
+/**
+ * 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 memlabCore from '@memlab/core';
+import { z } from 'zod';
+import { getSnapshot, getSnapshotMetadata } from '../heap-state.js';
+import { boundedDominatorRetainedSize, errorResult, formatBytes, formatNumber, markdownTable, toolResult, } from '../utils.js';
+const { NumericSet } = memlabCore;
+function matchesShape(node, shape) {
+    const want = new Set(shape);
+    for (const e of node.references) {
+        if (e.type !== 'property')
+            continue;
+        want.delete(String(e.name_or_index));
+        if (want.size === 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Second-order collectability: what ELSE dies when this population goes away.
+ *
+ * The dominator-deduped figure is a floor by construction — it counts only what
+ * the population exclusively dominates. An object reachable by two paths, both
+ * of which run through the population, is dominated by neither member and so is
+ * counted by neither, yet it becomes garbage the moment they do. On a graph with
+ * shared substructure that is not a rounding error.
+ *
+ * Answering it properly means recomputing reachability, which is what this does:
+ * a BFS from the GC roots with the population's edges removed, compared against
+ * the same BFS with them present. It is O(N+E) twice rather than a dominator
+ * pass, so it is affordable, but it is a real graph walk and not a heuristic.
+ */
+function findRootIds(snapshot) {
+    const roots = [];
+    snapshot.nodes.forEach(node => {
+        if (roots.length > 0)
+            return;
+        if (node.type === 'synthetic' && node.name.includes('GC roots')) {
+            roots.push(node.id);
+        }
+    });
+    if (roots.length === 0) {
+        // Fall back to every node V8 marks as unreachable-from-nothing: the first
+        // node in a V8 snapshot is the root by convention.
+        snapshot.nodes.forEach(node => {
+            if (roots.length === 0)
+                roots.push(node.id);
+        });
+    }
+    return roots;
+}
+/**
+ * Reachability marking uses a flat byte array indexed by node id, not a Set.
+ * A Set of ids throws "Set maximum size exceeded" on a large server heap
+ * (observed on a 9.9M-node Node.js capture), and the failure lands in the
+ * middle of an otherwise-complete analysis. The array costs one byte per id
+ * slot — tens of MB on the largest heaps that load at all — and cannot hit a
+ * collection limit.
+ */
+function maxNodeId(snapshot) {
+    let max = 0;
+    snapshot.nodes.forEach(node => {
+        if (node.id > max)
+            max = node.id;
+    });
+    return max;
+}
+function reachableFrom(snapshot, rootIds, removed, maxId) {
+    const seen = new Uint8Array(maxId + 1);
+    const stack = [];
+    for (const id of rootIds) {
+        if (id > maxId || removed[id] === 1)
+            continue;
+        seen[id] = 1;
+        stack.push(id);
+    }
+    while (stack.length > 0) {
+        const id = stack.pop();
+        const node = snapshot.getNodeById(id);
+        if (node == null)
+            continue;
+        for (const edge of node.references) {
+            // A weak edge does not keep its target alive, so following it would
+            // report objects as surviving that a real GC would collect.
+            if (edge.type === 'weak')
+                continue;
+            const toId = edge.toNode.id;
+            if (toId > maxId || removed[toId] === 1 || seen[toId] === 1)
+                continue;
+            seen[toId] = 1;
+            stack.push(toId);
+        }
+    }
+    return seen;
+}
+export function registerWhatIf(server) {
+    server.tool('memlab_what_if', 'If this set of objects were freed, how many bytes would actually come back? Reports the dominator-deduped retained size of a population — the bytes that go away when it does, with nothing double-counted and nothing counted that is also reachable another way.\n\n' +
+        'This is the number every fix decision needs and the one that is easiest to get wrong by hand. Summing per-object retained sizes double-counts every nested object; quoting the class total counts memory that other live code still holds; quoting a container\'s retained size includes internals that survive. `memlab_detached_dom` already reports it for detached subtrees as "Owner Frees" — this makes the same question askable about any set.\n\n' +
+        'Specify the population by ids, class name, or property shape.', {
+        node_ids: z
+            .array(z.number())
+            .optional()
+            .describe('Explicit node ids to free (from any tool that reports ids).'),
+        class_name: z
+            .string()
+            .optional()
+            .describe('Free every instance of this class (exact name match).'),
+        shape: z
+            .array(z.string())
+            .optional()
+            .describe('Free every object carrying ALL of these properties — the usable selector on a minified heap.'),
+        breakdown: z
+            .boolean()
+            .optional()
+            .default(true)
+            .describe('Also report what the freed bytes consist of, grouped by the class of the dominated nodes (default true). Answers "am I freeing the records, or the data they point at?".'),
+        limit: z
+            .number()
+            .optional()
+            .default(12)
+            .describe('Rows in the breakdown table (default 12).'),
+        cascade: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe('Also compute the SECOND-ORDER effect: objects that become unreachable because the population was their last live referrer, even though no member dominated them. Recomputes reachability from the GC roots with the population removed (two O(N+E) walks — seconds on a multi-million-node heap, not instant). Off by default because the dominator figure alone is the conservative answer.'),
+    }, async ({ node_ids, class_name, shape, breakdown, limit, cascade }) => {
+        try {
+            const snapshot = getSnapshot();
+            const selectors = [
+                node_ids != null && node_ids.length > 0,
+                class_name != null,
+                shape != null && shape.length > 0,
+            ].filter(Boolean).length;
+            if (selectors === 0) {
+                return errorResult(new Error('Pass node_ids, class_name or shape to select what to free.'));
+            }
+            if (selectors > 1) {
+                return errorResult(new Error('Pass exactly one of node_ids / class_name / shape — combining them would make the reported population ambiguous.'));
+            }
+            const ids = [];
+            if (node_ids != null && node_ids.length > 0) {
+                for (const id of node_ids) {
+                    if (snapshot.getNodeById(id) != null)
+                        ids.push(id);
+                }
+                if (ids.length === 0) {
+                    return errorResult(new Error('None of those ids exist in the active snapshot. Node ids are per-capture — check the handle with memlab_snapshots.'));
+                }
+            }
+            else {
+                snapshot.nodes.forEach(node => {
+                    if (node.id <= 3)
+                        return;
+                    if (class_name != null) {
+                        if (node.name !== class_name)
+                            return;
+                    }
+                    else if (shape != null && !matchesShape(node, shape)) {
+                        return;
+                    }
+                    ids.push(node.id);
+                });
+            }
+            if (ids.length === 0) {
+                return toolResult(`Nothing matched, so there is nothing to free. Check the class name with \`memlab_class_histogram\` or the shape with \`memlab_shape_histogram\`.`);
+            }
+            const idSet = new NumericSet(ids);
+            const { retained, exact } = boundedDominatorRetainedSize(idSet, snapshot);
+            const meta = getSnapshotMetadata();
+            const heapTotal = meta?.totalSize ?? 0;
+            const share = heapTotal > 0 ? (retained / heapTotal) * 100 : 0;
+            let selfTotal = 0;
+            for (const id of ids) {
+                selfTotal += snapshot.getNodeById(id)?.self_size ?? 0;
+            }
+            const label = class_name != null
+                ? `class \`${class_name}\``
+                : shape != null
+                    ? `shape \`{${shape.join(', ')}}\``
+                    : `${formatNumber(ids.length)} explicit id(s)`;
+            const lines = [
+                `## What if ${label} were freed?`,
+                '',
+                `**${formatBytes(retained)} would be reclaimed**${exact ? '' : ' (upper bound — the dominator walk hit its depth cap)'}` +
+                    `${heapTotal > 0 ? `, ${share.toFixed(1)}% of the ${formatBytes(heapTotal)} heap` : ''}.`,
+                '',
+                `- Population: ${formatNumber(ids.length)} object(s)`,
+                `- Their own bytes (self size): ${formatBytes(selfTotal)}`,
+                `- Everything they exclusively dominate: ${formatBytes(retained)}`,
+                '',
+                retained > selfTotal * 2
+                    ? `Most of the win is in what these objects HOLD, not in the objects themselves (${formatBytes(retained - selfTotal)} of the total). Freeing them is worth it only if nothing else references that payload — which is exactly what dominator-deduped means, so this figure already accounts for it.`
+                    : "Nearly all of the win is the objects' own bytes; they hold little exclusively.",
+            ];
+            if (breakdown) {
+                // What the reclaimed bytes actually consist of. "Freeing 26 MB" reads
+                // very differently once you know 90% of it is one payload class.
+                const byClass = new Map();
+                const seen = new Set();
+                for (const id of ids) {
+                    const start = snapshot.getNodeById(id);
+                    if (start == null)
+                        continue;
+                    const stack = [start];
+                    while (stack.length > 0) {
+                        const n = stack.pop();
+                        if (seen.has(n.id))
+                            continue;
+                        seen.add(n.id);
+                        const key = `${n.name} (${n.type})`;
+                        const e = byClass.get(key) ?? { count: 0, bytes: 0 };
+                        e.count++;
+                        e.bytes += n.self_size;
+                        byClass.set(key, e);
+                        for (const edge of n.references) {
+                            const child = edge.toNode;
+                            if (child.id > 3 &&
+                                !seen.has(child.id) &&
+                                child.dominatorNode?.id === n.id) {
+                                stack.push(child);
+                            }
+                        }
+                    }
+                }
+                const rows = [...byClass.entries()]
+                    .sort((a, b) => b[1].bytes - a[1].bytes)
+                    .slice(0, limit)
+                    .map(([name, e]) => [
+                    name.length > 50 ? name.slice(0, 47) + '…' : name,
+                    formatNumber(e.count),
+                    formatBytes(e.bytes),
+                ]);
+                lines.push('', '### What the reclaimed bytes are', '', markdownTable(['Class', 'Nodes', 'Self size'], rows, new Set([1, 2])));
+            }
+            if (cascade) {
+                const maxId = maxNodeId(snapshot);
+                const removed = new Uint8Array(maxId + 1);
+                for (const id of ids)
+                    if (id <= maxId)
+                        removed[id] = 1;
+                const none = new Uint8Array(maxId + 1);
+                const roots = findRootIds(snapshot);
+                const before = reachableFrom(snapshot, roots, none, maxId);
+                const after = reachableFrom(snapshot, roots, removed, maxId);
+                let cascadeBytes = 0;
+                let cascadeNodes = 0;
+                for (let id = 0; id <= maxId; id++) {
+                    if (before[id] !== 1)
+                        continue;
+                    // The population's own bytes are already counted; this walk is
+                    // about what ELSE dies with it.
+                    if (after[id] === 1 || removed[id] === 1)
+                        continue;
+                    cascadeNodes++;
+                    cascadeBytes += snapshot.getNodeById(id)?.self_size ?? 0;
+                }
+                // The dominator figure splits into the population's own bytes plus
+                // what it exclusively dominates. Only the second part is comparable
+                // to the cascade walk, which excludes the population itself.
+                const dominatedNonSelf = Math.max(0, retained - selfTotal);
+                const extra = cascadeBytes - dominatedNonSelf;
+                const totalFreed = selfTotal + cascadeBytes;
+                lines.push('', '### Second-order effect (cascade)', '', `Recomputing reachability from ${formatNumber(roots.length)} GC root(s) with this population removed: **${formatNumber(cascadeNodes)} node(s) outside the population / ${formatBytes(cascadeBytes)} become unreachable**, against ${formatBytes(dominatedNonSelf)} that the population exclusively dominates.`, '', extra > 0
+                    ? `**${formatBytes(extra)} of that is second-order** — objects no member dominated (they were reachable by several paths, all of which ran through the population) but which nothing else keeps alive. Total freed including the population's own ${formatBytes(selfTotal)}: **${formatBytes(totalFreed)}**, against the ${formatBytes(retained)} dominator figure.`
+                    : extra === 0
+                        ? 'No second-order effect: the exclusively-dominated set is exactly what becomes unreachable.'
+                        : `The cascade walk found ${formatBytes(-extra)} LESS than the dominator figure claims is exclusively dominated. That is a discrepancy, not a saving — it means part of the dominated set stays reachable in this walk, most likely through an edge type the walk skips (weak) or a root the walk did not start from (${formatNumber(roots.length)} found). Trust the dominator figure and treat this cascade run as inconclusive.`, '', '_Reachability only. It does not model finalizers, and it treats weak edges as non-retaining (which is correct for collectability but means a WeakMap value shown as freed is freed only if its key also dies)._');
+            }
+            lines.push('', '_Counts only what this population EXCLUSIVELY dominates: anything also reachable from elsewhere stays and is not included. Second-order effects — objects that become collectable because a freed one was their last referrer without dominating them — are not in this figure, so treat it as a floor; pass `cascade: true` to measure them._');
+            return toolResult(lines.join('\n'));
+        }
+        catch (err) {
+            return errorResult(err);
+        }
+    });
+}
+//# sourceMappingURL=what-if.js.map

package/dist/tools/what-if.js.map

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

package/dist/utils.d.ts

@@ -40,12 +40,26 @@ export interface IncomingEdge extends EdgeSummary {
     from_node: NodeSummary;
 }
 export declare function truncateDomToTag(name: string): string;
+export declare const BLINK_TEMPLATE_ELISION = "<\u2026>";
+export declare function abbreviateBlinkTypeName(name: string): string;
 export declare function truncateNodeName(name: string, type: string, selfSize: number, maxLen?: number, aggressiveDom?: boolean): string;
 export declare function serializeNodeSummary(node: IHeapNode): NodeSummary;
 export declare function serializeNodeDetail(node: IHeapNode): NodeDetail;
 export declare function serializeOutgoingEdge(edge: IHeapEdge): OutgoingEdge;
 export declare function serializeIncomingEdge(edge: IHeapEdge): IncomingEdge;
-export declare function isNodeWorthInspecting(node: IHeapNode): boolean;
+/**
+ * Whether a node is worth showing in a default "interesting objects" listing.
+ *
+ * `NODE_TYPE_BLOCK_LIST` exists to keep noise out of the DEFAULT view — it is not
+ * meant to make those types unreachable. When a caller explicitly asks for one
+ * of them (e.g. `largest_objects({node_type: 'array'})`), honour the request:
+ * otherwise the filter silently returns zero rows for `array`, `native`, `code`,
+ * `synthetic` and `hidden`, which reads as "there are none" on a heap that
+ * plainly contains 100k+ of them.
+ */
+export declare function isNodeWorthInspecting(node: IHeapNode, opts?: {
+    allowBlockedTypes?: boolean;
+}): boolean;
 /**
  * Property names that mark a "freshness" timestamp on a TTL/warm cache wrapper
  * object (e.g. `{entries, loadedAt}`, `{items, timestamp}`). Their presence next
@@ -71,6 +85,21 @@ export declare function hasFreshnessTimestampSibling(node: IHeapNode): boolean;
  */
 export declare function looksLikeFailurePayload(value: string): boolean;
 export declare function filterLargestObjects(snapshot: IHeapSnapshot, filter: (node: IHeapNode) => boolean, limit: number): IHeapNode[];
+/**
+ * As `filterLargestObjects`, but also reports how many nodes MATCHED.
+ *
+ * The population size is not a nicety. A conclusion drawn from the top 5 of a
+ * matching population reads identically whether that population was 5 or 23,918,
+ * and the difference decides whether the conclusion is sound: one report stated
+ * "all 5 sampled instances share the same retainer pattern — likely a single
+ * root cause" where a full-population trace found 1,468 distinct paths, the
+ * largest covering 2.2%. The sample fraction has to reach the caller, so the
+ * walk that already visits every node returns it.
+ */
+export declare function filterLargestObjectsCounted(snapshot: IHeapSnapshot, filter: (node: IHeapNode) => boolean, limit: number): {
+    nodes: IHeapNode[];
+    matched: number;
+};
 /**
  * Collapse heap nodes that are merely different VIEWS of the same dominator
  * subtree (e.g. on a single in-flight request: Client → Request → closure →
@@ -128,6 +157,85 @@ export declare function boundedDominatorRetainedSize(ids: HeapNodeIdSet, snapsho
     retained: number;
     exact: boolean;
 };
+/**
+ * One backing-store slot of a Map/Set/WeakMap: its true FixedArray index
+ * (`name_or_index`) and the heap node it points at.
+ */
+export interface BackingSlot {
+    idx: number;
+    node: IHeapNode;
+}
+/**
+ * One enumerated Map/WeakMap entry. `value` is null when the value slot held an
+ * inline SMI (no heap edge) — see `enumerateMapEntries`.
+ */
+export interface CollectionEntry {
+    key: IHeapNode;
+    value: IHeapNode | null;
+}
+/**
+ * Collect the object-valued slots of a Map/Set/WeakMap backing store, sorted by
+ * their true FixedArray slot index.
+ *
+ * V8 stores entries in an OrderedHashMap/OrderedHashSet reachable via the
+ * `table` (or `backing_store`) edge. Browser (Chromium) snapshots type the
+ * key/value slot edges as `internal` with a numeric name (the array index);
+ * Node snapshots type them `element`. The header counts and hash-chain links are
+ * inline SMIs, which emit NO edge at all — so the slot indices are NOT
+ * contiguous, and the GAPS are meaningful (they mark SMI-valued or deleted
+ * slots). Returning the slots WITH their indices lets callers pair by index
+ * instead of by position, which is what makes the pairing correct when some
+ * values are SMIs (see `enumerateMapEntries`).
+ */
+export declare function collectBackingSlots(node: IHeapNode): BackingSlot[];
+/**
+ * Enumerate a Map/WeakMap's (key, value) entries.
+ *
+ * V8 lays each entry out as consecutive slots `[key, value, chain]` (the chain
+ * link is an inline SMI, so it emits no edge). We therefore pair a key with the
+ * value in the immediately-following slot INDEX (`key.idx + 1`). When no slot
+ * exists at `key.idx + 1`, the value was an inline SMI/primitive and we emit
+ * `value: null` — instead of mispairing the key with the NEXT entry's key, which
+ * is what naive "consecutive object edges = key,value" pairing does whenever a
+ * Map has SMI values (a real correctness bug on browser heaps).
+ */
+export declare function enumerateMapEntries(node: IHeapNode): CollectionEntry[];
+/** Enumerate a Set's elements (every occupied backing-store slot). */
+export declare function enumerateSetElements(node: IHeapNode): IHeapNode[];
+/**
+ * Property names that identify an individual record rather than describe its
+ * content — always unique per instance, so INCLUDING them in a content
+ * signature defeats duplicate detection (every record looks distinct). Excluded
+ * by default from `objectContentSignature`. `id`/`__id`/`__ref` are Relay/GraphQL
+ * data-id fields; `key`/`clientMutationId` are common per-instance keys.
+ */
+export declare const IDENTITY_PROPS: ReadonlySet<string>;
+/**
+ * A stable, shallow content signature for an object: the sorted set of property
+ * names, each annotated with its scalar value (strings capped) or a marker for
+ * object/array-valued properties. Two objects with the same signature are
+ * structurally identical at one level — the basis for duplicate-record
+ * detection (`memlab_duplicate_objects`) and ad-hoc dedup checks in eval.
+ *
+ * By default per-instance identity fields (`IDENTITY_PROPS`: id/__id/__ref/…) are
+ * EXCLUDED so records that differ only by their data-id still collapse together
+ * — pass `ignoreProps` to override the set (e.g. `new Set()` to include them).
+ *
+ * String, boolean, null and object-valued properties are captured (objects
+ * generically as `o`, so nested content is not compared).
+ *
+ * Caveat — numeric values are NOT captured: the V8 heap-snapshot format does not
+ * store the actual value of a number field (SMI nodes are `smi number`,
+ * heap-numbers are `heap number` — the IEEE-754/int value is not accessible; see
+ * `tools/get-value.ts`). A numeric property therefore contributes only a generic
+ * `<name>=n` marker, so two objects differing ONLY in a numeric field hash to the
+ * same signature and are reported as duplicates. Treat numeric-heavy records
+ * accordingly (or compare their values via another tool).
+ */
+export declare function objectContentSignature(node: IHeapNode, opts?: {
+    maxStringLen?: number;
+    ignoreProps?: ReadonlySet<string>;
+}): string;
 /**
  * Best-effort detection of which app a Node snapshot came from, by tallying the
  * `/app(s)/<name>/` segment in bundle paths embedded throughout the heap (string
@@ -149,6 +257,54 @@ export declare function instrumentationRetainerNote(steps: Array<{
     name: string;
     edgeName?: string;
 }>): string | null;
+/**
+ * The nearest owner reachable by a NAMED property, plus HOW the target hangs
+ * off it. `Owner.prop` alone is not an address — the anchor is frequently an
+ * ancestor, and reading it as the object's own location is wrong for a large
+ * fraction of a real heap.
+ *
+ * Measured over 3,009 candidate objects on one browser capture: 1,815 hung
+ * directly off a named property, 1,084 were entries inside a Map or array, and
+ * 105 were variables captured in a closure. For the closure cases the bare
+ * anchor also DISCARDED the local variable name — `EMOJI_LIST`,
+ * `fbTop50Emojis`, `specialTags` were each reported under an unrelated
+ * sibling's property name, which is the single most greppable thing about them.
+ *
+ * Grouping by the immediate referrer edge does not work either: objects held in
+ * a Map are keyed by a numeric slot index in the backing table, so 552
+ * identical objects fragment into 552 groups of one. And in a minified bundle
+ * the class name is `Object` for all of them.
+ */
+export interface NamedOwner {
+    /** `<OwnerClass>.<property>` — the greppable part. */
+    anchor: string;
+    /**
+     * `null` when the anchor IS the target's own property slot; otherwise how the
+     * target sits under it (`entry`, `closure var caches`, ...).
+     */
+    relation: string | null;
+    /** `anchor`, or `anchor ▸ relation` — what to show a reader. */
+    label: string;
+    ownerNode: IHeapNode;
+    hops: number;
+}
+export declare function nearestNamedOwner(node: IHeapNode, opts?: {
+    maxHops?: number;
+}): NamedOwner | null;
+export interface EphemeronEdge {
+    keyName: string;
+    keyId: number;
+    valueName: string;
+    valueId: number;
+}
+/** Parse a WeakMap ephemeron edge name, or `null` if it is an ordinary edge. */
+export declare function parseEphemeronEdge(edgeName: string | undefined | null): EphemeronEdge | null;
+/**
+ * The caveat to print when a path traverses an ephemeron edge. `atTarget` marks
+ * the case where it is the LAST hop, which is the one that invalidates the
+ * conclusion outright rather than merely complicating it.
+ */
+export declare function ephemeronCaveat(eph: EphemeronEdge, atTarget: boolean): string;
 export declare function formatBytes(bytes: number): string;
 export declare function formatNumber(n: number): string;
 export declare function markdownTable(headers: string[], rows: string[][], alignRight?: Set<number>): string;
@@ -169,7 +325,39 @@ export interface RetainerTreeStep {
     edgeName?: string;
     collapsedBefore?: number;
     collapsedNote?: string;
+    repeatCount?: number;
 }
+/**
+ * Collapse runs of consecutive same-class hops in a retainer path into a single
+ * step tagged with `repeatCount`.
+ *
+ * Linked structures (a React hook update queue's `pending → .next → .next → …`,
+ * intrusive lists, promise chains) produce paths that are hundreds of identical
+ * `Object → Object → Object` hops long. Rendering every hop costs thousands of
+ * tokens and tells the reader nothing the count doesn't: the interesting part is
+ * the chain's head, its length, and where it attaches. This keeps the first hop
+ * of each run (so the edge into the run is preserved) and folds the rest.
+ *
+ * Only runs of at least `minRun` are collapsed, so ordinary short paths render
+ * exactly as before.
+ */
+export declare function collapseRepeatedRuns(steps: RetainerTreeStep[], minRun?: number): RetainerTreeStep[];
+/**
+ * Collapse runs of an identical rendered label, for formatters that have already
+ * reduced each hop to a string. Mirrors `collapseRepeatedRuns` for chain-style
+ * (`A → B → C`) renderers.
+ */
+export declare function collapseRepeatedLabels(labels: string[], minRun?: number): string[];
+/**
+ * One-line note describing what a tool's thresholds excluded from its own
+ * output. Printing this everywhere a default threshold exists prevents the
+ * failure mode where a tool reports "0" or "none found" and the reader takes it
+ * as "there is nothing there", when in fact everything interesting was below the
+ * cutoff. (A `dev_artifacts` run reporting `0 B` dev-only — because every
+ * console-retained string was under the 512 KB default — nearly landed a
+ * measurement artifact in a diff as a production leak.)
+ */
+export declare function describeSkipped(examined: number, skipped: number, thresholdLabel: string): string;
 /**
  * Render a retainer path so it reads in a single, unambiguous direction: the GC
  * root is at the top, and **every node is retained by the one above it**. The
@@ -191,15 +379,57 @@ export declare function formatRetainerTree(steps: RetainerTreeStep[], opts?: {
     maxTreeDepth?: number;
 }): string;
 export declare function formatNodeSummaryTable(nodes: NodeSummary[]): string;
+/**
+ * Legend for elided C++ template arguments, emitted only when something in the
+ * rendered output actually carries the marker — an unconditional legend is the
+ * same token tax the abbreviation exists to remove.
+ */
+export declare function blinkLegend(rendered: Iterable<string>): string;
 export declare function formatQueryNodesResult(result: QueryNodesResult, offset?: number): string;
+/**
+ * Build a name filter from a caller-supplied pattern.
+ *
+ * Interpreted as a case-insensitive regular expression, falling back to a plain
+ * case-insensitive substring test when the pattern is not valid regex — so a
+ * literal like `blink::UndoStep` works without escaping and a real pattern
+ * still works. An empty/absent pattern matches everything.
+ *
+ * Why this exists: answering "is `blink::UndoStep` present?" previously meant
+ * `class_histogram({node_type: "native", limit: 200})` and reading ~4 KB of
+ * table for one row. Filtering at the source is the difference between a
+ * yes/no answer and a page of output.
+ */
+export declare function makeNamePatternTest(pattern: string | undefined): (name: string) => boolean;
 export declare function snapshotHeader(): string;
+/**
+ * The header for a tool that read snapshots given as PATHS.
+ *
+ * `snapshotHeader()` can only ever describe the RESIDENT snapshot, because that
+ * is the only one the session knows about. For a path-taking tool that is the
+ * wrong file by construction whenever the caller has something else loaded —
+ * and these tools restore the caller's active snapshot before they build their
+ * result (see `withSnapshotAt`), so by the time the header is rendered the
+ * snapshot it names is never the one that was measured.
+ *
+ * Measured across a 12-round investigation: every path-based call printed a
+ * header naming a capture from an earlier round. A ladder result labelled with
+ * another round's rung is a cross-round misattribution hazard in exactly the
+ * workflow these tools exist for, so name what was actually read.
+ */
+export declare function pathsHeader(labels: readonly string[]): string;
 export declare function textResult(text: string): {
     content: {
         type: "text";
         text: string;
     }[];
 };
-export declare function toolResult(text: string): {
+/**
+ * @param headerOverride Pass `pathsHeader([...])` when the tool read snapshots
+ * by PATH rather than operating on the resident one. Passing `null` suppresses
+ * the header entirely. Omitting it keeps the session-header behaviour, which is
+ * correct only for tools that genuinely act on the active snapshot.
+ */
+export declare function toolResult(text: string, headerOverride?: string | null): {
     content: {
         type: "text";
         text: string;
@@ -208,9 +438,14 @@ export declare function toolResult(text: string): {
 /**
  * Whether tools should omit "Suggested next steps" / "How to fix" trailers.
  * Honors the session-level `suppressSuggestions` config so callers can trim
- * repeated boilerplate tokens across a long investigation.
+ * repeated boilerplate tokens across a long investigation, and self-suppresses
+ * after `SUGGESTION_TRAILER_BUDGET` trailers.
+ *
+ * NOTE: this both reads and ADVANCES the budget, so call it once per decision.
  */
 export declare function suggestionsSuppressed(): boolean;
+/** Test seam; also reset when the session config is changed explicitly. */
+export declare function resetSuggestionBudget(): void;
 export declare function jsonResult(data: unknown): {
     content: {
         type: "text";

package/dist/utils.d.ts.map

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