@hydranium/cli 1.0.0-next.10

package/heap-analysis/heap/langium/concepts.mjs

@@ -0,0 +1,230 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+/*
+ * Concept-classification engine: shared heap-node helpers, the primitive / plain
+ * fallback (V8/JS universals, no language vocabulary), and `composeClassifiers`,
+ * which folds a set of ConceptClassifier contributions into the `classify` /
+ * `isAnchorConcept` / `conceptGroup` / `grammarTypes` the analyzer consumes.
+ *
+ * The engine knows no model vocabulary of its own — Langium and GLSP knowledge
+ * live in classifier contributions loaded by default, exactly the contract an
+ * adopter's `--classifier` file uses.
+ */
+
+/**
+ * @typedef {Object} ConceptClassifier
+ * @property {(node: import('@memlab/core').IHeapNode) => (string|undefined)} classify
+ *   Map a heap node to a concept label, or `undefined` to defer to the next
+ *   classifier / the engine fallback. Receives only `object`-typed nodes
+ *   (primitives are the engine's baseline).
+ * @property {string[]} [anchorConcepts] Concept labels this classifier owns as
+ *   exclusive-retained attribution anchors.
+ * @property {string[]} [grammarTypes] `$type`s from a meta-grammar that appear in
+ *   the heap but not an adopter document model (e.g. Langium's own grammar AST).
+ * @property {(label: string) => boolean} [isAnchor] Predicate for prefix-based
+ *   anchors (e.g. `AST node:*`); supplements `anchorConcepts`.
+ * @property {Record<string, string>} [descriptions] One-line explanations keyed by
+ *   root group (first label segment, e.g. `GModel`, `CST`), shown under that
+ *   group's heading in the hierarchical breakdown.
+ *
+ * A label is a `:`-delimited HIERARCHY PATH (`L1:L2:L3`, see {@link parseLabelPath}):
+ * the first segment is the display group and the analyzer aggregates at every
+ * prefix, so a classifier never declares a group — it just mints a path. Each
+ * segment must be `:`-free (spaces are fine); ≤3 levels is the readability
+ * convention, but aggregation is depth-agnostic and never truncates.
+ */
+
+/** Property-name set of a node's own named properties. */
+export function propertySet(node) {
+   const set = new Set();
+   for (const edge of node.references) {
+      if (edge.type === 'property' && !edge.is_index && edge.name_or_index !== '__proto__') {
+         set.add(edge.name_or_index);
+      }
+   }
+   return set;
+}
+
+/** Value of a string-valued property edge (e.g. the `$type` element kind). */
+export function stringProp(node, name) {
+   for (const edge of node.references) {
+      if (edge.type === 'property' && edge.name_or_index === name) {
+         const target = edge.toNode;
+         if (target && (target.type === 'string' || target.type === 'concatenated string')) {
+            return target.name;
+         }
+         return undefined;
+      }
+   }
+   return undefined;
+}
+
+/** True when a property set contains every named property. */
+export const has = (set, ...names) => names.every(name => set.has(name));
+
+/**
+ * Follow a property edge to its target object and read a string property off it
+ * (one hop of dereference). Used where a discriminator lives on a referenced node
+ * rather than inline — e.g. a leaf CST node's token type is `_tokenType.name`.
+ */
+export function derefStringProp(node, edgeName, prop) {
+   for (const edge of node.references) {
+      if (edge.type === 'property' && edge.name_or_index === edgeName && edge.toNode) {
+         return stringProp(edge.toNode, prop);
+      }
+   }
+   return undefined;
+}
+
+/**
+ * Read a discriminator property (e.g. `$type`/`type`) as a usable label segment.
+ * A concatenated/sliced string value cannot be materialized by memlab — it
+ * surfaces as a placeholder like `(concatenated string)`; treat any such
+ * unreadable value (and a missing one) as `unknown` rather than leaking the
+ * placeholder into a concept label.
+ */
+export function readableType(node, name = 'type') {
+   const value = stringProp(node, name);
+   return value && !value.startsWith('(') ? value : 'unknown';
+}
+
+/**
+ * Split a `:`-delimited label into its hierarchy segments: the first segment is
+ * the display group and each deeper segment a drill-down level. ≤3 levels is the
+ * convention, but parsing is depth-agnostic — it never truncates, so an adopter
+ * that emits a deeper path simply gets a deeper tree (and a `:`-free label is a
+ * 1-level leaf, which is always valid). Empty/blank → a single `(unknown)`
+ * segment so callers always get a non-empty group.
+ */
+export function parseLabelPath(label) {
+   const trimmed = (label ?? '').trim();
+   return trimmed ? trimmed.split(':') : ['(unknown)'];
+}
+
+/**
+ * Aggregate labelled buckets into a hierarchy keyed by the `:`-delimited label
+ * path. EVERY prefix accumulates, so a label `A:B:C` adds its sizes to nodes `A`,
+ * `A→B` and `A→B→C`; a parent's sizes are therefore exactly the sum of its
+ * descendants' leaf buckets (the reconciliation invariant the report relies on).
+ * Each tree node is `{ sizes: {count, shallow, exclusive, overlapping}, children:
+ * Map<segment, node> }`. No concept is hardcoded — the tree shape is whatever the
+ * labels imply.
+ *
+ * @param {Iterable<[string, {count: number, shallow: number, retainedOverlapping: number}]>} buckets
+ *   `[label, byBucket-entry]` pairs (the shallow/overlapping/count view per label).
+ * @param {(label: string) => number} exclusiveOf exclusive-retained bytes for a label.
+ * @returns {Map<string, {sizes: object, children: Map}>} the L1 group → subtree map.
+ */
+export function buildHierarchy(buckets, exclusiveOf) {
+   const root = new Map();
+   const ensure = (map, segment) => {
+      let node = map.get(segment);
+      if (!node) {
+         node = { sizes: { count: 0, shallow: 0, exclusive: 0, overlapping: 0 }, children: new Map() };
+         map.set(segment, node);
+      }
+      return node;
+   };
+   for (const [label, entry] of buckets) {
+      const exclusive = exclusiveOf(label);
+      let level = root;
+      for (const segment of parseLabelPath(label)) {
+         const node = ensure(level, segment);
+         node.sizes.count += entry.count;
+         node.sizes.shallow += entry.shallow;
+         node.sizes.exclusive += exclusive;
+         node.sizes.overlapping += entry.retainedOverlapping;
+         level = node.children;
+      }
+   }
+   return root;
+}
+
+/** Engine baseline for non-`object` heap nodes — V8/JS universals, no vocabulary. */
+function classifyPrimitive(type) {
+   switch (type) {
+      case 'string':
+         return 'string';
+      case 'concatenated string':
+         return 'string (concatenated)';
+      case 'sliced string':
+         return 'string (sliced)';
+      case 'number':
+         return 'boxed number';
+      case 'closure':
+         return 'closure';
+      case 'code':
+      case 'compiled code':
+         return 'code';
+      case 'array':
+         return 'array (backing)';
+      case 'hidden':
+         return 'hidden';
+      case 'synthetic':
+         return 'synthetic (roots)';
+      case 'native':
+         return 'native';
+      default:
+         return `(${type})`;
+   }
+}
+
+/** Engine fallback for an `object` node no classifier claimed. */
+function classifyObjectFallback(node) {
+   if (node.name && node.name !== 'Object') {
+      return `class:${node.name}`;
+   }
+   return propertySet(node).size === 0 ? 'empty object {}' : 'other Object shape';
+}
+
+/**
+ * Fold a set of {@link ConceptClassifier} contributions into the classification
+ * functions the analyzer consumes. Contributions are tried in order — first
+ * non-`undefined` `classify` wins — with the engine's primitive handling before
+ * them and its `class:<name>` / `other Object shape` fallback after. Anchors are
+ * the union of every contribution's `anchorConcepts` plus any `isAnchor`
+ * predicate; `grammarTypes` is the union of all contributions' grammar `$type`s.
+ *
+ * `conceptGroup` is structural, NOT contributed: a label's group is the first
+ * segment of its `:`-delimited path (see {@link parseLabelPath}). Since
+ * classifiers mint the label, the first segment IS the display group — there is
+ * no alias/rename layer to keep in sync.
+ *
+ * @param {ConceptClassifier[]} contributions
+ */
+export function composeClassifiers(contributions) {
+   const anchorSet = new Set(contributions.flatMap(contribution => contribution.anchorConcepts ?? []));
+   const grammarTypes = new Set(contributions.flatMap(contribution => contribution.grammarTypes ?? []));
+   // Merge group descriptions; earlier contributions win (adopter overrides default),
+   // so apply defaults first and the earlier contributions last.
+   const descriptions = Object.assign({}, ...[...contributions].reverse().map(contribution => contribution.descriptions ?? {}));
+
+   const classify = node => {
+      if (node.type !== 'object') {
+         return classifyPrimitive(node.type);
+      }
+      for (const contribution of contributions) {
+         const label = contribution.classify(node);
+         if (label !== undefined) {
+            return label;
+         }
+      }
+      return classifyObjectFallback(node);
+   };
+
+   const isAnchorConcept = label => anchorSet.has(label) || contributions.some(contribution => contribution.isAnchor?.(label) === true);
+
+   // The display group is structural: the first segment of the label path.
+   const conceptGroup = label => parseLabelPath(label)[0];
+
+   const describe = group => descriptions[group];
+
+   return { classify, isAnchorConcept, conceptGroup, grammarTypes, describe };
+}

