@graphty/graphty-element 2.3.1 → 2.4.1

package/dist/src/managers/GraphContext.d.ts

@@ -69,7 +69,8 @@ export interface GraphContext {
      */
     isRunning(): boolean;
     /**
-     * Set the running state
+     * Play or pause the layout on a consumer's behalf. A pause holds until `setRunning(true)`;
+     * the element's own restarts write `getLayoutManager().running`, which the pause refuses.
      */
     setRunning(running: boolean): void;
     /**

package/dist/src/managers/LayoutManager.d.ts

@@ -42,6 +42,13 @@ export declare class LayoutManager implements Manager {
     private styles;
     layoutEngine?: LayoutEngine;
     private _running;
+    /**
+     * Set while a CONSUMER has paused the layout, through {@link LayoutManager.setPaused}. Nothing
+     * inside the element clears it: a load, a freeze, an accelerator attaching, a new layout or a
+     * drag may rebuild or place nodes, but their `running = true` is refused until the consumer
+     * resumes.
+     */
+    private _paused;
     /**
      * Set when a layout was built over a graph with nothing in it, and the pre-steps it is
      * configured with have therefore not been spent. See
@@ -68,8 +75,19 @@ export declare class LayoutManager implements Manager {
      * again and the next frame moves nodes. Going true -> false only stops `step()` being
      * called; batches already in flight land in the position array by themselves, nothing is
      * disposed and nothing is released.
+     *
+     * While the consumer has paused the layout (see {@link LayoutManager.setPaused}) a `true` is
+     * ignored, so the element's own restarts cannot undo the pause.
      */
     set running(value: boolean);
+    /**
+     * Pause or resume the layout on a consumer's behalf.
+     *
+     * A pause holds until the consumer resumes it: internal restarts are refused while it is set.
+     * Resuming runs the layout, and reheats a simulation that had settled.
+     * @param paused - True to pause, false to resume.
+     */
+    setPaused(paused: boolean): void;
     private graphContext;
     /**
      * The graph's acceleration controller, once a context has arrived. A manager built without a
@@ -134,7 +152,7 @@ export declare class LayoutManager implements Manager {
     /**
      * Internal method for setting layout - bypasses queue
      * Used by operations that are already queued to prevent nested queueing
-     * @param type - Layout type identifier
+     * @param layout - A registered engine name, or a catalogue layout id
      * @param opts - Layout-specific options
      */
     private _setLayoutInternal;
@@ -246,10 +264,18 @@ export declare class LayoutManager implements Manager {
      */
     getNodePosition(node: Node): [number, number, number] | undefined;
     /**
-     * Check if layout has settled
-     * @returns True if layout has settled, false otherwise
+     * Whether the layout engine has converged: the positions are final.
+     *
+     * A layout that was stopped part-way is NOT settled; it is {@link LayoutManager.isPaused}. A
+     * reader that only needs "positions are not moving right now" asks `!running || isSettled`.
+     * @returns True when the engine has converged, or when there is no engine.
      */
     get isSettled(): boolean;
+    /**
+     * Whether the layout was stopped before it converged, so its positions are not final.
+     * @returns True when the layout is not running and has not settled.
+     */
+    get isPaused(): boolean;
     /**
      * Get nodes from layout engine
      * @returns Iterable of nodes managed by the layout engine
@@ -295,6 +321,7 @@ export declare class LayoutManager implements Manager {
         layoutType: string | undefined;
         isRunning: boolean;
         isSettled: boolean;
+        isPaused: boolean;
         nodeCount: number;
         edgeCount: number;
     };

package/dist/src/meshes/CustomLineRenderer.d.ts

@@ -34,19 +34,21 @@ interface CustomLineOptions {
  */
 export declare class CustomLineRenderer {
     private static shadersRegistered;
-    private static activeMaterials;
-    private static registeredScene;
     /**
-     * Register custom line shaders
+     * Every line material, grouped by scene, each scene's group given that scene's render size
+     * once per frame. See {@link PerSceneMaterials} for the defect (issue #45).
      */
-    static registerShaders(): void;
+    private static readonly resolutionTracked;
+    /**
+     * Number of line materials receiving per-frame resolution updates.
+     * @param scene - Count only this scene's materials; omit for every scene
+     * @returns Count of tracked materials
+     */
+    static getActiveMaterialCount(scene?: Scene): number;
     /**
-     * Register the shared resolution update callback
-     * This callback updates ALL line materials at once, instead of having one callback per material.
-     * This dramatically improves performance when rendering many edges.
-     * @param scene - The Babylon.js scene to register the callback on
+     * Register custom line shaders
      */
-    private static registerResolutionCallback;
+    static registerShaders(): void;
     /**
      * Calculate evenly-spaced dot positions along a line path
      * @param points - Path points defining the line

package/dist/src/meshes/EdgeMesh.d.ts

@@ -1,4 +1,4 @@
-import { AbstractMesh, type Scene, Vector3 } from "@babylonjs/core";
+import { AbstractMesh, type InstancedMesh, type Scene, Vector3 } from "@babylonjs/core";
 import type { EdgeStyleConfig } from "../config";
 import type { MeshCache } from "./MeshCache";
 import { PatternedLineMesh } from "./PatternedLineMesh";
@@ -80,26 +80,35 @@ export declare class EdgeMesh {
      *
      * In 2D mode, uses StandardMaterial with XY rotation.
      * In 3D mode, uses shader-based billboard rendering.
+     *
+     * The head is an InstancedMesh of a batch its scene shares with every head of the same
+     * shape (and, where the material holds them, the same colour and opacity), so a graph's
+     * arrowheads cost a draw call per batch rather than per edge. See
+     * `FilledArrowRenderer.instanceOf`.
      * @param _cache - MeshCache instance (currently unused, kept for API compatibility)
      * @param _styleId - Style ID (currently unused, kept for API compatibility)
      * @param options - Arrow head options including type, width, color, size, and opacity
      * @param scene - Babylon.js scene
      * @returns The created arrow mesh, or null if type is "none" or undefined
      */
-    static createArrowHead(_cache: MeshCache, _styleId: string, options: ArrowHeadOptions, scene: Scene): AbstractMesh | null;
+    static createArrowHead(_cache: MeshCache, _styleId: string, options: ArrowHeadOptions, scene: Scene): InstancedMesh | null;
     /**
-     * Create a filled arrow base mesh using FilledArrowRenderer
-     * Returns a cached mesh template with thin instance support.
-     * lineDirection is set per-instance when creating thin instances.
-     * @param type - Arrow type (normal, inverted, diamond, etc.)
+     * A 3D sphere-dot arrowhead: an unlit sphere, batched by colour and opacity, sized by the
+     * instance's scale.
      * @param length - Arrow length in world units
-     * @param _width - Arrow width in world units (reserved for future use)
      * @param color - Arrow color as hex string
      * @param opacity - Arrow opacity (0-1)
      * @param scene - Babylon.js scene
-     * @returns Created arrow mesh
+     * @returns The sphere instance
+     */
+    private static createSphereDot;
+    /**
+     * Build the normalized geometry of a billboarded arrow type (every filled type but sphere-dot).
+     * @param type - Arrow type (normal, inverted, diamond, etc.)
+     * @param scene - Babylon.js scene
+     * @returns The arrow's geometry, with no material
      */
-    private static createFilledArrow;
+    private static createArrowShape;
     private static createStaticLine;
     private static createAnimatedLine;
     private static createAnimatedTexture;

package/dist/src/meshes/FilledArrowRenderer.d.ts

@@ -1,4 +1,5 @@
-import { Mesh, Scene, ShaderMaterial, Vector3 } from "@babylonjs/core";
+import "@babylonjs/core/Meshes/instancedMesh";
+import { type AbstractMesh, InstancedMesh, Mesh, Scene, ShaderMaterial, Vector3 } from "@babylonjs/core";
 export interface FilledArrowOptions {
     size: number;
     color: string;
@@ -18,16 +19,23 @@ export interface FilledArrowOptions {
  */
 export declare class FilledArrowRenderer {
     private static shadersRegistered;
-    private static activeMaterials;
-    private static cameraCallbackRegistered;
+    /**
+     * Every billboarding material, grouped by scene, each scene's group given that scene's
+     * camera position once per frame. See {@link PerSceneMaterials} for the defect (issue #45).
+     */
+    private static readonly cameraTracked;
+    /**
+     * The arrowhead batches: per scene, one hidden source mesh per batch key. See
+     * {@link FilledArrowRenderer.instanceOf}.
+     */
+    private static readonly batches;
     /**
      * Unregister a shader material so the per-frame camera-uniform walk stops visiting it.
      *
      * WHY THIS EXISTS -- the defect it repairs:
      * {@link FilledArrowRenderer.applyShader} builds a fresh `ShaderMaterial` per mesh and
-     * adds it to {@link FilledArrowRenderer.activeMaterials}, which is iterated once per
-     * frame. Nothing removed entries. The `catch` inside that walk reads as an eviction
-     * path but cannot fire: `ShaderMaterial.setVector3` does not throw on a disposed
+     * adds it to the per-frame camera walk. Nothing used to remove entries. A `catch` inside
+     * that walk read as an eviction path but could not fire: `ShaderMaterial.setVector3` does not throw on a disposed
      * material, it just records the value into a dead material's uniform cache. So every
      * arrowhead and every pattern element ever built stayed in the walk for the lifetime of
      * the page, and since both are rebuilt wholesale on every style change the walk grew
@@ -48,21 +56,15 @@ export declare class FilledArrowRenderer {
      * Exists so the leak described on {@link FilledArrowRenderer.releaseMaterial} is
      * OBSERVABLE from a test; it has no visible symptom until the frame rate has already
      * collapsed, and asserting on frame time instead would be flaky.
+     * @param scene - Count only this scene's materials; omit for every scene
      * @returns Count of tracked materials
      * @public
      */
-    static getActiveMaterialCount(): number;
+    static getActiveMaterialCount(scene?: Scene): number;
     /**
      * Register filled arrow shaders
      */
     static registerShaders(): void;
-    /**
-     * Register the shared camera position update callback
-     * This callback updates ALL arrow materials at once, instead of having one callback per material.
-     * This dramatically improves performance when rendering many arrows.
-     * @param scene - The Babylon.js scene to register the callback on
-     */
-    private static registerCameraCallback;
     /**
      * Create a filled triangle arrow mesh
      *
@@ -191,13 +193,11 @@ export declare class FilledArrowRenderer {
      *
      * This line used to read `mesh.alwaysSelectAsActiveMesh = true`, with a comment
      * explaining that thin instances needed it because their base mesh was parked at
-     * y = -10000. Both halves of that comment are now false. The same function's comment two
-     * lines above says thin instances are no longer used, and `applyShader` has exactly three
-     * call sites -- `PatternedLineRenderer.createPatternMesh` twice and
-     * `EdgeMesh.createFilledArrow` once -- none of which parks a template anywhere: arrowhead
-     * meshes are built one per edge and positioned at the real arrow location by `Edge`, and
-     * the `MeshCache` template that genuinely does sit at y = -10000 holds NODE meshes, uses
-     * `InstancedMesh`, and never reaches this function. The flag's effect today is simply that
+     * y = -10000. Both halves of that comment are now false. This function is reached from
+     * `applyShader` (pattern elements, one mesh each) and from `createArrowInstance`, which
+     * calls it on each arrowhead INSTANCE -- positioned at the real arrow location by `Edge` --
+     * never on a parked template; and the `MeshCache` template that genuinely does sit at
+     * y = -10000 holds NODE meshes and never reaches this function. The flag's effect was that
      * every mesh carrying this shader is submitted every frame regardless of where the camera
      * is pointing -- which, at the mesh counts a dotted line used to reach, was thousands of
      * pointless draw calls per frame.
@@ -230,10 +230,48 @@ export declare class FilledArrowRenderer {
     /**
      * Set the line direction for a filled arrow mesh
      * This should be called every frame when the edge updates
-     * @param mesh - Filled arrow mesh
+     * @param mesh - Filled arrow mesh, or an arrowhead instance from {@link FilledArrowRenderer.createArrowInstance}
      * @param direction - Line direction vector (normalized)
      */
-    static setLineDirection(mesh: Mesh, direction: Vector3): void;
+    static setLineDirection(mesh: AbstractMesh, direction: Vector3): void;
+    /**
+     * Draw one arrowhead as an instance of its scene's batch for `key`, building the batch's
+     * hidden source mesh with `build` the first time the scene needs it.
+     *
+     * WHY -- issue #25: every arrowhead used to be its own `Mesh` with its own material, so N
+     * arrowheaded edges cost N draw calls a frame (and, through issue #27, O(N^2) to load). A
+     * batch is drawn in one call however many edges use it. Each instance keeps its own
+     * transform, and Babylon refills the per-instance buffers once per frame in one pass, so this
+     * does not bring back the per-edge buffer writes that made thin instances 35x slower.
+     *
+     * The source mesh goes when its last instance does, so a cleared graph leaves nothing in the
+     * scene, and the batches of one scene are never seen by another.
+     * @param scene - The scene the arrowhead is drawn in
+     * @param key - What the batch's heads have in common: shape, and whatever else lives on the material
+     * @param build - Builds the source mesh (with its material) for a new batch
+     * @returns The arrowhead: an instance of the batch's source mesh
+     */
+    static instanceOf(scene: Scene, key: string, build: () => Mesh): InstancedMesh;
+    /**
+     * Draw one billboarded 3D arrowhead as an instance of its scene's batch for that shape and
+     * opacity. The direction, size and colour are the instance's own attributes, so edges of
+     * every colour and size share one draw call.
+     * @param shape - The arrow type, which names the batch's geometry
+     * @param createShape - Builds that geometry, for a new batch
+     * @param options - The head's size (world-space length), colour and opacity
+     * @param scene - Babylon.js scene
+     * @returns The arrowhead instance; point it with {@link FilledArrowRenderer.setLineDirection}
+     */
+    static createArrowInstance(shape: string, createShape: () => Mesh, options: FilledArrowOptions, scene: Scene): InstancedMesh;
+    /**
+     * Give a batch's source mesh the billboard shader, reading direction, size and colour from
+     * instance attributes instead of uniforms.
+     * @param mesh - The batch's source mesh
+     * @param opacity - The opacity every head in the batch is drawn at
+     * @param scene - Babylon.js scene
+     * @returns The same mesh
+     */
+    private static applyInstancedShader;
     /**
      * Create a 2D arrow mesh with flat StandardMaterial
      *

package/dist/src/meshes/MeshCache.d.ts

@@ -26,6 +26,24 @@ export declare class MeshCache {
      * Clear all cached meshes and reset statistics
      */
     clear(): void;
+    /**
+     * Dispose and forget every cached mesh that nothing is drawn from any more.
+     *
+     * Every source mesh is handed out only as instances, so one with no instances is a look no
+     * element has: a size a layer used to paint, a halo nobody is selected for. Without this the
+     * cache holds one mesh per look ever drawn, which grows with every edit to a size or a shape
+     * until the next dataset boundary. A name that is asked for again is simply built again.
+     */
+    prune(): void;
+    /**
+     * Dispose a source mesh and the material it was built with.
+     *
+     * Every creator handed to get() builds a fresh material for its mesh, so the material dies
+     * with it; `mesh.dispose()` alone would leave it in `scene.materials` for good. Textures are
+     * kept: node gradient textures are shared across materials per scene.
+     * @param mesh - The cached source mesh
+     */
+    private static disposeSource;
     /**
      * Get the number of cached meshes
      * @returns Count of cached meshes

package/dist/src/meshes/NodeEffects.d.ts

@@ -83,13 +83,16 @@ export declare class NodeEffects {
      * must not pay for it, so the only call site is the `effect.glow` branch of
      * {@link NodeEffects.applyGlowEffect}; the removal branch deliberately does NOT create one.
      *
+     * DISPOSED AGAIN WHEN NOTHING GLOWS, by {@link NodeEffects.syncGlowStrengths}. The inclusion
+     * list alone never says so: `node.glow` is a mesh channel, so a node that stops glowing moves
+     * to another source mesh and the old glowing source stays listed with no instances. The next
+     * glow recreates the layer through this method.
+     *
      * `excludeByDefault: true` is a safety catch, not a tuning knob. Babylon's inclusion list
      * means "only these" when it is non-empty and "no opinion" -- i.e. EVERY mesh in the scene --
-     * when it is empty (ThinGlowLayer.hasMesh). An empty list is not reachable today, because the
-     * layer is only created at the moment a mesh is added to it and membership is keyed by the
-     * shared source mesh (see resolveRenderedMesh), but "the whole graph blooms" is a bad enough
-     * failure to be worth one option: with this set, `_internalShouldRender` returns false while
-     * the list is empty, so an emptied layer renders nothing at all.
+     * when it is empty (ThinGlowLayer.hasMesh). With this set, `_internalShouldRender` returns
+     * false while the list is empty, so an emptied layer renders nothing rather than blooming
+     * the whole graph.
      * @param scene - The Babylon.js scene
      * @returns The glow layer for the scene
      */
@@ -142,6 +145,10 @@ export declare class NodeEffects {
      * back to 0.1) leaves a mesh with no instances behind; counted, it would hold the layer at 100
      * and round the live glow away in the 8-bit map. It keeps its entry, because a node that goes
      * back to that strength reuses the cached mesh. A disposed mesh is dropped.
+     *
+     * When no glowing source mesh draws a node any more, the layer is disposed: it is a
+     * full-screen post-process that would otherwise render nothing every frame for the life of
+     * the scene. Every node mesh is an instance, so a source with no instances draws nothing.
      * @param glowLayer - The scene's glow layer
      * @param scene - The Babylon.js scene
      */
@@ -155,8 +162,8 @@ export declare class NodeEffects {
      * with one outline configuration -- and resolving to it here would take the outline away from
      * every sibling still on screen. That is the same reasoning `Node.dispose` records for glow,
      * and it has the same consequence: for an instanced node this removes nothing, the source is
-     * freed when `MeshCache` is cleared, and the layer's leftover uniqueId is inert because
-     * Babylon's uniqueIds are monotonic per scene and never reused.
+     * freed when `MeshCache` prunes or clears it, and the layer's leftover uniqueId is inert
+     * because Babylon's uniqueIds are monotonic per scene and never reused.
      * @param mesh - The mesh to remove from highlighting
      */
     static removeFromHighlight(mesh: AbstractMesh): void;
@@ -178,10 +185,8 @@ export declare class NodeEffects {
      * The colour map is keyed by mesh uniqueId, so it MUST die with the layer: leaving it behind
      * would let a later mesh that happens to reuse a uniqueId inherit a dead style's glow colour.
      *
-     * Sibling of {@link NodeEffects.disposeHighlightLayer} and, like it, currently called from
-     * nowhere in this package -- the scene outlives every dataset, so the layers are reused rather
-     * than rebuilt. It exists so that whoever tears a scene down has one call for each layer this
-     * class can create, instead of discovering the glow layer only by leaking it.
+     * Called by {@link NodeEffects.syncGlowStrengths} once no node glows; the next glow
+     * recreates the layer lazily.
      * @param scene - The Babylon.js scene
      */
     static disposeGlowLayer(scene: Scene): void;

package/dist/src/meshes/NodeMesh.d.ts

@@ -120,8 +120,8 @@ export declare class NodeMesh {
      *      provenance is invisible here, but unbounded allocation is not.
      *
      * The cache is a WeakMap keyed by scene, so the entries die with the scene and never leak
-     * across scenes or across tests. `MeshCache.clear()` disposes meshes only -- not materials and
-     * not textures -- so a cached texture stays valid across a 2D/3D switch.
+     * across scenes or across tests. `MeshCache` disposes a source mesh's material but never its
+     * textures, so a cached texture stays valid across a 2D/3D switch.
      * @param gradient - The normalised gradient to paint
      * @param scene - Babylon.js scene that will own the texture
      * @returns The shared texture, or undefined if one cannot or should not be allocated

package/dist/src/meshes/PatternedLineRenderer.d.ts

@@ -45,42 +45,16 @@ export declare const PATTERN_DEFINITIONS: Record<PatternType, PatternDefinition>
  * Static utility class for creating mesh-based pattern geometries for line visualization
  */
 export declare class PatternedLineRenderer {
-    private static activeMaterials;
-    private static cameraCallbackRegistered;
     /**
-     * Unregister a pattern material so the per-frame camera-uniform walk stops visiting it.
+     * Stop a pattern material receiving per-frame camera updates.
      *
-     * WHY THIS EXISTS -- the defect it repairs:
-     * Every pattern element (every dot, dash, star, diamond) owns its own `ShaderMaterial`,
-     * and creating one adds it to {@link PatternedLineRenderer.activeMaterials} and, inside
-     * `FilledArrowRenderer.applyShader`, to that class's own active set as well. Both sets
-     * are iterated once per frame to push the camera position uniform. Nothing ever removed
-     * an entry: `PatternedLineMesh.dispose` disposed the mesh with Babylon's default
-     * arguments, which leaves the material alive, and the `catch` inside each per-frame walk
-     * that looks like an eviction path cannot fire, because `ShaderMaterial.setVector3` does
-     * not throw on a disposed material. The result was a per-frame loop that grew
-     * monotonically for the lifetime of the page: every change of line style, width or colour
-     * rebuilt every edge's meshes and left the previous generation's materials in the walk
-     * forever. That is a second, slower-burning half of the same halt the product owner
-     * reported ("I changed line style to dot and width to 1 and everything crawled to a halt").
-     *
-     * Removal must reach BOTH sets, which is why this delegates to
-     * {@link FilledArrowRenderer.releaseMaterial} as well as clearing its own.
+     * Every pattern element owns its own `ShaderMaterial`, built by
+     * `FilledArrowRenderer.applyShader`, which registers it in that renderer's per-scene camera
+     * walk (see `PerSceneMaterials`). Disposing the material ends the registration on its own;
+     * `PatternedLineMesh` calls this as well, eagerly, before it disposes one.
      * @param material - The ShaderMaterial to stop tracking; passing an untracked material is a no-op
-     * @public
      */
     static releaseMaterial(material: ShaderMaterial): void;
-    /**
-     * Number of pattern materials currently receiving per-frame camera updates.
-     *
-     * Exists so the material leak described on {@link PatternedLineRenderer.releaseMaterial}
-     * is OBSERVABLE from a test. The leak has no visible symptom until the frame rate has
-     * already collapsed, and the count is the only direct evidence that a disposed pattern
-     * line truly stopped costing anything; asserting on frame time instead would be flaky.
-     * @returns Count of tracked materials
-     * @public
-     */
-    static getActiveMaterialCount(): number;
     /**
      * Create a PatternedLineMesh instance
      * Note: start/end are already adjusted by Edge.transformArrowCap() for node surfaces and arrows
@@ -233,11 +207,5 @@ export declare class PatternedLineRenderer {
      * @returns The default shape type for the pattern
      */
     private static getDefaultShapeType;
-    /**
-     * Register camera position update callback
-     * Updates all pattern materials in one batch per frame
-     * @param scene - Babylon.js scene
-     */
-    private static registerCameraCallback;
 }
 export {};

package/dist/src/meshes/PerSceneMaterials.d.ts

@@ -0,0 +1,49 @@
+import type { Scene, ShaderMaterial } from "@babylonjs/core";
+/**
+ * Called once per frame for one scene, with the shader materials that scene draws.
+ */
+type RefreshFn = (scene: Scene, materials: Iterable<ShaderMaterial>) => void;
+/**
+ * Shader materials grouped by the scene that draws them, each group refreshed by an observer on
+ * its OWN scene, just before that scene renders.
+ *
+ * WHY THIS EXISTS -- the defect it repairs (issue #45): the line, arrowhead and pattern renderers
+ * push per-frame uniforms (the render resolution, the camera position) into their shader
+ * materials. Each kept those materials in one static set shared by every `<graphty-element>` on
+ * the page, and registered its per-frame observer either once per page (on whichever scene came
+ * first) or once per scene switch. So a second element's arrowheads billboarded towards the
+ * FIRST element's camera, an element created after the first was disposed got no camera
+ * position at all, and each scene's observer walked every other scene's materials.
+ *
+ * Here each scene gets its own set and its own observer, which reads that scene's own engine and
+ * camera. A material leaves its set when it is disposed, and a scene's set and observer go when
+ * the scene is disposed, so nothing outlives the element that drew it.
+ */
+export declare class PerSceneMaterials {
+    private readonly refresh;
+    private readonly scenes;
+    /**
+     * Track materials whose uniforms `refresh` writes once per frame.
+     * @param refresh - Writes the per-frame uniforms of one scene's materials
+     */
+    constructor(refresh: RefreshFn);
+    /**
+     * Track a material under its own scene and give it its uniforms now, so it draws correctly
+     * even on the first frame.
+     * @param material - The shader material to keep refreshed
+     */
+    add(material: ShaderMaterial): void;
+    /**
+     * Stop refreshing a material. Disposing the material does this on its own.
+     * @param material - The material to forget; an untracked material is a no-op
+     */
+    delete(material: ShaderMaterial): void;
+    /**
+     * Number of tracked materials.
+     * @param scene - Count only this scene's materials; omit for every scene
+     * @returns How many materials are refreshed each frame
+     */
+    count(scene?: Scene): number;
+    private materialsOf;
+}
+export {};

package/dist/src/meshes/RichTextParser.d.ts

@@ -35,3 +35,29 @@ export declare class RichTextParser {
         totalHeight: number;
     };
 }
+/**
+ * Measures one line of segments from the font's own metrics.
+ *
+ * The line's ink height is the tallest ascent plus the deepest descent over its segments, each
+ * the larger of the font box (`fontBoundingBoxAscent` / `fontBoundingBoxDescent`) and the actual
+ * glyph box, plus the outline on both sides. The line box is that height times `lineHeight`, and
+ * the extra leading is split evenly above and below, as CSS does. The label's panel height and
+ * the renderer's line advance both come from here, so they cannot disagree.
+ * @param ctx - Canvas rendering context for measurement
+ * @param lineSegments - The segments of one line
+ * @param options - Layout options
+ * @param options.lineHeight - Line height multiplier
+ * @param options.textOutline - Whether text outline is enabled
+ * @param options.textOutlineWidth - Width of text outline
+ * @returns The line's advance width, its line box height, and the distance from the top of the
+ * line box to the alphabetic baseline
+ */
+export declare function measureLine(ctx: CanvasRenderingContext2D, lineSegments: TextSegment[], options: {
+    lineHeight: number;
+    textOutline: boolean;
+    textOutlineWidth: number;
+}): {
+    width: number;
+    lineBox: number;
+    baseline: number;
+};

package/dist/src/meshes/RichTextRenderer.d.ts

@@ -43,7 +43,6 @@ export declare class RichTextRenderer {
         width: number;
         height: number;
     }): void;
-    private measureLine;
     private calculateLineStartX;
     private drawLine;
     private drawTextWithShadow;

package/dist/src/session/cost/estimate.d.ts

@@ -27,7 +27,7 @@
  * Nothing here reaches Babylon.js, Lit or the DOM: an estimate is arithmetic over plain data,
  * published from the Node-safe `./session` entry point.
  */
-import type { AlgorithmDescriptor, AlgorithmKey, CostClass, Scope } from "../../catalog/types";
+import { type AlgorithmDescriptor, type AlgorithmKey, type CostClass, type Scope } from "../../catalog/types";
 import { GraphtyError } from "../../errors/GraphtyError";
 import type { GraphStatistics } from "../types";
 /**

package/dist/src/session/layout.d.ts

@@ -29,8 +29,8 @@ export interface LayoutRecommendation {
      * The arrangement, exactly as `catalog.layouts()` publishes it.
      *
      * `layout.id` is the public arrangement name -- `"force"`, `"circular"` -- and `layout.engine`
-     * is the registered engine name `setLayout` takes. A consumer needs the second in order to
-     * act: `element.setLayout(recommendation.layout.engine)`.
+     * is the registered engine that runs it by default. `setLayout` takes either, so a consumer
+     * acts on the id: `element.setLayout(recommendation.layout.id)`.
      */
     readonly layout: LayoutDescriptor;
     /** Why this arrangement suits this graph, in a sentence a consumer can show a reader. */
@@ -80,7 +80,7 @@ export interface LayoutRecommendationOptions {
  * });
  *
  * if (advice !== undefined) {
- *     await element.setLayout(advice.layout.engine);
+ *     await element.setLayout(advice.layout.id);
  * }
  * ```
  */

package/dist/src/session/runs/RunsApi.d.ts

@@ -18,7 +18,7 @@
  * structural view of `OperationQueueManager` narrow enough that the session never imports the
  * renderer's manager to talk to it.
  */
-import type { AlgorithmDescriptor, LayerId, RunId, Scope } from "../../catalog/types";
+import { type AlgorithmDescriptor, type LayerId, type RunId, type Scope } from "../../catalog/types";
 import type { AutoApplyPolicy } from "../styles/autoApply";
 import { type RunExecutor, type RunQueueContext } from "./Run";
 import { type Caveats, type EngineVersions, type ResolvedScope, type RunChange, type RunsApi } from "./types";

package/dist/src/session/styles/StylesApi.d.ts

@@ -493,6 +493,12 @@ export interface StylesSources {
      * @param change - What changed, and how much was painted.
      */
     readonly onChange?: (change: StyleChange) => void;
+    /**
+     * Aborted when the session holding the stack is disposed. Every edit still pending is
+     * cancelled with it, so a caller awaiting one gets an `AbortError` rather than waiting for
+     * ever, and an edit issued afterwards is cancelled before it starts.
+     */
+    readonly disposed?: AbortSignal;
 }
 /**
  * What a highlight paints when its caller names no style.