@graphty/graphty-element 2.4.0 → 2.5.0

package/dist/graphty.js

@@ -1,81 +1,85 @@
-import { A as e, a as r, b as E, D as O, E as o, d as S, G as R, e as _, I as L, L as t, N as C, O as A, R as N, S as n, f as I, g as T, h as g, U as i, i as p } from "./chunks/index-2xkq7wyD.js";
-import { L as l, S as G, a as f } from "./chunks/paletteRegistry-A63C71Gn.js";
-import { D, E as M } from "./chunks/DataSource-B8vf2uhW.js";
-import { I as P, J as U, p as c, q as m, A as u, C as x, x as B } from "./chunks/optionsFromZod-BuTOFgVM.js";
-import { g as H, b, N as Y, c as F, P as W, R as K, S as k, d as q, e as v, f as w } from "./chunks/NodeStyle-CtmA7dXi.js";
-import { A as Q, a as X, G as j, i as z, b as Z } from "./chunks/GraphtyError-B93WRH3e.js";
-import { B as aa, a as sa, b as ea, C as ra, G as Ea, c as Oa, I as oa, O as Sa, d as Ra, e as _a, f as La, P as ta, g as Ca, h as Aa, R as Na, T as na, i as Ia, V as Ta, Y as ga } from "./chunks/sequential-Zym81qm7.js";
-import { a as pa, G as da, V as la, i as Ga } from "./chunks/GraphStyle-Cwr55SAE.js";
-import { c as ya } from "./chunks/common-DWNKjpH_.js";
+import { A as s, a as r, b as E, D as O, E as o, d as S, G as R, e as t, I as L, L as _, N as C, O as A, R as N, S as g, f as i, g as n, h as I, U as T, i as p } from "./chunks/index-6GDfNfwJ.js";
+import { L as d, S as G, a as f, r as y } from "./chunks/paletteRegistry-jg9uS7wo.js";
+import { D as M, E as P } from "./chunks/DataSource-xL3Yn0Pa.js";
+import { I as m, J as U, p as c, q as x, A as u, C as B, x as V, r as H } from "./chunks/optionsFromZod-DHLLiX_8.js";
+import { r as Y } from "./chunks/GraphtyLogger-kbOx2zq3.js";
+import { g as W, b as k, N as w, c as K, P as q, R as v, S as J, d as Q, e as X, f as j } from "./chunks/NodeStyle-CtmA7dXi.js";
+import { A as Z, a as $, G as aa, i as ea, b as sa } from "./chunks/pluginRegistry-MaTIDh6l.js";
+import { B as Ea, a as Oa, b as oa, C as Sa, G as Ra, c as ta, I as La, O as _a, d as Ca, e as Aa, f as Na, P as ga, g as ia, h as na, R as Ia, T as Ta, i as pa, V as la, Y as da } from "./chunks/sequential-Zym81qm7.js";
+import { a as fa, G as ya, V as Da, i as Ma } from "./chunks/GraphStyle-Cwr55SAE.js";
+import { c as ha } from "./chunks/common-DWNKjpH_.js";
 export {
-  Q as ACCELERATION_ERROR_CODES,
-  P as ACCELERATION_MIN_NODES_DEFAULT,
+  Z as ACCELERATION_ERROR_CODES,
+  m as ACCELERATION_MIN_NODES_DEFAULT,
   U as ACCELERATION_MIN_NODES_KEY,
   c as ACCELERATION_POLICIES,
-  m as ACCELERATION_POLICY_DEFAULT,
+  x as ACCELERATION_POLICY_DEFAULT,
   u as Algorithm,
-  e as AlgorithmManager,
+  s as AlgorithmManager,
   r as AnimationCancelledError,
-  aa as BLUES_COLORS,
-  sa as BLUE_HIGHLIGHT,
-  ea as BLUE_ORANGE_COLORS,
+  Ea as BLUES_COLORS,
+  Oa as BLUE_HIGHLIGHT,
+  oa as BLUE_ORANGE_COLORS,
   E as BUILTIN_PRESETS,
-  ra as CARBON_COLORS,
-  x as CPU_PRECISION,
-  pa as DEFAULT_VIEW_MODE,
+  Sa as CARBON_COLORS,
+  B as CPU_PRECISION,
+  fa as DEFAULT_VIEW_MODE,
   O as DataManager,
-  D as DataSource,
-  H as EDGE_CONSTANTS,
+  M as DataSource,
+  W as EDGE_CONSTANTS,
   o as Edge,
-  b as EdgeStyle,
-  M as ErrorAggregator,
+  k as EdgeStyle,
+  P as ErrorAggregator,
   S as EventManager,
-  X as GRAPHTY_ERROR_CODES,
-  Ea as GREENS_COLORS,
-  Oa as GREEN_SUCCESS,
+  $ as GRAPHTY_ERROR_CODES,
+  Ra as GREENS_COLORS,
+  ta as GREEN_SUCCESS,
   R as Graph,
-  da as GraphBackground,
-  _ as Graphty,
-  j as GraphtyError,
-  oa as INFERNO_COLORS,
+  ya as GraphBackground,
+  t as Graphty,
+  aa as GraphtyError,
+  La as INFERNO_COLORS,
   L as InputManager,
-  l as LayoutEngine,
-  t as LayoutManager,
+  d as LayoutEngine,
+  _ as LayoutManager,
   C as Node,
-  Y as NodeShapes,
-  F as NodeStyle,
-  Sa as OKABE_ITO_COLORS,
-  Ra as ORANGES_COLORS,
-  _a as ORANGE_WARNING,
-  La as OTHER_GROUP_COLOR,
+  w as NodeShapes,
+  K as NodeStyle,
+  _a as OKABE_ITO_COLORS,
+  Ca as ORANGES_COLORS,
+  Aa as ORANGE_WARNING,
+  Na as OTHER_GROUP_COLOR,
   A as OperationQueueManager,
-  ta as PASTEL_COLORS,
-  Ca as PLASMA_COLORS,
-  Aa as PURPLE_GREEN_COLORS,
-  W as PolyhedronType,
-  Na as RED_BLUE_COLORS,
+  ga as PASTEL_COLORS,
+  ia as PLASMA_COLORS,
+  na as PURPLE_GREEN_COLORS,
+  q as PolyhedronType,
+  Ia as RED_BLUE_COLORS,
   N as RenderManager,
-  K as RichTextStyle,
-  k as SHAPE_CONSTANTS,
-  n as ScreenshotError,
-  I as ScreenshotErrorCode,
-  T as SelectionManager,
+  v as RichTextStyle,
+  J as SHAPE_CONSTANTS,
+  g as ScreenshotError,
+  i as ScreenshotErrorCode,
+  n as SelectionManager,
   G as SimpleLayoutConfig,
   f as SimpleLayoutEngine,
-  g as StatsManager,
-  na as TOL_MUTED_COLORS,
-  Ia as TOL_VIBRANT_COLORS,
-  i as UpdateManager,
-  la as VIEW_MODE_VALUES,
-  Ta as VIRIDIS_COLORS,
-  ga as YLORBR_COLORS,
-  ya as colorToHex,
-  q as defaultEdgeStyle,
-  v as defaultNodeStyle,
-  w as defaultRichTextLabelStyle,
+  I as StatsManager,
+  Ta as TOL_MUTED_COLORS,
+  pa as TOL_VIBRANT_COLORS,
+  T as UpdateManager,
+  Da as VIEW_MODE_VALUES,
+  la as VIRIDIS_COLORS,
+  da as YLORBR_COLORS,
+  ha as colorToHex,
+  Q as defaultEdgeStyle,
+  X as defaultNodeStyle,
+  j as defaultRichTextLabelStyle,
   p as defaultXRConfig,
-  B as isAccelerationPolicy,
-  z as isGraphtyError,
-  Z as isGraphtyErrorCode,
-  Ga as isViewMode
+  V as isAccelerationPolicy,
+  ea as isGraphtyError,
+  sa as isGraphtyErrorCode,
+  Ma as isViewMode,
+  H as registerCameraView,
+  Y as registerLogSink,
+  y as registerPalette
 };

