@neo4j-nvl/base 1.2.2 → 2.0.0

package/dist/types/modules/state/types.d.ts

@@ -34,29 +34,98 @@ export type DisabledItemStyles = {
     fontColor: string;
 };
 /**
- * The options for the force directed layout
+ * Identifier returned by {@link ClusterByFn} to group nodes into physical clusters.
+ * Nodes sharing the same string or number are clustered together.
  */
-export interface ForceDirectedOptions {
+export type ClusterId = string | number;
+/**
+ * A physical cluster produced by {@link ClusteringOptions.clusterBy}.
+ * Not a graph element — used for hit-testing and interaction callbacks.
+ */
+export type Cluster = {
+    /** Semantic cluster id returned by {@link ClusterByFn}. */
+    id: ClusterId;
+    /** Real member node ids belonging to this cluster (at least two). */
+    nodeIds: string[];
+};
+/**
+ * Function that maps a node id to a {@link ClusterId} for force-directed clustering.
+ * Returns `undefined` for nodes that should remain independent.
+ */
+export type ClusterByFn = (nodeId: string) => ClusterId | undefined;
+/**
+ * Options that control physical clustering and cluster decorations for the force-directed layout.
+ */
+export interface ClusteringOptions {
+    /**
+     * Optional function to group nodes into physical clusters based on a custom identifier.
+     * Nodes returning the same string or number will be grouped together in the layout.
+     * Nodes returning undefined will be treated as independent.
+     *
+     * @note Ensure this function has a stable reference to avoid evaluation on every render.
+     */
+    clusterBy?: ClusterByFn;
     /**
-     * Enables a workaround for Intel GPU compatibility issues in WebGL shader compilation.
-     * When enabled, this flag modifies how physics simulation shaders are compiled to avoid
-     * rendering problems on Intel graphics hardware.
+     * Draws a convex-hull outline around each cluster.
      *
-     * @remarks Requires a restart of NVL as shaders need to be recompiled.
+     * @note Outline color is the same as the nodes in the cluster.
+     * If the nodes in the cluster have different colors, the outline uses
+     * {@link NvlOptions.styling.overlayLineColor}.
+     * @defaultValue false
+     */
+    drawOutline?: boolean;
+    /**
+     * Fills a soft glowing halo around each cluster.
      *
-     * @deprecated This option will be removed in a future release, where WebGL will be upgraded to WebGL2,
-     * which resolves the compatibility issues with Intel GPUs.
+     * @note Halo color is the same as the nodes in the cluster.
+     * If the nodes in the cluster have different colors, the halo won't be shown.
+     * @defaultValue false
      */
-    intelWorkaround?: boolean;
+    drawHalo?: boolean;
     /**
-     * @deprecated This option will be removed in a future release. For small datasets, use the d3Force layout instead.
-     * Whether to enable automatic switching to CoseBilkent layout for small graphs.
-     * When enabled, small graphs will automatically use the CoseBilkent layout algorithm
-     * which can provide better initial positioning for smaller datasets.
-     * @defaultValue true
+     * Spring force multiplier for relationships that cross a {@link ClusteringOptions.clusterBy}
+     * cluster boundary.
+     * Capped between `0` and `1`.
+     * `0` disables cross-cluster spring pull. `1` is full strength. Intra-cluster edges are always
+     * full strength. Only applies when {@link ClusteringOptions.clusterBy} is set.
+     * @defaultValue 0
+     * @experimental
+     * @note Can cause unstable layouts when set to close to `1` in highly connected graphs.
+     */
+    crossClusterRelationshipMultiplier?: number;
+}
+/**
+ * The options for the force directed layout
+ */
+export interface ForceDirectedOptions {
+    /**
+     * How initial node positions are seeded before the physics simulation runs.
+     * @defaultValue 'box'
+     */
+    seedingMethod?: 'box' | 'circle';
+    /**
+     * Physical clustering and cluster decoration options.
      */
-    enableCytoscape?: boolean;
+    clustering?: ClusteringOptions;
 }
+/**
+ * Returns the clustering options from force-directed layout options, if present.
+ * @param layoutOptions - The layout options to read from.
+ * @returns The clustering options, or undefined when absent / not force-directed.
+ */
+export declare const getClusteringOptions: (layoutOptions?: LayoutOptions) => ClusteringOptions | undefined;
+/**
+ * Whether {@link ClusteringOptions.drawOutline} is enabled on the given layout options.
+ * @param layoutOptions - The layout options to check.
+ * @returns Whether {@link ClusteringOptions.drawOutline} is enabled on the given layout options.
+ */
+export declare const isDrawClusterOutlineEnabled: (layoutOptions?: LayoutOptions) => boolean;
+/**
+ * Whether {@link ClusteringOptions.drawHalo} is enabled on the given layout options.
+ * @param layoutOptions - The layout options to check.
+ * @returns Whether {@link ClusteringOptions.drawHalo} is enabled on the given layout options.
+ */
+export declare const isDrawClusterHaloEnabled: (layoutOptions?: LayoutOptions) => boolean;
 /**
  * The options for the hierarchical layout
  */
@@ -65,6 +134,16 @@ export interface HierarchicalOptions {
     direction?: 'up' | 'down' | 'left' | 'right';
     /** The packing method to be used */
     packing?: 'bin' | 'stack';
+    /**
+     * Optional function to group nodes into semantic clusters based on a custom identifier.
+     * Nodes returning the same string or number will be grouped together in the layout via
+     * dagre compound subgraphs. Nodes returning undefined will be treated as independent.
+     *
+     * @note Ensure this function has a stable reference to avoid evaluation on every render.
+     *
+     * @experimental
+     */
+    clusterBy?: ClusterByFn;
 }
 export declare const isHierarchicalLayoutOptions: (options: LayoutOptions) => options is HierarchicalOptions;
 /**
@@ -102,11 +181,12 @@ export declare const d3ForceLayoutType = "d3Force";
  */
 export declare const CircularLayoutType = "circular";
 /**
- * A WebGL renderer that uses the GPU for rendering.
+ * A WebGL2 renderer that uses the GPU for rendering.
  *
  * @remarks
- * This renderer has better performance than the canvas renderer,
- * but does not support captions and arrowheads.
+ * Upgraded to WebGL2 in NVL 2.0.
+ * This renderer has better performance than the canvas renderer.
+ * Supports rendering node icons and relationship arrowheads, but does not support captions.
  */
 export declare const WebGLRendererType = "webgl";
 /**
@@ -114,7 +194,7 @@ export declare const WebGLRendererType = "webgl";
  *
  * @remarks
  * This renderer has lower performance than the WebGL renderer,
- * but supports captions and arrowheads.
+ * but supports captions.
  */
 export declare const CanvasRendererType = "canvas";
 /**
@@ -183,8 +263,9 @@ export interface NvlOptions {
     /**
      * What renderer to use
      * @defaultValue 'canvas'
-     * WebGL renderer uses GPU and has better performance.
-     * Captions and arrowheads are only displayed when using the canvas or svg renderer.
+     * WebGL renderer uses GPU (WebGL2) and has better performance.
+     * Supports node icons and relationship arrowheads.
+     * Captions are only displayed when using the canvas or svg renderer.
      */
     renderer?: Renderer;
     /**
@@ -239,11 +320,23 @@ export interface NvlOptions {
         minimapViewportBoxColor?: string;
     };
     /**
-     * @internal
-     * @hidden
-     * Defines a time limit for how long layout iterations may run
+     * Target minimum presentation fps while layout is active, at the cost of stabilization speed when set higher.
+     * Budgets layout steps only. Actual fps may undershoot when rendering is expensive.
+     *
+     * @defaultValue 3
+     *
+     * @note Will be capped between 1 and 120.
+     */
+    minFps?: number;
+    /**
+     * Target maximum presentation fps while layout is active; extra time in the tick goes to layout stabilization.
+     * Budgets layout steps only. Actual fps may undershoot when rendering is expensive.
+     *
+     * @defaultValue 30
+     *
+     * @note Will be capped between 1 and 120.
      */
-    layoutTimeLimit?: number;
+    maxFps?: number;
     /**
      * Disables tracking of library usage
      * @defaultValue false

package/dist/types/renderers/ClusterOverlay.d.ts

@@ -0,0 +1,73 @@
+import { type CoarsenedGraph } from '../layouts/forcedirectedlayout/clustering/types';
+import { type NvlState } from '../modules/state/types';
+import type { Node } from '../types/graph-element';
+import { type Point } from '../utils/geometry';
+type ClusterPositions = Readonly<Record<string, Point>> | (() => (Node & Point)[]);
+/**
+ * Canvas2D overlay for cluster decorations.
+ */
+export default class ClusterOverlay {
+    private readonly canvas;
+    private readonly context;
+    private readonly state;
+    private readonly stateDisposers;
+    private readonly clusterColors;
+    private clusterColorsDirty;
+    private cachedFirstSubGraphLevel;
+    private cachedIdToPosition;
+    private cachedPositionListVersion;
+    private readonly clusterGeometry;
+    private geometryPositionsVersion;
+    constructor(canvas: HTMLCanvasElement, context: CanvasRenderingContext2D, state: NvlState);
+    /** Clears the overlay. */
+    clear(): void;
+    /**
+     * Draws cluster decorations for a given multi-member first-level sun system and positions.
+     * @param subGraphs - Layout coarsening hierarchy (`subGraphs[1]` = first-level suns).
+     * @param positions - Node id to position map, or a getter for a lagged position list.
+     * @param cacheVersion - PhysLayout positions-cache version.
+     */
+    render(subGraphs: CoarsenedGraph[], positions: ClusterPositions, cacheVersion: number): void;
+    destroy(): void;
+    private resetClusterColorCache;
+    private resetGeometryCache;
+    private syncGeometryCacheVersion;
+    private resetPositionCache;
+    /**
+     * Returns an id to position map. Records are used as-is. Getters are converted once per `cacheVersion`.
+     * @param positions - Node id to position map, or a getter for a lagged position list.
+     * @param cacheVersion - PhysLayout positions-cache version; ignored for maps.
+     * @returns An id to position map.
+     */
+    private resolveIdToPosition;
+    /**
+     * Rebuilds {@link clusterColors} for every multi-member first-level sun.
+     * @param firstSubGraphLevel - `subGraphs[1]` from the current layout coarsening hierarchy.
+     */
+    private rebuildClusterColors;
+    /**
+     * Returns fitted world-space hull for a cluster, reusing the last fit while the
+     * positions cache version is unchanged (e.g. pan/zoom-only frames while layout is stable).
+     * @param sunId - Original id of the sun the hull belongs to.
+     * @param collectMembers - Builds the member disks to fit; only called on a cache miss.
+     * @returns The fitted hull, or null when the cluster cannot be fitted.
+     */
+    private getCachedHull;
+    private fillHalo;
+    private strokeOutline;
+    /**
+     * Traces a closed rounded path along the given points.
+     * @param points - The points to trace the path along.
+     */
+    private traceSmoothClosedPath;
+    private applyZoomAndPan;
+    /**
+     * Returns the shared member color when color is consistent; otherwise null.
+     * @param nodeIds - The IDs of the nodes in the cluster.
+     * @param idToItem - The map of node IDs to items.
+     * @param defaultNodeColor - The default node color.
+     * @returns The shared member color when color is consistent; otherwise null.
+     */
+    private resolveUnanimousClusterColor;
+}
+export {};

package/dist/types/renderers/ClusterOverlay.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/renderers/domrenderer/shared/ImageCache.d.ts

@@ -4,6 +4,7 @@ declare class ImageCache {
     private readonly onImageLoadedCb?;
     constructor(onImageLoaded?: () => void);
     getImage(src: string, inverted?: boolean): HTMLCanvasElement;
+    isDrawn(src: string, inverted?: boolean): boolean;
     private getOrCreateEntry;
     private invertCanvas;
     private loadImage;

package/dist/types/renderers/domrenderer/shared/types.d.ts

@@ -11,8 +11,7 @@ export type TextSegment = {
  */
 export type StyledCaption = {
     /**
-     * The font styles as an array of style keywords.
-     * @example `['bold', 'italic']`
+     * The font styles as an array of style keywords, e.g. `['bold', 'italic']`.
      */
     styles?: string[];
     /** The text value for the caption. */

package/dist/types/renderers/webglrenderer/Controller.d.ts

@@ -10,8 +10,10 @@ export interface ControllerInterface {
     stateDisposers: NvlState['autorun'][];
     state: NvlState;
     needsToRun: () => boolean;
-    renderMainScene: (positionArray: Node[]) => void;
-    renderMinimap: (positionArray: Node[]) => void;
+    renderMainScene: (positionArray: Node[], positionsChanged?: boolean) => void;
+    renderMainSceneFromTexture: (positionTexture: WebGLTexture) => void;
+    setPositionTexelIndices: (map: Readonly<Record<string, number>> | null) => void;
+    renderMinimap: (positionArray: Node[], positionsChanged?: boolean) => void;
     checkForUpdates: (nodes: DataSet<Node>, rels: DataSet<Relationship>) => void;
     onResize: () => void;
     updateMainViewport: (zoom: number, panX: number, panY: number) => void;
@@ -34,8 +36,25 @@ export default class Controller implements ControllerInterface {
         state?: NvlState;
     });
     needsToRun(): boolean;
-    renderMainScene(positionArray: Node[]): void;
-    renderMinimap(positionArray: Node[]): void;
+    renderMainScene(positionArray: Node[], positionsChanged?: boolean): void;
+    /**
+     * Renders the main scene from a GPU position texture instead of a
+     * CPU position array, avoiding the readback + upload round trip.
+     * @param positionTexture - Live GPU node-position texture to render from.
+     */
+    renderMainSceneFromTexture(positionTexture: WebGLTexture): void;
+    /**
+     * Sets the node-id -> texel-index map for the main scene renderer so it
+     * samples a shared position texture in the layout's order. Pass null to use
+     * insertion order.
+     * @param map - The node-id-to-texel-index map, or null.
+     *
+     * @note The minimap keeps insertion-order sampling and uploads lagged CPU
+     * positions (async PhysLayout cache) while the main scene may sample the
+     * shared GPU texture.
+     */
+    setPositionTexelIndices(map: Readonly<Record<string, number>> | null): void;
+    renderMinimap(positionArray: Node[], positionsChanged?: boolean): void;
     checkForUpdates(nodes: DataSet<Node>, rels: DataSet<Relationship>): void;
     onResize(): void;
     updateMainViewport(zoom: number, panX: number, panY: number): void;
@@ -52,8 +71,10 @@ export declare class DummyController implements ControllerInterface {
     minimapMouseDown: boolean;
     stateDisposers: NvlState['autorun'][];
     state: NvlState;
-    renderMainScene(positionArray: Node[]): void;
-    renderMinimap(positionArray: Node[]): void;
+    renderMainScene(positionArray: Node[], positionsChanged?: boolean): void;
+    renderMainSceneFromTexture(positionTexture: WebGLTexture): void;
+    setPositionTexelIndices(map: Readonly<Record<string, number>> | null): void;
+    renderMinimap(positionArray: Node[], positionsChanged?: boolean): void;
     checkForUpdates(nodes: DataSet<Node>, rels: DataSet<Relationship>): void;
     onResize(): void;
     updateMainViewport(zoom: number, panX: number, panY: number): void;

package/dist/types/renderers/webglrenderer/IconLayerRegistry.d.ts

@@ -0,0 +1,14 @@
+export declare const MaxIconLayers = 256;
+/**
+ * Maps icon URLs to stable layer indices for a WebGL `sampler2DArray`.
+ * Delegates image loading and rasterization to {@link ImageCache}.
+ */
+export declare class IconLayerRegistry {
+    private readonly imageCache;
+    private readonly layerMap;
+    constructor(onImageLoaded?: () => void);
+    getLayer(url: string, inverted: boolean): number | null;
+    hasLoadingLayers(): boolean;
+    layerCount(): number;
+    getAvailableCanvases(): Map<number, HTMLCanvasElement>;
+}

package/dist/types/renderers/webglrenderer/IconLayerRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/renderers/webglrenderer/Renderer.d.ts

@@ -2,11 +2,17 @@ import { mat4 } from 'gl-matrix';
 import type { DataSet } from '../../modules/dataset';
 import type { NvlState } from '../../modules/state/types';
 import type { Node, Relationship } from '../../types/graph-element';
+export type RendererOptions = {
+    enableIcons?: boolean;
+};
 export default class Renderer {
     private readonly nodeShader;
     private readonly nodeAnimShader;
     private readonly relShader;
+    private readonly arrowShader;
     private relDataBuffer;
+    private arrowDataBuffer;
+    private arrowData;
     private readonly viewportBoxShader;
     private readonly defaultRelColor;
     private readonly defaultNodeColor;
@@ -14,39 +20,73 @@ export default class Renderer {
     private readonly disableNodeColor;
     private readonly gl;
     activeNodes: Record<string, boolean>;
+    numActiveNodes: number;
     readonly canvas: HTMLCanvasElement;
     projection: mat4;
     private idToIndex;
+    /** Node-id → texel-index map for GPU-shared rendering; null falls back to insertion order. */
+    private texelIndexForId;
+    /** texelIndexForId value when vertex buffers were last built; used to detect changes in the texel-index mapping. */
+    private texelMapAtBuild;
+    private lastNodes;
+    private lastBundledRels;
+    private idToSize;
     private posBuffer;
+    private positionsDirty;
     private numRels;
     private numNodes;
     private nodeDataByte;
     private relIdToIndex;
     private relData;
     private viewportBoxBuffer;
+    private readonly viewportBoxVertices;
     private relBuffer;
+    private arrowBuffer;
     private nodeBuffer;
     private posTexture;
+    private iconTexture;
     private nodeVao;
     private relVao;
+    private arrowVao;
     private nodeAnimVao;
-    private vaoExt;
-    constructor(gl: WebGLRenderingContext, nodes: DataSet<Node>, rels: DataSet<Relationship>, state: NvlState);
+    private readonly iconLayers;
+    private uploadedIconLayers;
+    private nodeColors;
+    private nodeDisabled;
+    constructor(gl: WebGL2RenderingContext, nodes: DataSet<Node>, rels: DataSet<Relationship>, state: NvlState, options?: RendererOptions);
     private setShaderUniforms;
     setData(data: {
         nodes: Node[];
         rels: Relationship[];
     }): void;
-    render(positionArray: Node[]): void;
+    /** Sets the texel-index map for GPU-shared rendering, or null for insertion order. */
+    setPositionTexelIndices(map: Readonly<Record<string, number>> | null): void;
+    /** Texel index for a node id; falls back to insertion index, or 0 if the id is unknown. */
+    private getTexelIndex;
+    /**
+     * Rebuilds vertex buffers when the texel-index mapping has changed since the last build.
+     */
+    private rebuildBuffersIfTexelMappingChanged;
+    render(positionArray: Node[], positionsChanged?: boolean): void;
+    /** Renders using a GPU position texture directly as `u_positions` */
+    renderFromGpuTexture(positionTexture: WebGLTexture): void;
+    private renderRelationships;
     renderViewbox(): void;
     updateNodes(updates: Node[]): void;
     updateRelationships(relItems: Relationship[]): void;
     private createPositionTexture;
+    private createIconTexture;
+    private uploadPendingIconLayers;
+    hasPendingIcons(): boolean;
     updateViewportBox(zoom: number, panX: number, panY: number, viewportWidth: number, viewportHeight: number): void;
     updateViewport(zoom: number, panX: number, panY: number): void;
     private setupViewportRendering;
+    private resolveNodeColor;
     private setupNodeRendering;
     private setupRelationshipRendering;
+    private setupArrowRendering;
+    private getRelBufferAttributes;
+    private updateEndpointSizesForNode;
     private renderAnimations;
     destroy(): void;
 }

package/dist/types/renderers/webglrenderer/node-animation-fragment.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mediump float u_zoom;\nuniform lowp float u_animPos;\nuniform mediump float u_glAdjust;\n\nvarying lowp vec4 color;\nvarying lowp float varNodeSize;\nmediump float circleSize = 0.50;\n\nvoid main(void) {\n\n  lowp float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  }\n  else {\n    lowp float alpha = 1.0 - smoothstep(circleSize - (1.0 / (varNodeSize * 2.0 * u_zoom * u_glAdjust)), circleSize, dist);\n    lowp float pulseAlpha = 0.9 - 0.9 * u_animPos;\n    gl_FragColor = vec4(color.xyz, 1.0) * alpha * pulseAlpha;\n  }\n}\n";
+declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform mediump float u_zoom;\nuniform lowp float u_animPos;\nuniform mediump float u_glAdjust;\n\nin lowp vec4 color;\nin mediump float varNodeSize;\n\nout vec4 fragColor;\n\nconst float pulseCircleEdge = 0.50;\n\nvoid main(void) {\n  float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  } else {\n    float alpha = 1.0 - smoothstep(pulseCircleEdge - (1.0 / (varNodeSize * 2.0 * u_zoom * u_glAdjust)), pulseCircleEdge, dist);\n    float pulseAlpha = 0.9 - 0.9 * u_animPos;\n    fragColor = vec4(color.xyz, 1.0) * alpha * pulseAlpha;\n  }\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/node-animation-vertex.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform lowp float u_animPos;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nattribute float a_size;\nattribute lowp vec2 a_index;\nattribute lowp vec4 a_color;\nattribute lowp float a_active;\n\nvarying lowp float varNodeSize;\nvarying lowp vec4 color;\n\nvoid main(void) {\n  vec4 data = texture2D(u_positions, a_index);\n\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  float nodeSize = a_size * u_zoom * u_glAdjust;\n  nodeSize = nodeSize * (0.4 / 0.5); // Remove extra space added for shadow and selection ring\n\n  gl_PointSize = a_active > 0.5\n    ? nodeSize + 0.88 * nodeSize * u_animPos\n    : 0.0;\n\n  color = a_color;\n  varNodeSize = a_size;\n}";
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform lowp float u_animPos;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nin float a_size;\nin highp vec2 a_index;\nin lowp vec4 a_color;\nin lowp float a_active;\n\nout mediump float varNodeSize;\nout lowp vec4 color;\n\nvoid main(void) {\n  vec4 data = texture(u_positions, a_index);\n\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  float nodeSize = a_size * u_zoom * u_glAdjust;\n  nodeSize = nodeSize * 0.8;\n\n  gl_PointSize = a_active > 0.5\n    ? nodeSize + 0.88 * nodeSize * u_animPos\n    : 0.0;\n\n  color = a_color;\n  varNodeSize = a_size;\n}";
 export default _default;

package/dist/types/renderers/webglrenderer/node-fragment-point.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nvarying lowp vec4 color;\nvarying lowp float drawDefaultBorder;\nvarying lowp vec3 nodeBorderColor;\nvarying lowp vec3 selectedBorderColor;\nvarying lowp vec3 selectedInnerBorderColor;\nvarying lowp vec3 shadowColor;\nvarying lowp float selected;\nvarying lowp float hovered;\nvarying lowp float varNodeSize;\n\nmediump float circleSize = 0.40;\nmediump float defaultBoderSize = 0.42;\nmediump float innerSelectedRingSize = 0.43;\nmediump float outerSelectedRingSize = 0.47;\nmediump float shadowSize = 0.51;\n\nlowp float getShadowAlpha(lowp float size, lowp float dist) {\n  return (1.0 - smoothstep(size, shadowSize, dist)) * 0.25;\n}\n\nlowp float getCircleAlpha(lowp float ringSize, lowp float nodeSize, lowp float dist) {\n  return color.w - smoothstep(ringSize - nodeSize, ringSize, dist);\n}\n\nvoid main() {\n  lowp float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  }\n  else {\n    lowp float nodeSize = 1.0 / varNodeSize;\n    lowp float nodeAlpha = getCircleAlpha(circleSize, nodeSize, dist);\n    lowp float borderAlpha = getCircleAlpha(defaultBoderSize, nodeSize, dist);\n    lowp float ringAlpha = getCircleAlpha(innerSelectedRingSize, nodeSize, dist);\n    lowp vec3 finalColor = color.xyz;\n    lowp float finalAlpha = nodeAlpha;\n\n    if (selected > 0.0) {\n      lowp float shadowAlpha = getShadowAlpha(outerSelectedRingSize, dist);\n      lowp float ringAlpha2 = getCircleAlpha(outerSelectedRingSize, nodeSize, dist);\n\n      if (drawDefaultBorder > 0.0) {\n        finalColor = mix(nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(selectedInnerBorderColor, finalColor, borderAlpha);\n        finalColor = mix(selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(borderAlpha, ringAlpha2)));\n      } else {\n        finalColor = mix(selectedInnerBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(ringAlpha, ringAlpha2)));\n      }\n    } else if (hovered > 0.0) {\n      if (drawDefaultBorder > 0.0) {\n        lowp float shadowAlpha = getShadowAlpha(defaultBoderSize, dist);\n  \n        finalColor = mix(nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(shadowColor, finalColor, borderAlpha);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, ringAlpha));\n      } else {\n        lowp float shadowAlpha = getShadowAlpha(circleSize, dist);\n\n        finalColor = mix(shadowColor, finalColor, nodeAlpha);\n        finalAlpha = max(shadowAlpha, nodeAlpha);\n      }\n    } else {\n      if (drawDefaultBorder > 0.0) {\n        finalColor = mix(nodeBorderColor, finalColor, nodeAlpha);\n        finalAlpha = borderAlpha;\n      }\n    }\n    gl_FragColor = vec4(finalColor, 1.0) * finalAlpha;\n  }\n}\n";
+declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform lowp vec3 u_nodeBorderColor;\nuniform lowp vec3 u_selectedBorderColor;\nuniform lowp vec3 u_selectedInnerBorderColor;\nuniform lowp vec3 u_shadowColor;\nuniform lowp float u_drawDefaultBorder;\nuniform lowp sampler2DArray u_icons;\nuniform mediump float u_minIconScreenPx;\n\nin lowp vec4 color;\nin lowp float selected;\nin lowp float hovered;\nin mediump float varNodeSize;\nin mediump float iconLayer;\nin lowp float hasIcon;\n\nout vec4 fragColor;\n\nconst float circleSize = 0.40;\nconst float defaultBorderSize = 0.42;\nconst float innerSelectedRingSize = 0.43;\nconst float outerSelectedRingSize = 0.47;\nconst float shadowSize = 0.51;\n\nfloat getShadowAlpha(float size, float dist) {\n  return (1.0 - smoothstep(size, shadowSize, dist)) * 0.25;\n}\n\nfloat getCircleAlpha(float ringSize, float nodeSize, float dist) {\n  return color.w - smoothstep(ringSize - nodeSize, ringSize, dist);\n}\n\nvoid main() {\n  float dist = distance(gl_PointCoord, vec2(0.5));\n\n  if (dist > 0.51) {\n    discard;\n  } else {\n    float nodeSize = 1.0 / varNodeSize;\n    float nodeAlpha = getCircleAlpha(circleSize, nodeSize, dist);\n    float borderAlpha = getCircleAlpha(defaultBorderSize, nodeSize, dist);\n    float ringAlpha = getCircleAlpha(innerSelectedRingSize, nodeSize, dist);\n    vec3 finalColor = color.xyz;\n    float finalAlpha = nodeAlpha;\n\n    if (selected > 0.0) {\n      float shadowAlpha = getShadowAlpha(outerSelectedRingSize, dist);\n      float ringAlpha2 = getCircleAlpha(outerSelectedRingSize, nodeSize, dist);\n\n      if (u_drawDefaultBorder > 0.0) {\n        finalColor = mix(u_nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(u_selectedInnerBorderColor, finalColor, borderAlpha);\n        finalColor = mix(u_selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(u_shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(borderAlpha, ringAlpha2)));\n      } else {\n        finalColor = mix(u_selectedInnerBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(u_selectedBorderColor, finalColor, ringAlpha);\n        finalColor = mix(u_shadowColor, finalColor, ringAlpha2);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, max(ringAlpha, ringAlpha2)));\n      }\n    } else if (hovered > 0.0) {\n      if (u_drawDefaultBorder > 0.0) {\n        float shadowAlpha = getShadowAlpha(defaultBorderSize, dist);\n        finalColor = mix(u_nodeBorderColor, finalColor, nodeAlpha);\n        finalColor = mix(u_shadowColor, finalColor, borderAlpha);\n        finalAlpha = max(shadowAlpha, max(nodeAlpha, ringAlpha));\n      } else {\n        float shadowAlpha = getShadowAlpha(circleSize, dist);\n        finalColor = mix(u_shadowColor, finalColor, nodeAlpha);\n        finalAlpha = max(shadowAlpha, nodeAlpha);\n      }\n    } else {\n      if (u_drawDefaultBorder > 0.0) {\n        finalColor = mix(u_nodeBorderColor, finalColor, nodeAlpha);\n        finalAlpha = borderAlpha;\n      }\n    }\n\n    bool iconLargeEnough = varNodeSize * circleSize >= u_minIconScreenPx;\n    if (hasIcon > 0.5 && iconLargeEnough) {\n      vec2 uv = (gl_PointCoord - vec2(0.5)) / circleSize + 0.5;\n\n      float inX = step(0.0, uv.x) - step(1.0, uv.x);\n      float inY = step(0.0, uv.y) - step(1.0, uv.y);\n      float isInside = inX * inY;\n\n      vec4 ic = texture(u_icons, vec3(uv, iconLayer));\n      finalColor = mix(finalColor, ic.rgb, ic.a * isInside);\n    }\n\n    fragColor = vec4(finalColor, 1.0) * finalAlpha;\n  }\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/node-vertex-point.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\nuniform lowp vec3 u_nodeBorderColor;\nuniform lowp vec3 u_selectedBorderColor;\nuniform lowp vec3 u_selectedInnerBorderColor;\nuniform lowp vec3 u_shadowColor;\nuniform lowp float u_drawDefaultBorder;\n\nattribute float a_size;\nattribute lowp vec2 a_index;\nattribute lowp vec4 a_color;\nattribute lowp float a_selected;\nattribute lowp float a_hovered;\n\nvarying lowp float window;\nvarying lowp vec4 color;\nvarying lowp float selected;\nvarying lowp float hovered;\nvarying lowp float varNodeSize;\nvarying lowp vec3 nodeBorderColor;\nvarying lowp vec3 selectedBorderColor;\nvarying lowp vec3 selectedInnerBorderColor;\nvarying lowp vec3 shadowColor;\nvarying lowp float drawDefaultBorder;\n\nlowp float MinNodeSize = 5.0;\n\nvoid main(void) {\n  vec4 data = texture2D(u_positions, a_index);\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  lowp float nodeSize = a_size * u_zoom * u_glAdjust;\n  if (nodeSize < MinNodeSize) {\n   gl_PointSize = MinNodeSize;\n   varNodeSize = MinNodeSize;\n  } else {\n    gl_PointSize = nodeSize;\n    varNodeSize = nodeSize;\n  }\n\n  color = a_color;\n  selected = a_selected;\n  hovered = a_hovered;\n  nodeBorderColor = u_nodeBorderColor;\n  selectedBorderColor = u_selectedBorderColor;\n  selectedInnerBorderColor = u_selectedInnerBorderColor;\n  shadowColor = u_shadowColor;\n  drawDefaultBorder = u_drawDefaultBorder;\n}";
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_zoom;\nuniform mediump float u_glAdjust;\n\nin float a_size;\nin highp vec2 a_index;\nin lowp vec4 a_color;\nin lowp float a_selected;\nin lowp float a_hovered;\nin lowp float a_iconLayer;\nin lowp float a_hasIcon;\n\nout lowp vec4 color;\nout lowp float selected;\nout lowp float hovered;\nout mediump float varNodeSize;\nout mediump float iconLayer;\nout lowp float hasIcon;\n\nconst float MinNodeSize = 5.0;\n\nvoid main(void) {\n  vec4 data = texture(u_positions, a_index);\n  gl_Position = u_projection * vec4(data.xy, 0.0, 1.0);\n\n  float nodeSize = max(a_size * u_zoom * u_glAdjust, MinNodeSize);\n  gl_PointSize = nodeSize;\n  varNodeSize = nodeSize;\n\n  color = a_color;\n  selected = a_selected;\n  hovered = a_hovered;\n  iconLayer = a_iconLayer * 255.0;\n  hasIcon = a_hasIcon;\n}";
 export default _default;

package/dist/types/renderers/webglrenderer/rel-fragment-line.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "varying lowp vec4 color;\n\nvoid main(void) {\n  gl_FragColor = vec4(color.xyz, 1.0) * color.w;\n}\n";
+declare const _default: "#version 300 es\nprecision lowp float;\n\nin lowp vec4 color;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  fragColor = vec4(color.xyz, 1.0) * color.w;\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/rel-glsl-utils.d.ts

@@ -0,0 +1 @@
+export declare const arrowShaderUtilsGLSL = "\nconst float CircleSize = 0.40;\nconst float HeadHalfWidthScale = 4.0;\nconst float HeadLengthScale = 2.5;\nconst float MaxHeadHalfWidthRatio = 0.6;\nconst float MaxHeadLengthRatio = 1.0;\n\n// Self-referencing relationships aren't supported in WebGL yet.\nbool relationshipIsSelfLoop(vec2 fromTexel, vec2 toTexel) {\n  return all(equal(fromTexel, toTexel));\n}\n\nvec2 perpendicular(vec2 dir) {\n  return vec2(-dir.y, dir.x);\n}\n\nfloat nodeRadiusFromSize(float size) {\n  return size * u_glAdjust * CircleSize;\n}\n\nfloat relationshipHalfWidth(float width) {\n  return width * u_glAdjust * 0.25;\n}\n\nfloat naturalArrowHeadHalfWidth(float lineHalfWidth) {\n  return lineHalfWidth * HeadHalfWidthScale + u_glAdjust;\n}\n\nfloat naturalArrowHeadLength(float headHalfWidth) {\n  return headHalfWidth * HeadLengthScale;\n}\n\nfloat clampArrowHeadHalfWidth(float lineHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadHalfWidth(lineHalfWidth);\n  float minHalfWidth = lineHalfWidth;\n  float maxHalfWidth = max(minHalfWidth, nodeRadius * MaxHeadHalfWidthRatio);\n  return clamp(natural, minHalfWidth, maxHalfWidth);\n}\n\nfloat clampArrowHeadLength(float headHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadLength(headHalfWidth);\n  float maxLength = nodeRadius * MaxHeadLengthRatio;\n  return min(natural, maxLength);\n}\n\nfloat arrowHeadClearance(float lineHalfWidth, float nodeRadius) {\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, nodeRadius);\n  return clampArrowHeadLength(headHalfWidth, nodeRadius);\n}\n";

package/dist/types/renderers/webglrenderer/rel-vertex-arrow.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_glAdjust;\n\nin vec2 a_from;\nin vec2 a_to;\nin lowp vec4 a_color;\nin float a_width;\nin float a_toSize;\n\nout lowp vec4 color;\n\n\nconst float CircleSize = 0.40;\nconst float HeadHalfWidthScale = 4.0;\nconst float HeadLengthScale = 2.5;\nconst float MaxHeadHalfWidthRatio = 0.6;\nconst float MaxHeadLengthRatio = 1.0;\n\n// Self-referencing relationships aren't supported in WebGL yet.\nbool relationshipIsSelfLoop(vec2 fromTexel, vec2 toTexel) {\n  return all(equal(fromTexel, toTexel));\n}\n\nvec2 perpendicular(vec2 dir) {\n  return vec2(-dir.y, dir.x);\n}\n\nfloat nodeRadiusFromSize(float size) {\n  return size * u_glAdjust * CircleSize;\n}\n\nfloat relationshipHalfWidth(float width) {\n  return width * u_glAdjust * 0.25;\n}\n\nfloat naturalArrowHeadHalfWidth(float lineHalfWidth) {\n  return lineHalfWidth * HeadHalfWidthScale + u_glAdjust;\n}\n\nfloat naturalArrowHeadLength(float headHalfWidth) {\n  return headHalfWidth * HeadLengthScale;\n}\n\nfloat clampArrowHeadHalfWidth(float lineHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadHalfWidth(lineHalfWidth);\n  float minHalfWidth = lineHalfWidth;\n  float maxHalfWidth = max(minHalfWidth, nodeRadius * MaxHeadHalfWidthRatio);\n  return clamp(natural, minHalfWidth, maxHalfWidth);\n}\n\nfloat clampArrowHeadLength(float headHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadLength(headHalfWidth);\n  float maxLength = nodeRadius * MaxHeadLengthRatio;\n  return min(natural, maxLength);\n}\n\nfloat arrowHeadClearance(float lineHalfWidth, float nodeRadius) {\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, nodeRadius);\n  return clampArrowHeadLength(headHalfWidth, nodeRadius);\n}\n\n\nvoid main(void) {\n  vec4 from = texture(u_positions, a_from);\n  vec4 to = texture(u_positions, a_to);\n\n  if (relationshipIsSelfLoop(a_from, a_to)) {\n    color = a_color;\n    gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n    return;\n  }\n\n  vec2 delta = to.xy - from.xy;\n  vec2 dir = normalize(delta);\n  vec2 perp = perpendicular(dir);\n\n  float toRadius = nodeRadiusFromSize(a_toSize);\n  float lineHalfWidth = relationshipHalfWidth(a_width);\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, toRadius);\n  float headLength = clampArrowHeadLength(headHalfWidth, toRadius);\n\n  vec2 tip = to.xy - dir * toRadius;\n  vec2 baseCenter = tip - dir * headLength;\n\n  int corner = gl_VertexID % 3;\n  float isTip = float(corner == 0);\n  float perpSign = float(corner == 1) - float(corner == 2);\n  vec2 basePos = mix(baseCenter, tip, isTip);\n  vec2 vertexPosition = basePos + perp * (headHalfWidth * perpSign);\n\n  color = a_color;\n  gl_Position = u_projection * vec4(vertexPosition, 0.0, 1.0);\n}\n";
+export default _default;

package/dist/types/renderers/webglrenderer/rel-vertex-line.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "uniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_glAdjust;\n\nattribute vec2 a_from;\nattribute vec2 a_to;\nattribute lowp vec4 a_color;\nattribute lowp float a_triside;\nattribute float a_width;\n\nvarying lowp vec4 color;\n\nvoid main(void) {\n  vec4 from = texture2D(u_positions, a_from);\n  vec4 to = texture2D(u_positions, a_to);\n  vec2 direction = normalize(to.xy - from.xy);\n  direction = vec2(-direction.y, direction.x);\n\n  float width = a_width * u_glAdjust * 0.5;\n\n  if (a_triside == 0.0) {\n    from.y += (width / 2.0) * direction.y;\n    from.x += (width / 2.0) * direction.x;\n  } else {\n    from.y -= (width / 2.0) * direction.y;\n    from.x -= (width / 2.0) * direction.x;\n  }\n\n  color = a_color;\n  gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n}\n";
+declare const _default: "#version 300 es\nuniform mat4 u_projection;\nuniform sampler2D u_positions;\nuniform mediump float u_glAdjust;\n\nin vec2 a_from;\nin vec2 a_to;\nin lowp vec4 a_color;\nin lowp float a_triside;\nin lowp float a_isTarget;\nin float a_endpointSize;\nin float a_otherEndpointSize;\nin float a_width;\n\nout lowp vec4 color;\n\n\nconst float CircleSize = 0.40;\nconst float HeadHalfWidthScale = 4.0;\nconst float HeadLengthScale = 2.5;\nconst float MaxHeadHalfWidthRatio = 0.6;\nconst float MaxHeadLengthRatio = 1.0;\n\n// Self-referencing relationships aren't supported in WebGL yet.\nbool relationshipIsSelfLoop(vec2 fromTexel, vec2 toTexel) {\n  return all(equal(fromTexel, toTexel));\n}\n\nvec2 perpendicular(vec2 dir) {\n  return vec2(-dir.y, dir.x);\n}\n\nfloat nodeRadiusFromSize(float size) {\n  return size * u_glAdjust * CircleSize;\n}\n\nfloat relationshipHalfWidth(float width) {\n  return width * u_glAdjust * 0.25;\n}\n\nfloat naturalArrowHeadHalfWidth(float lineHalfWidth) {\n  return lineHalfWidth * HeadHalfWidthScale + u_glAdjust;\n}\n\nfloat naturalArrowHeadLength(float headHalfWidth) {\n  return headHalfWidth * HeadLengthScale;\n}\n\nfloat clampArrowHeadHalfWidth(float lineHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadHalfWidth(lineHalfWidth);\n  float minHalfWidth = lineHalfWidth;\n  float maxHalfWidth = max(minHalfWidth, nodeRadius * MaxHeadHalfWidthRatio);\n  return clamp(natural, minHalfWidth, maxHalfWidth);\n}\n\nfloat clampArrowHeadLength(float headHalfWidth, float nodeRadius) {\n  float natural = naturalArrowHeadLength(headHalfWidth);\n  float maxLength = nodeRadius * MaxHeadLengthRatio;\n  return min(natural, maxLength);\n}\n\nfloat arrowHeadClearance(float lineHalfWidth, float nodeRadius) {\n  float headHalfWidth = clampArrowHeadHalfWidth(lineHalfWidth, nodeRadius);\n  return clampArrowHeadLength(headHalfWidth, nodeRadius);\n}\n\n\nvoid main(void) {\n  vec4 from = texture(u_positions, a_from);\n  vec4 to = texture(u_positions, a_to);\n\n  if (relationshipIsSelfLoop(a_from, a_to)) {\n    color = a_color;\n    gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n    return;\n  }\n\n  vec2 delta = from.xy - to.xy;\n  float halfWidth = relationshipHalfWidth(a_width);\n  float ownRadius = nodeRadiusFromSize(a_endpointSize);\n  float otherRadius = nodeRadiusFromSize(a_otherEndpointSize);\n  float toRadius = mix(otherRadius, ownRadius, a_isTarget);\n  float arrowClearance = arrowHeadClearance(halfWidth, toRadius);\n  float endpointClearance = ownRadius + a_isTarget * arrowClearance;\n\n  vec2 along = normalize(delta);\n  from.xy -= along * endpointClearance;\n\n  float sideSign = 1.0 - 2.0 * a_triside;\n  from.xy += sideSign * halfWidth * perpendicular(along);\n\n  color = a_color;\n  gl_Position = u_projection * vec4(from.xy, 0.0, 1.0);\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/viewport-box-fragment.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "\nvarying lowp vec4 minimapViewportBoxColor;\n\nvoid main(void) {\n gl_FragColor = minimapViewportBoxColor;\n}\n";
+declare const _default: "#version 300 es\nprecision lowp float;\n\nuniform lowp vec4 u_minimapViewportBoxColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  fragColor = u_minimapViewportBoxColor;\n}\n";
 export default _default;

package/dist/types/renderers/webglrenderer/viewport-box-vertex.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "\nattribute vec2 coordinates;\nuniform mat4 u_projection;\nuniform lowp vec4 u_minimapViewportBoxColor;\n\nvarying lowp vec4 minimapViewportBoxColor;\n\nvoid main(void) {\n  gl_Position = u_projection * vec4(coordinates, 0.0, 1.0);\n  minimapViewportBoxColor = u_minimapViewportBoxColor;\n}\n";
+declare const _default: "#version 300 es\nin vec2 coordinates;\nuniform mat4 u_projection;\n\nvoid main(void) {\n  gl_Position = u_projection * vec4(coordinates, 0.0, 1.0);\n}\n";
 export default _default;

package/dist/types/types/graph-element.d.ts

@@ -1,4 +1,5 @@
 import type { StyledCaption } from '../renderers/domrenderer/shared/types';
+import type { Point } from '../utils/geometry';
 /**
  * The base type for graph elements.
  * @private
@@ -97,6 +98,13 @@ interface Node extends GraphElement {
      */
     html?: HTMLElement;
 }
+/**
+ * A node returned by {@link NVL.getNodes} with layout coordinates and screen position.
+ * `x` and `y` are canvas/layout space; `clientPosition` is relative to the canvas element.
+ */
+type NodeWithClientPosition = Node & Point & {
+    clientPosition: Point;
+};
 /**
  * A node with only a subset of its properties.
  */
@@ -132,4 +140,4 @@ type PartialRelationship = Partial<Relationship> & {
     /** The id of the relationship. */
     id: string;
 };
-export type { Node, Relationship, PartialNode, PartialRelationship };
+export type { Node, NodeWithClientPosition, Relationship, PartialNode, PartialRelationship };

package/dist/types/types/nvl-window-functions.d.ts

@@ -1,6 +1,6 @@
-import type { Node, Relationship } from './graph-element';
+import type { Node, NodeWithClientPosition, Relationship } from './graph-element';
 export interface NvlWindow {
-    __Nvl_dumpNodes: (instanceId?: string) => Node[];
+    __Nvl_dumpNodes: (instanceId?: string) => NodeWithClientPosition[];
     __Nvl_dumpRelationships: (instanceId?: string) => Relationship[];
     __Nvl_getNodesOnScreen: (instanceId?: string) => {
         nodes: Node[];

package/dist/types/utils/canvasManagement.d.ts

@@ -13,7 +13,7 @@ export declare const createCanvasForScreenshot: (fullWidth: number, fullHeight:
 export declare const createCanvasForRenderer: (parent?: HTMLElement, onContextLostCallback?: (e: WebGLContextEvent) => void) => HTMLCanvasElement;
 export declare const removeCanvas: (canvas: HTMLCanvasElement) => void;
 export declare const getCanvas2DContext: (canvas: HTMLCanvasElement) => CanvasRenderingContext2D;
-export declare const getWebGLContext: (canvas: HTMLCanvasElement) => WebGLRenderingContext;
+export declare const getWebGLContext: (canvas: HTMLCanvasElement) => WebGL2RenderingContext | null;
 export declare const removeWebGLContext: (webGLCtx: WebGLRenderingContext) => void;
 export declare const checkWebGLAvailability: (canvas?: HTMLCanvasElement) => boolean;
 /**

package/dist/types/utils/clusterGeometry.d.ts

@@ -0,0 +1,14 @@
+import { type Point } from './geometry';
+/** Extra world-space padding around each member disk before taking the cluster hull. */
+export declare const ClusterHullPadding = 14;
+/** Circumference samples per member disk before taking the convex hull. */
+export declare const DiskSampleCount = 8;
+export type ClusterMemberDisk = Point & {
+    radius: number;
+};
+/**
+ * Fits a convex hull around the given disks by sampling each member circumference.
+ * @param members - The cluster member disks to fit the hull around.
+ * @returns The fitted hull, or null if fewer than two members have a usable position/radius.
+ */
+export declare const fitClusterHull: (members: ClusterMemberDisk[]) => Point[] | null;

package/dist/types/utils/clusterGeometry.test.d.ts

@@ -0,0 +1 @@
+export {};