package/heap-analysis/heap/langium/glsp.classifier.mjs

@@ -0,0 +1,80 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+/*
+ * GLSP GModel concept classifier — a default contribution for heads with a
+ * `@hydranium/glsp-server` diagram layer. GModel elements are class instances
+ * from `@eclipse-glsp/graph` (GGraph/GNode/GEdge/GLabel/GCompartment/…), each
+ * carrying a `type` string and the shared own-prop set
+ * {type,id,children,cssClasses}. So this mirrors CST (recognise by constructor)
+ * and AST (sub-label by the discriminator) at once: a GModel instance →
+ * `GModel:<type>` (the field is `type`, NOT `$type`).
+ *
+ * The `type` string is itself hierarchical by GLSP convention
+ * (`<kind>:<subtype>`), so the label becomes a 3-level path
+ * `GModel:<kind>:<subtype>` that the analyzer drills into (group `GModel`, then
+ * by kind `node`/`edge`/`comp`/`label`/`graph`, then by subtype). A flat `type`
+ * (`graph`, `label`) is simply a 2-level leaf — never wrong.
+ *
+ * The element vocabulary is framework-fixed (`@eclipse-glsp/graph`), so it ships
+ * as a default rather than behind discovery. On a non-GLSP heap it matches
+ * nothing and is inert. Only leaf option bags (`layoutOptions`/`args`) are plain
+ * objects — negligible mass — so no plain-object predicate is needed; the
+ * structural fallback catches any GModel subtype a head adds beyond this set.
+ */
+
+import { has, propertySet, readableType } from './concepts.mjs';
+
+/** `@eclipse-glsp/graph` element classes — the framework-fixed GModel vocabulary. */
+const GMODEL_CTORS = new Set([
+   'GGraph',
+   'GNode',
+   'GEdge',
+   'GLabel',
+   'GCompartment',
+   'GPort',
+   'GForeignObjectElement',
+   'GHtmlRoot',
+   'GIssueMarker'
+]);
+
+/** @type {import('./concepts.mjs').ConceptClassifier} */
+export const glspClassifier = {
+   classify(node) {
+      if (node.type !== 'object') {
+         return undefined;
+      }
+      const { name } = node;
+      if (name && GMODEL_CTORS.has(name)) {
+         return `GModel:${readableType(node)}`;
+      }
+      // Recognise any GModel element by its shared own-prop shape
+      // {type,id,children,cssClasses}, regardless of constructor name. A bundled
+      // server renames the classes (`_GLabel`) and heads add their own
+      // subclasses (`_AttributeCompartment`), so a name allow-list misses most
+      // of a real diagram — the structural signature is what holds. The shape is
+      // GLSP-specific, and Langium runs first, so only unclassified objects reach
+      // this check (no risk of stealing a model node).
+      if (has(propertySet(node), 'type', 'id', 'children', 'cssClasses')) {
+         return `GModel:${readableType(node)}`;
+      }
+      return undefined;
+   },
+
+   // Matches the raw per-node labels (exclusive-retained attribution anchors)
+   // and the bare group (`GModel`, retainer-path selection).
+   isAnchor(label) {
+      return label.startsWith('GModel');
+   },
+
+   descriptions: {
+      GModel:
+         'GLSP graphical-model elements for the open diagrams (nodes, edges, labels, ports, compartments). Sub-levels are the GLSP `type`, itself a `<kind>:<subtype>` path.'
+   }
+};