package/dist/index.d.ts

@@ -54,6 +54,9 @@ export { DataSource } from "./src/data/DataSource";
 export type { DataLoadingError, ErrorSummary } from "./src/data/index";
 export { ErrorAggregator } from "./src/data/index";
 export { Algorithm } from "./src/algorithms/Algorithm";
+export { registerCameraView } from "./src/catalog/cameraRegistry";
+export { registerLogSink } from "./src/catalog/logSinkRegistry";
+export { registerPalette } from "./src/catalog/paletteRegistry";
 export type { CameraStateChangedEvent, DataLoadingCompleteEvent, DataLoadingErrorEvent, DataLoadingErrorSummaryEvent, DataLoadingProgressEvent, EdgeAddEvent, EdgeEvent, EdgeEventType, EdgeGenericEvent, EventCallbackType, EventType, GraphDataAddedEvent, GraphDataLoadedEvent, GraphErrorEvent, GraphEvent, GraphEventType, GraphGenericEvent, GraphLayoutInitializedEvent, GraphSettledEvent, NodeAddEvent, NodeClickEvent, NodeDragEndEvent, NodeDragStartEvent, NodeEvent, NodeEventDetail, NodeEventType, NodeGenericEvent, NodeHoverEvent, } from "./src/events";
 export type { Manager, ManagerConfig, ManagerContext, QueueableManager } from "./src/managers/index";
 export { AlgorithmManager, DataManager, EventManager, InputManager, LayoutManager, OperationQueueManager, RenderManager, SelectionManager, StatsManager, UpdateManager, } from "./src/managers/index";

package/dist/logging.js

@@ -1,5 +1,5 @@
-import { d as c, p } from "./chunks/GraphtyLogger-CqOVV13Y.js";
-import { G, e as C, f as M, g as w, h as N, i as V, j as I, k as P, m as U, n as T, o as x } from "./chunks/GraphtyLogger-CqOVV13Y.js";
+import { d as c, p } from "./chunks/GraphtyLogger-kbOx2zq3.js";
+import { G, e as C, f as M, g as w, h as N, i as V, j as I, k as P, m as U, n as T, o as x } from "./chunks/GraphtyLogger-kbOx2zq3.js";
 const g = "graphty-element-logging-config";
 function O(t) {
   try {

package/dist/session.js

@@ -1,9 +1,9 @@
 import { R, e as _ } from "./chunks/types-C_c53VgR.js";
-import { A as c, a as C, G as p, i as m, b as L } from "./chunks/GraphtyError-B93WRH3e.js";
-import { p as O, q as U, R as I, t as P, u as y, w as N, x as D, y as w, z as v } from "./chunks/optionsFromZod-BuTOFgVM.js";
-import { D as h } from "./chunks/GraphSession-dcwOjGJh.js";
-import { a as b, b as x, c as F, d as z, Q as M, R as k, e as H, f as Y, S as j, T as q, g as Q, i as X, h as B, j as J, k as K } from "./chunks/GraphSession-dcwOjGJh.js";
-import { L as s } from "./chunks/scales-B2d-7Bf0.js";
+import { A as c, a as C, G as p, i as m, b as L } from "./chunks/pluginRegistry-MaTIDh6l.js";
+import { p as O, q as U, R as I, t as P, u as y, w as N, x as D, y as w, z as v } from "./chunks/optionsFromZod-DHLLiX_8.js";
+import { D as h } from "./chunks/GraphSession-PFm2tJ_j.js";
+import { a as b, b as x, c as F, d as z, Q as M, R as k, e as H, f as Y, S as j, T as q, g as Q, i as X, h as B, j as J, k as K } from "./chunks/GraphSession-PFm2tJ_j.js";
+import { L as s } from "./chunks/scales-BXHmwPXC.js";
 const u = [
   {
     id: "fixed",

package/dist/src/Edge.d.ts

@@ -239,10 +239,10 @@ export declare class Edge {
      * cached SOURCE meshes -- and Babylon disposes a source mesh's instances with it. That is why
      * node spheres and 3D solid edge lines vanished on a dataset clear while roughly sixty grey
      * ARROWHEADS stayed on the canvas, in rosettes where the previous dataset's edges had
-     * converged. Arrowheads are deliberately not cached (`EdgeMesh.createArrowHead` carries a
-     * "PERFORMANCE FIX: Create individual meshes for all arrow types" note): they are built bare
-     * against the scene and parented to the `graph-root` TransformNode, which outlives every
-     * dataset, so nothing ever disposed them. The same was true of the patterned-line meshes
+     * converged. Arrowheads are not in the MeshCache (today each is an instance of a per-scene
+     * batch that `FilledArrowRenderer.instanceOf` frees with its last head): they are parented
+     * to the `graph-root` TransformNode, which outlives every dataset, so nothing but this
+     * dispose frees them. The same was true of the patterned-line meshes
      * (dot/dash/star/...), 2D lines, bezier curves and all three RichTextLabels.
      *
      * Every dispose is guarded with `isDisposed()` -- matching the idiom already used in

package/dist/src/acceleration/AccelerationController.d.ts

@@ -190,6 +190,12 @@ export declare class AccelerationController {
      *
      * Switching to `"off"` releases the accelerator, because holding a device nobody is allowed
      * to use is a cost with no benefit. Switching back to `"auto"` or `"required"` probes again.
+     * Leaving `"required"` releases a software accelerator, which only `"required"` accepts, and
+     * probes again.
+     *
+     * A no-op on a disposed controller, rather than a throw: the element forwards its
+     * `acceleration` attribute here from `attributeChangedCallback`, where a throw would leave the
+     * element unrendered, and a probe nobody can hear would request a device for nothing.
      * @param policy - The new policy.
      */
     setPolicy(policy: AccelerationPolicy): void;

package/dist/src/acceleration/registry.d.ts

@@ -92,6 +92,9 @@ export declare class AcceleratorRegistry {
 /**
  * The registry the element uses when it is not given another, and the one the `./webgpu` entry
  * point registers into.
+ *
+ * One per page rather than one per copy of graphty-element, so the `./webgpu` entry reaches the
+ * element whichever copy defined it.
  */
 export declare const acceleratorRegistry: AcceleratorRegistry;
 /**

package/dist/src/acceleration/types.d.ts

@@ -221,6 +221,13 @@ export type AcceleratorFactory = (options?: AcceleratorFactoryOptions) => Promis
  * renders. It is plain, frozen, serialisable data: no GPU objects, no promises, no classes.
  */
 export interface AccelerationStatus {
+    /**
+     * The policy in force: what the consumer asked for, however they asked -- the `acceleration`
+     * attribute, the property, or `session.acceleration`. A change of policy publishes a new
+     * status even when the state does not move.
+     * @since 2.3.0
+     */
+    readonly policy: AccelerationPolicy;
     /** The one-word state. */
     readonly state: AccelerationState;
     /** The attached accelerator's backend, when one is attached. */

package/dist/src/algorithms/Algorithm.d.ts

@@ -50,8 +50,21 @@ export interface AlgorithmStatics {
      *
      * Absent, the element estimates from the `costClass` the descriptor declares, which is what
      * every algorithm this package ships does.
+     *
+     * Prefer {@link costUnits}: seconds written on one machine are wrong on every other, and no
+     * calibration can scale them, so an estimate from this hook always reports "modelled".
      */
     cost?: (n: number, m: number) => number;
+    /**
+     * A cost model in WORK UNITS over a graph of n nodes and m edges, for the whole run.
+     *
+     * The units are those of the descriptor's `costClass`: elements for `instant` and
+     * `iterative` (count every iteration), source-edge pairs for `heavy`, operations for
+     * `cubic`. The element divides them by the rate it measured for that class on this device,
+     * so the estimate follows the machine and reports "calibrated" once the device is probed,
+     * exactly as a built-in's does. Wins over {@link cost} when both are declared.
+     */
+    costUnits?: (n: number, m: number) => number;
     /**
      * The plugin's own version, recorded on every run this algorithm produces.
      *

package/dist/src/cameras/InputUtils.d.ts

@@ -1,3 +1,4 @@
+import { Vector3 } from "@babylonjs/core";
 /**
  * Shared input utility functions for camera controllers.
  * Used by both 3D (OrbitInputController) and XR (XRInputHandler).
@@ -11,3 +12,69 @@
  * @returns Adjusted value with deadzone and curve applied
  */
 export declare function applyDeadzone(value: number, threshold?: number): number;
+/** Thumbstick deflection, per axis, that XR input ignores. */
+export declare const XR_THUMBSTICK_DEADZONE = 0.15;
+/**
+ * Whether a tracked hand is pinching, with hysteresis: a hand that is already pinching lets go at
+ * a looser distance than an open hand needs to start.
+ * @param distance - Thumb tip to index tip, in metres
+ * @param wasPinching - Whether the hand was pinching last frame
+ * @returns Whether the hand is pinching now
+ */
+export declare function isPinching(distance: number, wasPinching: boolean): boolean;
+/**
+ * How firmly a tracked hand is pinching: 1 with the finger tips touching, falling to 0 at the
+ * pinch start distance.
+ * @param distance - Thumb tip to index tip, in metres
+ * @returns Pinch strength in [0, 1]
+ */
+export declare function pinchStrength(distance: number): number;
+/** What one frame of thumbstick input does to the XR pivot. Zero (or a zoom of 1) means leave it alone. */
+interface ThumbstickDeltas {
+    /** Radians, for `PivotController.rotate`. */
+    yaw: number;
+    /** Radians, for `PivotController.rotate`. */
+    pitch: number;
+    /** Factor, for `PivotController.zoom`. */
+    zoom: number;
+    /** Distance, for `PivotController.panViewRelative`. */
+    pan: number;
+}
+/**
+ * Map one frame of thumbstick input to pivot movement. Left stick X yaws and Y pitches (forward
+ * moves the graph up, as mouse and touch do); right stick Y zooms (forward zooms in) and X pans.
+ * @param left - Left stick axes, each in [-1, 1]
+ * @param left.x - Left stick X
+ * @param left.y - Left stick Y
+ * @param right - Right stick axes, each in [-1, 1]
+ * @param right.x - Right stick X
+ * @param right.y - Right stick Y
+ * @returns The movement to apply this frame
+ */
+export declare function thumbstickDeltas(left: {
+    x: number;
+    y: number;
+}, right: {
+    x: number;
+    y: number;
+}): ThumbstickDeltas;
+/** What one frame of a two-hand gesture does to the XR pivot. */
+interface TwoHandGestureDelta {
+    /** Factor, for `PivotController.zoom`, clamped to [0.9, 1.1]. Hands moving apart zoom out. */
+    zoom: number;
+    /** Unit axis for `PivotController.rotateAroundAxis`, or null when the hands did not turn. */
+    axis: Vector3 | null;
+    /** Radians, for `PivotController.rotateAroundAxis`. */
+    angle: number;
+}
+/**
+ * Map the change in the line between two pinching hands, from one frame to the next, to pivot
+ * movement: the change in its length zooms, and the change in its direction rotates.
+ * @param previousDistance - Distance between the hands last frame
+ * @param previousDirection - Unit vector from left hand to right hand last frame
+ * @param distance - Distance between the hands this frame
+ * @param direction - Unit vector from left hand to right hand this frame
+ * @returns The movement to apply this frame
+ */
+export declare function twoHandGestureDelta(previousDistance: number, previousDirection: Vector3, distance: number, direction: Vector3): TwoHandGestureDelta;
+export {};

package/dist/src/cameras/XRInputHandler.d.ts

@@ -32,14 +32,6 @@ export declare class XRInputHandler {
     private previousDirection;
     private wasPinching;
     private handTrackingFeature;
-    private readonly DEADZONE;
-    private readonly YAW_SPEED;
-    private readonly PITCH_SPEED;
-    private readonly PAN_SPEED;
-    private readonly ZOOM_SPEED;
-    private readonly GESTURE_ZOOM_SENSITIVITY;
-    private readonly _PINCH_START;
-    private readonly _PINCH_END;
     private lastControllerRemovedTime;
     private readonly INPUT_SWITCH_DELAY_MS;
     private isDraggingNode;

package/dist/src/catalog/pluginRegistry.d.ts

@@ -33,6 +33,12 @@
  * {@link PluginRegistry.clearForTesting} exists so a suite can leave the registry as it found
  * it, and is named so nobody can mistake it for part of the contract.
  *
+ * ONE STORE PER PAGE, NOT PER COPY. A page can evaluate graphty-element twice -- the self-contained
+ * bundle beside an `./extend` import, two installs of the package, a dev server loading one module
+ * under two URLs -- and the element deliberately survives that. Every registry therefore keeps its
+ * state on `globalThis` under a `Symbol.for` key ({@link sharedStore}), so a registration made
+ * through any copy reaches the element any other copy defined.
+ *
  * NOTHING HERE IMPORTS A CLASS, a reader, an engine or a renderer. A registry holds whatever it
  * was handed at run time, which is what keeps `./catalog` and `./extend` resolvable in Node.
  */
@@ -110,6 +116,62 @@ export interface PluginRegistrySpec<TEntry, TDescriptor> {
      */
     builtInIds(): readonly string[];
 }
+/**
+ * The one instance of a piece of registry state on this page, whichever copy of graphty-element
+ * asks for it.
+ *
+ * Keyed on `Symbol.for`, which is shared by every realm-local module graph, so two copies of this
+ * module find the same value. The `v1` names the shape of what is stored, and that includes the
+ * shape of every entry and descriptor inside it, not only the container: any change to an entry
+ * or a descriptor that an older copy on the same page cannot read must bump the version, so the
+ * two copies keep separate stores rather than misreading each other's.
+ * @param kind - Which piece of state.
+ * @param create - Builds it the first time any copy asks.
+ * @returns The page's instance.
+ */
+export declare function sharedStore<T>(kind: string, create: () => T): T;
+/**
+ * A map from name to implementation (a class, a factory) that this copy of graphty-element reads
+ * first and every other copy on the page reads after its own.
+ *
+ * THIS COPY'S OWN ENTRIES WIN, because they include its built-ins: a second copy's box shape is
+ * built with the second copy's Babylon.js, and its degree algorithm extends the second copy's base
+ * class, so handing those to this copy's element would mix two renderers in one scene. What a copy
+ * does not have itself -- a plugin registered through another copy -- comes from the page's
+ * shared map.
+ */
+export declare class SharedImplementationMap<V> {
+    #private;
+    /**
+     * Join the page's shared map for this extension point, creating it if this copy is first.
+     * @param kind - Which extension point, which names the page's shared map.
+     */
+    constructor(kind: string);
+    /**
+     * File an implementation for this copy and for every other copy on the page.
+     * @param name - The name it is filed under.
+     * @param value - The implementation.
+     */
+    set(name: string, value: V): void;
+    /**
+     * This copy's implementation, or else the one another copy filed.
+     * @param name - The name.
+     * @returns The implementation, or undefined when no copy filed one.
+     */
+    get(name: string): V | undefined;
+    /**
+     * Whether THIS copy filed the name, which is what a built-in duplicate check asks: another
+     * copy registering its own built-ins is not a collision.
+     * @param name - The name.
+     * @returns True when this copy filed it.
+     */
+    hasOwn(name: string): boolean;
+    /**
+     * Every name any copy filed.
+     * @returns The names, this copy's first.
+     */
+    keys(): IterableIterator<string>;
+}
 /**
  * Build a registry for one extension point.
  * @param spec - How this kind of extension is read.

package/dist/src/catalog/registry.d.ts

@@ -61,6 +61,13 @@ export interface RegisteredAlgorithm {
      * plugin still supplies real arithmetic for the estimator to use.
      */
     readonly cost?: (n: number, m: number) => number;
+    /**
+     * A cost model in work units of the descriptor's cost class, read from `static costUnits`.
+     *
+     * The estimator divides it by this device's rate for that class, so calibration scales it.
+     * Wins over {@link cost} when both are present.
+     */
+    readonly costUnits?: (n: number, m: number) => number;
     /**
      * The plugin's own version, read from `static version`.
      *

package/dist/src/data/DataSource.d.ts

@@ -1,5 +1,5 @@
 import * as z4 from "zod/v4/core";
-import type { RegisterOptions } from "../catalog/pluginRegistry";
+import { type RegisterOptions } from "../catalog/pluginRegistry";
 import type { FormatDescriptor } from "../catalog/types";
 import { AdHocData } from "../config";
 import { ErrorAggregator } from "./ErrorAggregator.js";

package/dist/src/errors/codes.d.ts

@@ -163,7 +163,8 @@ export type GraphtyErrorCode =
 /**
  * A source could not be fetched: a network failure, a non-2xx status, a CORS refusal or an
  * unreadable file. `details` carry the url and the status where there was one, and `cause`
- * carries the original failure. Usually recoverable by retrying.
+ * carries the original failure. Recoverable by retrying, except a client error (a 4xx other
+ * than 408 and 429), which fails after one request with `recoverable: false`.
  */
  | "E_FETCH_FAILED"
 /**

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;