package/heap-analysis/heap/langium/langium.classifier.mjs

@@ -0,0 +1,203 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+/*
+ * Generic Langium/LSP concept classifier — the default contribution every run
+ * loads. Its `classify(node)` returns a Langium concept label or `undefined` to
+ * defer to the next classifier / the engine fallback. Recognises class instances
+ * by constructor and plain objects by their property-name set; AST nodes and
+ * descriptions are sub-labelled by `$type` / element kind so the report can
+ * break down by element. No application-specific vocabulary — heads contribute
+ * their own classifier alongside this one.
+ */
+
+import { derefStringProp, has, propertySet, stringProp } from './concepts.mjs';
+
+/** Concepts that own memory and act as exclusive-retained attribution anchors.
+ *  (CST/AST node/AstNodeDescription are matched by prefix in `isAnchor`.) */
+const ANCHOR_CONCEPTS = ['Range', 'Position', 'DocumentSegment', 'MultiMap', 'Map', 'LangiumDocument', 'ParseResult', 'Reference'];
+
+/**
+ * CST node constructors → their role, so CST drills down like AST
+ * (`CST:leaf`/`CST:composite`/`CST:root`/`CST:container`). Generic Langium names,
+ * no language coupling. A bundled server may prefix `_`, hence the lookup strips
+ * a leading underscore.
+ */
+const CST_ROLE = {
+   LeafCstNodeImpl: 'leaf',
+   CompositeCstNodeImpl: 'composite',
+   RootCstNodeImpl: 'root',
+   CstNodeContainer: 'container'
+};
+
+/**
+ * AST node $types from Langium's OWN grammar language. These appear in a
+ * language-server heap (the parsed .langium grammar) but never in an adopter's
+ * document model, so a `--validate` cross-check treats them as expected
+ * snapshot-only rather than a discrepancy. Generic Langium, not app-specific.
+ */
+const LANGIUM_GRAMMAR_TYPES = [
+   'Grammar',
+   'GrammarImport',
+   'AbstractRule',
+   'ParserRule',
+   'TerminalRule',
+   'InfixRule',
+   'Type',
+   'Interface',
+   'AbstractType',
+   'Action',
+   'Alternatives',
+   'Group',
+   'UnorderedGroup',
+   'Assignment',
+   'RuleCall',
+   'CrossReference',
+   'Keyword',
+   'RegexToken',
+   'TerminalAlternatives',
+   'TerminalGroup',
+   'TerminalRuleCall',
+   'CharacterRange',
+   'NegatedToken',
+   'UntilToken',
+   'Wildcard',
+   'EndOfFile',
+   'SimpleType',
+   'ReferenceType',
+   'ArrayType',
+   'UnionType',
+   'TypeAttribute',
+   'ParameterReference',
+   'ReturnType',
+   'NamedArgument',
+   'Parameter',
+   'Conjunction',
+   'Disjunction',
+   'Negation',
+   'BooleanLiteral',
+   'NumberLiteral',
+   'StringLiteral'
+];
+
+/** @type {import('./concepts.mjs').ConceptClassifier} */
+export const langiumClassifier = {
+   classify(node) {
+      const { type, name } = node;
+      if (type !== 'object') {
+         return undefined; // primitives are the engine's baseline
+      }
+
+      // Class instances: recognised by constructor name.
+      if (name && name !== 'Object') {
+         const cstRole = CST_ROLE[name.startsWith('_') ? name.slice(1) : name];
+         if (cstRole) {
+            // A leaf is a single token; sub-label by its token type
+            // (`_tokenType.name` — `ID`, `STRING`, or the keyword text), so the
+            // CST breakdown shows which tokens dominate (e.g. trivia vs identifiers).
+            if (cstRole === 'leaf') {
+               const token = derefStringProp(node, '_tokenType', 'name')?.trim();
+               if (!token) {
+                  return 'CST:leaf';
+               }
+               // Token names are either identifier-like (terminals `ID`/`STRING`,
+               // keywords `name`/`value`) or punctuation (`:`/`{`/`;`). Bucket
+               // punctuation together: per-mark counts are noise, and a literal `:`
+               // would corrupt the `:`-delimited label path (and `>` the ` > `
+               // display) if embedded as a segment.
+               return /^[A-Za-z_][\w-]*$/.test(token) ? `CST:leaf:${token}` : 'CST:leaf:(punctuation)';
+            }
+            return `CST:${cstRole}`;
+         }
+         // Any class whose name ends in AstNodeDescription is a description wrapper;
+         // the prefix is the scope layer (Local, Global, ...). Labelled
+         // `AstNodeDescription:<layer>` so it nests under the description family at
+         // L2 (the bases sit at `AstNodeDescription:base:<kind>`). Generic: no app names.
+         if (name.endsWith('AstNodeDescription')) {
+            const layer = name.slice(0, -'AstNodeDescription'.length) || 'base';
+            return `AstNodeDescription:${layer}`;
+         }
+         // Index manager is an attribution anchor but keeps its real name; Map/MultiMap
+         // stay their own names too (referrer edges show which are the scope index).
+         if (name.endsWith('IndexManager') || name === 'MultiMap' || name === 'Map') {
+            return name;
+         }
+         return undefined; // defer (engine → class:<name>, or a later classifier)
+      }
+
+      // Plain object literal: classify by property-name set.
+      const props = propertySet(node);
+      if (props.size === 0) {
+         // A Position {line,character} whose numeric fields are inline SMIs has NO
+         // property edges on the heap, so it looks empty. Recover it from an
+         // incoming Range `start`/`end` edge — otherwise the millions of Range
+         // endpoints misbucket as 'empty object {}' (the biggest single
+         // misclassification on a large workspace).
+         for (const edge of node.referrers) {
+            if (edge.type === 'property' && (edge.name_or_index === 'start' || edge.name_or_index === 'end')) {
+               return 'Position';
+            }
+         }
+         return undefined; // defer → engine 'empty object {}'
+      }
+      if (props.has('$type')) {
+         return `AST node:${stringProp(node, '$type') ?? 'unknown'}`;
+      }
+      if (props.size === 2 && has(props, 'start', 'end')) {
+         return 'Range';
+      }
+      if (has(props, 'line', 'character')) {
+         return 'Position';
+      }
+      if (has(props, 'parseResult', 'uri') || has(props, 'localSymbols', 'parseResult', 'uri')) {
+         return 'LangiumDocument';
+      }
+      if (has(props, 'value', 'lexerErrors', 'parserErrors')) {
+         return 'ParseResult';
+      }
+      if (has(props, 'name', 'nameSegment', 'documentUri', 'node', 'selectionSegment')) {
+         // The base description payload carries `type` = the described node's element
+         // kind. Labelled `AstNodeDescription:base:<kind>` so it nests under the
+         // description family: L2 `base` aggregates all payloads (alongside the L2
+         // scope-wrapper layers above), L3 `<kind>` is the per-element-kind split.
+         return `AstNodeDescription:base:${stringProp(node, 'type') ?? 'unknown'}`;
+      }
+      if (has(props, '$refText', 'ref')) {
+         return 'Reference';
+      }
+      if (has(props, 'range') && props.size <= 3) {
+         return 'DocumentSegment';
+      }
+      return undefined; // defer → engine 'other Object shape'
+   },
+
+   anchorConcepts: ANCHOR_CONCEPTS,
+   grammarTypes: LANGIUM_GRAMMAR_TYPES,
+
+   // Matches both the raw per-node labels (`AST node:Class`, used as exclusive-
+   // retained attribution anchors) and the bare group (`AST node`, used to pick
+   // top concepts for the retainer-path sample). `AstNodeDescription` prefix
+   // already covers the group and every layer/base path.
+   isAnchor(label) {
+      return (
+         label.startsWith('AST node') || label.startsWith('AstNodeDescription') || label.startsWith('CST') || label.endsWith('IndexManager')
+      );
+   },
+
+   descriptions: {
+      'AST node':
+         'Parsed abstract-syntax-tree nodes, split by `$type` (includes the Langium grammar AST since the parsed grammar shares the heap).',
+      AstNodeDescription:
+         'Scope-index entries. `base` is the payload (one per exported symbol, split by element kind); `Local`/`Global`/… are thin per-scope-layer wrappers that delegate to a base.',
+      CST: 'Concrete-syntax-tree nodes: `leaf` = a token (sub-split by token type — `ID`, `STRING`, keyword text, with all punctuation bucketed as `(punctuation)`), `composite` = a grammar rule, `root` = a document root, `container` = a child-node array.',
+      Range: 'LSP text ranges (`start`/`end` Position pairs) attached to CST nodes and document segments.',
+      Position:
+         'LSP `{line, character}` endpoints of Ranges (their numeric fields are inline, so they carry no heap properties of their own).'
+   }
+};

package/heap-analysis/heap/renderer/renderer.mjs

@@ -0,0 +1,122 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+/*
+ * Renderer (browser) heap classification — the `--renderer` mode's counterpart to
+ * the Langium/GLSP classifiers. A renderer `.heapsnapshot` (from CDP
+ * `HeapProfiler.takeHeapSnapshot`, the `browser-heap` artefact) has NO Langium
+ * structure; its leak vocabulary is the DOM: detached DOM subtrees and the JS
+ * that retains them (event listeners, closures, arrays). So this classifier
+ * buckets by that vocabulary and lets the SAME report machinery (exclusive
+ * retained, holders, retainer paths) do the work — a retainer path to a
+ * `Detached DOM` concept IS the listener-retainer analysis.
+ *
+ * Unlike a normal ConceptClassifier contribution, this cannot be composed through
+ * `composeClassifiers`: DOM nodes are `native`-typed, and the engine short-circuits
+ * every non-`object` node to its primitive bucket BEFORE contributions run. So the
+ * renderer mode installs a dedicated `classify` that intercepts `native`/DOM nodes
+ * itself and delegates everything else to the engine baseline (the JS/V8 universals
+ * — strings, arrays, closures — which a renderer heap has just like any other).
+ */
+
+import { composeClassifiers } from '../langium/concepts.mjs';
+
+const DETACHED_PREFIX = 'Detached ';
+const SYSTEM_PREFIX = 'system';
+/** Object-node class names V8 uses for a registered DOM event listener. */
+const EVENT_LISTENER_NAMES = new Set(['V8EventListener', 'EventListener']);
+
+/**
+ * A clean, single-segment DOM key for a heap node name. V8 names a DOM element by
+ * its markup or by its class (`HTMLDivElement`, `Text`). The raw markup breaks the
+ * report: the `<…>` is eaten as literal HTML by a Markdown renderer, an inline
+ * `style` attribute's `:` collides with the label-path separator, and a `|` would
+ * break the table column. So an element descriptor is normalised to a CSS selector
+ * — dropping the `style`/`data-*` soup, which also collapses near-duplicate rows —
+ * and any residual `:`/`|`/`<`/`>`/`"` is stripped. A plain class name passes
+ * through, and V8's trailing ` / <url>` suffix is dropped.
+ */
+function domClass(name) {
+   const raw = (name || 'native').split(' / ')[0].trim() || 'native';
+   const element = raw.match(/^<([a-zA-Z][\w-]*)([^>]*)>$/);
+   let key = raw;
+   if (element) {
+      const tag = element[1].toLowerCase();
+      const id = (element[2].match(/\bid="([^"]*)"/) ?? ['', ''])[1].trim();
+      const classes = (element[2].match(/\bclass="([^"]*)"/) ?? ['', ''])[1].trim();
+      const idSel = id ? `#${id}` : '';
+      const classSel = classes ? `.${classes.split(/\s+/).filter(Boolean).join('.')}` : '';
+      key = `${tag}${idSel}${classSel}`;
+   }
+   return (
+      key
+         .replace(/[:|<>"]/g, ' ')
+         .replace(/\s+/g, ' ')
+         .trim()
+         .slice(0, 80) || 'native'
+   );
+}
+
+/** The subtype of a V8 `system` native (`system / Context` → `Context`; bare `system` → `(other)`). */
+function nativeSubtype(name) {
+   const slash = name.indexOf('/');
+   return slash >= 0 ? name.slice(slash + 1).trim() || '(other)' : '(other)';
+}
+
+const RENDERER_DESCRIPTIONS = {
+   'Detached DOM':
+      "DOM nodes no longer in the document tree but still retained by JS — the classic browser leak. Follow each concept's retainer path to the listener / closure / array holding it; that holder is the lever.",
+   'DOM node':
+      'Live DOM nodes still attached to the document, grouped by element class. Growth across a session (vs a stable baseline) points at accumulating UI.',
+   'V8 native':
+      'V8-internal native allocations (`system / Context`, `system / JSArrayBufferData`, …) — NOT DOM. Renderer memory held by the engine (contexts, ArrayBuffer backing stores), grouped by system subtype.',
+   'Event listener':
+      'Registered DOM event listeners (V8EventListener). A listener retaining a detached subtree is a leak; a rising count is the other classic tell.'
+};
+
+/**
+ * Build the renderer classification functions in the shape the analyzer consumes
+ * ({@link composeClassifiers}'s return), intercepting `native`/DOM + event-listener
+ * nodes and delegating the rest to the engine baseline (no Langium/GLSP vocabulary).
+ */
+export function rendererClassifiers() {
+   const baseline = composeClassifiers([]);
+   const classify = node => {
+      if (node.type === 'native') {
+         const name = node.name || '';
+         if (name.startsWith(DETACHED_PREFIX)) {
+            return `Detached DOM:${domClass(name.slice(DETACHED_PREFIX.length))}`;
+         }
+         // V8-internal native allocations (`system / Context`, `system / JSArrayBufferData`,
+         // …) are NOT DOM — bucket them apart so `DOM node` reflects real elements.
+         if (name === SYSTEM_PREFIX || name.startsWith(`${SYSTEM_PREFIX} `) || name.startsWith(`${SYSTEM_PREFIX}/`)) {
+            return `V8 native:${nativeSubtype(name)}`;
+         }
+         return `DOM node:${domClass(name)}`;
+      }
+      if (node.type === 'object' && EVENT_LISTENER_NAMES.has(node.name)) {
+         return 'Event listener';
+      }
+      return baseline.classify(node);
+   };
+   // Anchor the DOM concepts AND the per-constructor `class:<Name>` buckets: a renderer
+   // heap has no curated model, so class instances (widgets, models, caches, framework
+   // objects) are the meaningful attribution anchors. Without this the ~1/5 of the heap
+   // that is the JS object graph shows 0 exclusive retained (attributed up to GC roots);
+   // anchoring per-class turns it into a "which constructor retains the most" view.
+   const isAnchorConcept = label =>
+      label.startsWith('Detached DOM') ||
+      label.startsWith('DOM node') ||
+      label.startsWith('V8 native') ||
+      label === 'Event listener' ||
+      label === 'class' ||
+      label.startsWith('class:');
+   const describe = group => RENDERER_DESCRIPTIONS[group];
+   return { classify, isAnchorConcept, conceptGroup: baseline.conceptGroup, grammarTypes: new Set(), describe };
+}

package/lib/cli-version.d.ts

@@ -0,0 +1,21 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+/**
+ * The version of the running binary.
+ *
+ * Read from the manifest rather than emitted as a constant at build time: a
+ * generated constant is a second copy of a number the manifest already carries,
+ * and nothing goes red while the two disagree.
+ *
+ * Throws rather than reporting `unknown`: every caller turns the number into a
+ * claim someone else acts on — a pinned dependency range, a version in a bug
+ * report — where a placeholder is worse than a failure.
+ */
+export declare function readCliVersion(): string;
+//# sourceMappingURL=cli-version.d.ts.map

package/lib/cli-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-version.d.ts","sourceRoot":"","sources":["../src/cli-version.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAOlF;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,IAAI,MAAM,CAMvC"}