@neo4j-nvl/base 1.2.0-158df7fc → 1.2.0-1fcd4d14

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@ import type { CircularOptions, ForceDirectedOptions, HierarchicalOptions, Render
 import { CanvasRendererType, CircularLayoutType, ForceDirectedLayoutType, FreeLayoutType, GridLayoutType, HierarchicalLayoutType, SvgRendererType, WebGLRendererType, d3ForceLayoutType } from './modules/state/types';
 import { drawCircleBand } from './renderers/domrenderer/canvasrenderer/nodeDrawing';
 import type { StyledCaption } from './renderers/domrenderer/shared/types';
-import type { Node, PartialNode, PartialRelationship, Relationship } from './types/graph-element';
+import type { Node, NodeWithClientPosition, PartialNode, PartialRelationship, Relationship } from './types/graph-element';
 import { CompatibilityError } from './utils/errors';
 import type { Point } from './utils/geometry';
 import type { HitTargetNode, HitTargetRelationship, HitTargets } from './utils/hittest';
@@ -139,9 +139,10 @@ declare class NVL {
     removeRelationshipsWithIds(relationshipIds: string[]): void;
     /**
      * Returns all nodes that is currently stored in the visualisation.
-     * @returns The array of {@link Node nodes}.
+     * Each node includes layout coordinates (`x`, `y`) and a `clientPosition` in screen space.
+     * @returns The array of {@link NodeWithClientPosition nodes}.
      */
-    getNodes(): Node[];
+    getNodes(): NodeWithClientPosition[];
     /**
      * Returns the relationships that are currently in the visualization.
      * @returns An array of the {@link Relationship relationships} in the visualization.
@@ -415,5 +416,5 @@ declare const colorMapperFunctions: {
  */
 type Renderer = Exclude<InternalRenderer, typeof SvgRendererType>;
 export default NVL;
-export type { NvlOptions, Renderer, Node, Relationship, PartialNode, PartialRelationship, Layout, LayoutOptions, ForceDirectedOptions, HierarchicalOptions, CircularOptions, ExternalCallbacks, HitTargets, HitTargetNode, HitTargetRelationship, Point, NvlMouseEvent, ZoomOptions, StyledCaption, WebGLRendererType, CanvasRendererType };
+export type { NvlOptions, Renderer, Node, NodeWithClientPosition, Relationship, PartialNode, PartialRelationship, Layout, LayoutOptions, ForceDirectedOptions, HierarchicalOptions, CircularOptions, ExternalCallbacks, HitTargets, HitTargetNode, HitTargetRelationship, Point, NvlMouseEvent, ZoomOptions, StyledCaption, WebGLRendererType, CanvasRendererType };
 export { NVL, colorMapperFunctions, CompatibilityError, ForceDirectedLayoutType, HierarchicalLayoutType, GridLayoutType, FreeLayoutType, d3ForceLayoutType, CircularLayoutType, drawCircleBand, nvlResultTransformer, getZoomTargetForNodePositions };

package/dist/types/layouts/animatedlayout/AnimatedLayout.d.ts

@@ -1,5 +1,5 @@
 import type { NvlState } from '../../modules/state/types';
-import type { Node } from '../../types/graph-element';
+import type { Node, PartialNode } from '../../types/graph-element';
 export default class AnimatedLayout {
     positions: Record<string, Node>;
     oldPositions: Record<string, Node>;
@@ -20,6 +20,6 @@ export default class AnimatedLayout {
     updateOldPositionFromState(): void;
     startAnimation(): void;
     update(): void;
-    updateNodes(positionList: Node[]): void;
+    updateNodes(positionList: PartialNode[]): void;
     getNodePositions(nodeList: Node[]): Node[];
 }

package/dist/types/layouts/d3forcelayout/d3ForceLayout.d.ts

@@ -1,6 +1,6 @@
 import type { Simulation, SimulationLinkDatum, SimulationNodeDatum } from 'd3-force';
 import type { NvlState } from '../../modules/state/types';
-import type { Node, Relationship } from '../../types/graph-element';
+import type { Node, PartialNode, Relationship } from '../../types/graph-element';
 import type { Point } from '../../utils/geometry';
 import type { D3Node } from './types';
 export declare class D3ForceLayout {
@@ -20,7 +20,7 @@ export declare class D3ForceLayout {
         state: NvlState;
     });
     setOptions(options: any): void;
-    updateNodes(positionList: D3Node[]): void;
+    updateNodes(positionList: PartialNode[]): void;
     update(refreshPositions?: boolean): void;
     layout(_nodes: Node[], _rels: Relationship[], firstTimeAddingNodes: boolean): void;
     getNodePositions(nodeList: D3Node[]): any[];

package/dist/types/layouts/forcedirectedlayout/physlayout/PhysLayout.d.ts

@@ -1,5 +1,5 @@
 import type { ForceDirectedOptions, NvlState } from '../../../modules/state/types';
-import type { Node, Relationship } from '../../../types/graph-element';
+import type { Node, PartialNode, Relationship } from '../../../types/graph-element';
 import type { Point } from '../../../utils/geometry';
 export declare class PhysLayout {
     private physVbo;
@@ -18,6 +18,7 @@ export declare class PhysLayout {
     private stateDisposers;
     private state;
     private dpr;
+    private maxGlNodeSize;
     private simulationStopVelocitySquared;
     private gravity;
     private force;
@@ -45,6 +46,9 @@ export declare class PhysLayout {
     private updateData;
     private updateShader;
     private physPositions;
+    private physDirty;
+    private convergencePbo;
+    private convergenceFence;
     private springTexture;
     private sizeTexture;
     private offsetTexture;
@@ -95,6 +99,51 @@ export declare class PhysLayout {
      * Stops the layout
      */
     terminateUpdate(): void;
+    /**
+     * Synchronously reads the latest node positions/velocities from the GPU into
+     * this.physPositions.
+     */
+    private readbackPositions;
+    /**
+     * Drives the convergence-readback state machine for the current iteration:
+     * consumes a pending fence if one is ready, otherwise starts a new readback
+     * when a convergence check is due.
+     * @returns Whether fresh velocity data is available.
+     */
+    private tryConsumeConvergenceReadback;
+    /**
+     * The GPU texture holding the latest node positions (xy) and velocities (zw).
+     * @returns The RGBA32F position texture.
+     *
+     * @note Texel layout matches the WebGL renderer's `u_positions` sampler, so it
+     * can be bound directly to webgl renderer.
+     */
+    getPositionTexture(): WebGLTexture;
+    /**
+     * Maps node id to its texel index in the position texture.
+     * @returns The node-id-to-texel-index map.
+     *
+     * @note This is the SolarMerger order (re-derived on add/remove), which differs from
+     * the renderer's insertion order. Consumers rendering from {@link getPositionTexture}
+     * must build their sampling indices from this.
+     */
+    getNodeTexelIndices(): Readonly<Record<Node['id'], number>>;
+    private shouldCheckConvergence;
+    /** Allocates the pixel-pack buffer used for the async convergence readback. */
+    private setupConvergencePbo;
+    /**
+     * Kicks off an async copy of the position texture into the pixel-pack buffer.
+     * Cancels any in-flight readback.
+     */
+    private issueConvergenceReadback;
+    /**
+     * Polls the fence without blocking; if the readback is ready, copies it into
+     * physPositions and clears the fence.
+     * @returns Whether fresh velocity data was consumed this call.
+     */
+    private consumeConvergenceReadback;
+    /** Drops any in-flight readback fence (on stop, reset, or destroy). */
+    private cancelConvergenceReadback;
     /**
      * Returns whether the current layout needs to be updated in the next iteration step.
      * @returns Whether the layout should update in the following step.
@@ -122,7 +171,7 @@ export declare class PhysLayout {
      * Updates the existing nodes of a graph with a given list of updates
      * @param nodeList - The list of updates.
      */
-    updateNodes(nodeList: Node[]): void;
+    updateNodes(nodeList: PartialNode[]): void;
     /**
      * Adds and removes nodes from the graph based on given updates
      * @param fullData - The entire graph object.

package/dist/types/layouts/forcedirectedlayout/physlayout/shaders/multilevel-fragment.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_physData;\nuniform sampler2D u_connections;\nuniform sampler2D u_connectionOffsets;\nuniform sampler2D u_pinnedNodes;\nuniform sampler2D u_sizeTexture;\nuniform float u_baseLength;\nuniform float u_curIteration;\nuniform float u_iterationMultiplier;\nuniform vec2 u_gravityCenter;\nuniform float u_numNodes;\nuniform float u_gravity;\n\nuniform sampler2D u_clusterData;\nuniform sampler2D u_prevForce;\nuniform float u_collisionMultiplier;\n\nout vec4 fragColor;\n\nfloat DAMP = 0.6;\nfloat COOL = 0.99998;\nfloat TIMESTEP = 1.0 / 30.0;\nfloat VELOCITYDECAY = 0.6;\nfloat accLimitLow = 500000.0;\nfloat accLimitHigh = 750000.0;\nfloat accLimitPosHigh = 10000000.0;\n\nconst float denseNodeThreshold = 1000.0;\nconst float MIN_DISTANCE = 0.00000001;\nconst float MAX_DISTANCE = 1000000000.0;\nconst float MAX_ACCELERATION = 50000.0;\n\nvec4 getTextureData(sampler2D tex, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture(tex, vec2(x + 0.5, y + 0.5) / base);\n}\n\nbool isNan(float val) {\n  return (val < 0.0 || 0.0 < val || val == 0.0) ? false : true;\n}\n\nconst float BIG_NUMBER = 999999999999999999.0;\nbool isInf(float val) {\n  return val > BIG_NUMBER || val < -BIG_NUMBER;\n}\n\nvec2 getDelta(vec2 v1, vec2 v2) {\n  vec2 delta = v1 - v2;\n  float dist = length(delta);\n  if (dist < MIN_DISTANCE || isNan(dist)) {\n    return vec2(MIN_DISTANCE, MIN_DISTANCE);\n  }\n  if (dist > MAX_DISTANCE) {\n    vec2 normDelta = delta / dist;\n    return normDelta * MAX_DISTANCE;\n  }\n  return delta;\n}\n\nvec4 getOtherNodePosition(float i) {\n  return getTextureData(u_physData, i, 256.0);\n}\n\nfloat getCombinedNodeSize(float i, float nodeSize) {\n  float otherNodeSize = getTextureData(u_sizeTexture, i, 256.0).r;\n  return nodeSize + otherNodeSize;\n}\n\nvec2 getSpringForce(float curConnection, float numConnections, float springFScale, vec4 myPosition, float i) {\n  float curSpring = getTextureData(u_connections, curConnection + i, 4096.0).r;\n\n  vec4 otherPosition = getTextureData(u_physData, curSpring, 256.0);\n  float otherDataPosition = getTextureData(u_connectionOffsets, curSpring, 256.0).r;\n  float otherNumConnections = getTextureData(u_connections, otherDataPosition, 4096.0).r;\n  float avgDegree = max((otherNumConnections + numConnections * 3.0) / 4.0, 4.0);\n\n  vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n  float dist = length(delta);\n\n  float F = (dist * dist * springFScale) / (u_baseLength * avgDegree);\n  if (u_collisionMultiplier > 0.0) {\n    F *= u_collisionMultiplier;\n  }\n  return (-delta / dist) * F;\n}\n\nvec2 getCollisionForce(float combinedNodeSize, float dist, float fScale, vec2 delta) {\n  float collisionForce = (combinedNodeSize - dist) / (dist);\n  if (u_collisionMultiplier > 0.0) {\n    collisionForce *= u_collisionMultiplier;\n  }\n  return (delta * collisionForce * fScale * combinedNodeSize) / (combinedNodeSize + 1.0);\n}\n\nvec2 getRepulsionForce(float dist, float fScale, vec2 delta) {\n  float F = (u_baseLength * u_baseLength * fScale) / (dist);\n  return (delta / dist) * F * 0.05;\n}\n\nvoid main(void) {\n  float textureSide = 256.0; //#TEXTURE_SIDE#;\n  float index = (gl_FragCoord.x - 0.5) + (gl_FragCoord.y - 0.5) * textureSide;\n\n  if (index >= u_numNodes) {\n    discard;\n  }\n\n  vec4 clusterData = getTextureData(u_clusterData, index, 256.0);\n\n  float clusterIndex = clusterData.x;\n  float clusterStartIndex = clusterData.y;\n  float clusterSize = clusterData.z;\n  float clusterWeight = clusterData.w;\n\n  vec4 myPosition = getTextureData(u_physData, index, 256.0);\n  vec4 previousForce = getTextureData(u_prevForce, clusterIndex, 256.0);\n\n  vec2 acceleration = previousForce.xy;\n\n  float isPinned = getTextureData(u_pinnedNodes, index, 256.0).r;\n  float nodeSize = getTextureData(u_sizeTexture, index, 256.0).r;\n\n  if (isPinned > 0.5) {\n    fragColor = vec4(myPosition.xy, 0.0, 0.0);\n    return;\n  }\n\n  float curConnection = getTextureData(u_connectionOffsets, index, 256.0).r;\n  float numConnections = getTextureData(u_connections, curConnection, 4096.0).r;\n\n  float fScale = 1.0 + sqrt(u_iterationMultiplier);\n  float springFScale = fScale;\n\n  if (numConnections > denseNodeThreshold) {\n    springFScale = sqrt(fScale);\n  }\n\n  float numOfRels = 0.0;\n\n  // Springs\n  for (float i = 1.0; i <= 256.0 * 256.0; i++) {\n    if (numOfRels >= numConnections) {\n      break;\n    }\n    acceleration += getSpringForce(curConnection, numConnections, springFScale, myPosition, i);\n    numOfRels += 1.0;\n  }\n\n  // Repulsion && collision detection\n  if (u_collisionMultiplier > 0.0) {\n    float number_of_collisions = 0.0;\n    for (float i = 0.0; i < 256.0 * 256.0; i++) {\n      if (i >= u_numNodes) {\n        break;\n      }\n\n      if (i == index) {\n        continue;\n      }\n\n      vec4 otherPosition = getOtherNodePosition(i);\n      vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n      float dist = length(delta);\n      float combinedNodeSize = getCombinedNodeSize(i, nodeSize) * 2.0;\n\n      if (dist < combinedNodeSize && number_of_collisions < 40.0) {\n        number_of_collisions++;\n        acceleration += getCollisionForce(combinedNodeSize, dist, fScale, delta);\n      }\n\n      if (i >= clusterStartIndex && i < clusterStartIndex + clusterSize) {\n        acceleration += getRepulsionForce(dist, fScale, delta);\n      }\n    }\n  } else {\n    for (float i = 0.0; i < 256.0 * 256.0; i++) {\n      if (i >= clusterStartIndex + clusterSize || i >= u_numNodes) {\n        break;\n      }\n\n      if (i < clusterStartIndex || i == index) {\n        continue;\n      }\n\n      vec4 otherPosition = getOtherNodePosition(i);\n      vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n      float dist = length(delta);\n      float combinedNodeSize = getCombinedNodeSize(i, nodeSize);\n\n      if (dist < combinedNodeSize) {\n        acceleration += getCollisionForce(combinedNodeSize, dist, fScale, delta);\n      }\n\n      acceleration += getRepulsionForce(dist, fScale, delta);\n    }\n  }\n\n  // Gravity\n  vec2 delta = getDelta(u_gravityCenter, myPosition.xy);\n  float dist = length(delta);\n\n  vec2 grav = (delta / dist) * u_gravity * fScale * (dist / 1000.0);\n  acceleration += grav;\n\n  float accMagnitude = length(acceleration);\n  acceleration *= min(MAX_ACCELERATION, accMagnitude) / accMagnitude;\n\n  float iterationFrictionThreshold = 1000.0;\n\n  if (u_curIteration > iterationFrictionThreshold) {\n    float friction = 1.0 + pow((u_curIteration - iterationFrictionThreshold), 2.0) / 100.0;\n    acceleration *= 1.0 / friction;\n  }\n\n  if (u_curIteration == 0.0) {\n    fragColor = vec4(myPosition.xy, myPosition.zw);\n  } else {\n    float TEMP = max(0.02, pow(COOL, u_curIteration));\n    vec2 prevVelocity = myPosition.zw;\n    vec2 currentPos = myPosition.xy;\n\n    vec2 newPos = currentPos + TEMP * ( DAMP * (prevVelocity) + acceleration * TIMESTEP * TIMESTEP);\n    vec2 newVelocity = newPos - currentPos;\n    fragColor = vec4(newPos, newVelocity);\n  }\n}";
+declare const _default: "#version 300 es\nprecision mediump float;\n\nuniform sampler2D u_physData;\nuniform sampler2D u_connections;\nuniform sampler2D u_connectionOffsets;\nuniform sampler2D u_pinnedNodes;\nuniform sampler2D u_sizeTexture;\nuniform float u_baseLength;\nuniform float u_curIteration;\nuniform float u_iterationMultiplier;\nuniform vec2 u_gravityCenter;\nuniform float u_numNodes;\nuniform float u_gravity;\n\nuniform sampler2D u_clusterData;\nuniform sampler2D u_prevForce;\nuniform float u_collisionMultiplier;\nuniform float u_maxNodeSize;\n\nout vec4 fragColor;\n\nfloat DAMP = 0.6;\nfloat COOL = 0.99998;\nfloat TIMESTEP = 1.0 / 30.0;\nfloat VELOCITYDECAY = 0.6;\nfloat accLimitLow = 500000.0;\nfloat accLimitHigh = 750000.0;\nfloat accLimitPosHigh = 10000000.0;\n\nconst float denseNodeThreshold = 1000.0;\nconst float MIN_DISTANCE = 0.00000001;\nconst float MAX_DISTANCE = 1000000000.0;\nconst float MAX_ACCELERATION = 50000.0;\n\nvec4 getTextureData(sampler2D tex, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture(tex, vec2(x + 0.5, y + 0.5) / base);\n}\n\nbool isNan(float val) {\n  return (val < 0.0 || 0.0 < val || val == 0.0) ? false : true;\n}\n\nconst float BIG_NUMBER = 999999999999999999.0;\nbool isInf(float val) {\n  return val > BIG_NUMBER || val < -BIG_NUMBER;\n}\n\nvec2 getDelta(vec2 v1, vec2 v2) {\n  vec2 delta = v1 - v2;\n  float dist = length(delta);\n  if (dist < MIN_DISTANCE || isNan(dist)) {\n    return vec2(MIN_DISTANCE, MIN_DISTANCE);\n  }\n  if (dist > MAX_DISTANCE) {\n    vec2 normDelta = delta / dist;\n    return normDelta * MAX_DISTANCE;\n  }\n  return delta;\n}\n\nvec4 getOtherNodePosition(float i) {\n  return getTextureData(u_physData, i, 256.0);\n}\n\nfloat getCombinedNodeSize(float i, float nodeSize) {\n  float otherNodeSize = getTextureData(u_sizeTexture, i, 256.0).r;\n  return nodeSize + otherNodeSize;\n}\n\nvec2 getSpringForce(float curConnection, float numConnections, float springFScale, vec4 myPosition, float i) {\n  float curSpring = getTextureData(u_connections, curConnection + i, 4096.0).r;\n\n  vec4 otherPosition = getTextureData(u_physData, curSpring, 256.0);\n  float otherDataPosition = getTextureData(u_connectionOffsets, curSpring, 256.0).r;\n  float otherNumConnections = getTextureData(u_connections, otherDataPosition, 4096.0).r;\n  float avgDegree = max((otherNumConnections + numConnections * 3.0) / 4.0, 4.0);\n\n  vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n  float dist = length(delta);\n\n  float F = (dist * dist * springFScale) / (u_baseLength * avgDegree);\n  if (u_collisionMultiplier > 0.0) {\n    F *= u_collisionMultiplier;\n  }\n  return (-delta / dist) * F;\n}\n\nvec2 getCollisionForce(float combinedNodeSize, float dist, float fScale, vec2 delta) {\n  float collisionForce = (combinedNodeSize - dist) / (dist);\n  if (u_collisionMultiplier > 0.0) {\n    collisionForce *= u_collisionMultiplier;\n  }\n  return (delta * collisionForce * fScale * combinedNodeSize) / (combinedNodeSize + 1.0);\n}\n\nvec2 getRepulsionForce(float dist, float fScale, vec2 delta) {\n  float F = (u_baseLength * u_baseLength * fScale) / (dist);\n  return (delta / dist) * F * 0.05;\n}\n\nvoid main(void) {\n  float textureSide = 256.0; //#TEXTURE_SIDE#;\n  float index = (gl_FragCoord.x - 0.5) + (gl_FragCoord.y - 0.5) * textureSide;\n\n  if (index >= u_numNodes) {\n    discard;\n  }\n\n  vec4 clusterData = getTextureData(u_clusterData, index, 256.0);\n\n  float clusterIndex = clusterData.x;\n  float clusterStartIndex = clusterData.y;\n  float clusterSize = clusterData.z;\n\n  vec4 myPosition = getTextureData(u_physData, index, 256.0);\n  vec4 previousForce = getTextureData(u_prevForce, clusterIndex, 256.0);\n\n  vec2 acceleration = previousForce.xy;\n\n  float isPinned = getTextureData(u_pinnedNodes, index, 256.0).r;\n  float nodeSize = getTextureData(u_sizeTexture, index, 256.0).r;\n\n  if (isPinned > 0.5) {\n    fragColor = vec4(myPosition.xy, 0.0, 0.0);\n    return;\n  }\n\n  float curConnection = getTextureData(u_connectionOffsets, index, 256.0).r;\n  float numConnections = getTextureData(u_connections, curConnection, 4096.0).r;\n\n  float fScale = 1.0 + sqrt(u_iterationMultiplier);\n  float springFScale = fScale;\n\n  if (numConnections > denseNodeThreshold) {\n    springFScale = sqrt(fScale);\n  }\n\n  float numOfRels = 0.0;\n\n  // Springs\n  for (float i = 1.0; i <= 256.0 * 256.0; i++) {\n    if (numOfRels >= numConnections) {\n      break;\n    }\n    acceleration += getSpringForce(curConnection, numConnections, springFScale, myPosition, i);\n    numOfRels += 1.0;\n  }\n\n  // Repulsion && collision detection\n  if (u_collisionMultiplier > 0.0) {\n    float number_of_collisions = 0.0;\n    for (float i = 0.0; i < 256.0 * 256.0; i++) {\n      if (i >= u_numNodes) {\n        break;\n      }\n\n      if (i == index) {\n        continue;\n      }\n\n      vec4 otherPosition = getOtherNodePosition(i);\n      vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n      float dist = length(delta);\n\n      if (number_of_collisions < 40.0 && dist < (nodeSize + u_maxNodeSize) * 2.0) {\n        float combinedNodeSize = getCombinedNodeSize(i, nodeSize) * 2.0;\n        if (dist < combinedNodeSize) {\n          number_of_collisions++;\n          acceleration += getCollisionForce(combinedNodeSize, dist, fScale, delta);\n        }\n      }\n\n      if (i >= clusterStartIndex && i < clusterStartIndex + clusterSize) {\n        acceleration += getRepulsionForce(dist, fScale, delta);\n      }\n    }\n  } else {\n    for (float i = 0.0; i < 256.0 * 256.0; i++) {\n      if (i >= clusterStartIndex + clusterSize || i >= u_numNodes) {\n        break;\n      }\n\n      if (i < clusterStartIndex || i == index) {\n        continue;\n      }\n\n      vec4 otherPosition = getOtherNodePosition(i);\n      vec2 delta = getDelta(myPosition.xy, otherPosition.xy);\n      float dist = length(delta);\n      float combinedNodeSize = getCombinedNodeSize(i, nodeSize);\n\n      if (dist < combinedNodeSize) {\n        acceleration += getCollisionForce(combinedNodeSize, dist, fScale, delta);\n      }\n\n      acceleration += getRepulsionForce(dist, fScale, delta);\n    }\n  }\n\n  // Gravity\n  vec2 delta = getDelta(u_gravityCenter, myPosition.xy);\n  float dist = length(delta);\n\n  vec2 grav = (delta / dist) * u_gravity * fScale * (dist / 1000.0);\n  acceleration += grav;\n\n  float accMagnitude = length(acceleration);\n  acceleration *= min(MAX_ACCELERATION, accMagnitude) / accMagnitude;\n\n  float iterationFrictionThreshold = 1000.0;\n\n  if (u_curIteration > iterationFrictionThreshold) {\n    float friction = 1.0 + pow((u_curIteration - iterationFrictionThreshold), 2.0) / 100.0;\n    acceleration *= 1.0 / friction;\n  }\n\n  if (u_curIteration == 0.0) {\n    fragColor = vec4(myPosition.xy, myPosition.zw);\n  } else {\n    float TEMP = max(0.02, pow(COOL, u_curIteration));\n    vec2 prevVelocity = myPosition.zw;\n    vec2 currentPos = myPosition.xy;\n\n    vec2 newPos = currentPos + TEMP * ( DAMP * (prevVelocity) + acceleration * TIMESTEP * TIMESTEP);\n    vec2 newVelocity = newPos - currentPos;\n    fragColor = vec4(newPos, newVelocity);\n  }\n}";
 export default _default;

package/dist/types/layouts/forcedirectedlayout/physlayout/shaders/multilevel-repulsive-fragment.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "#version 300 es\nprecision mediump float;\nuniform sampler2D u_physData;\nuniform sampler2D u_clusterData;\nuniform sampler2D u_finestIndexes;\nuniform sampler2D u_prevForce;\n\nuniform float u_baseLength;\nuniform float u_numNodes;\nuniform float u_iterationMultiplier;\nuniform float u_isTopLevel;\n\nout vec4 fragColor;\n\nfloat PI = 3.1415926535897932384626433832795;\nfloat TIMESTEP = 1.0 / 30.0;\nfloat VELOCITYDECAY = 1.0;\n\nvec4 getTextureData(sampler2D tex, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture(tex, vec2(x + 0.5, y + 0.5) / base);\n}\n\nfloat getSquaredLogClusterWeight(float value) {\n  return pow(log(value), 2.0);\n}\n\nvoid main(void) {\n  float index = (gl_FragCoord.x - 0.5) + (gl_FragCoord.y - 0.5) * 256.0;\n\n  if (index >= u_numNodes) {\n    discard;\n  }\n\n  vec4 clusterData = getTextureData(u_clusterData, index, 256.0);\n\n  float clusterIndex = clusterData.x;\n  float clusterStartIndex = clusterData.y;\n  float clusterSize = clusterData.z;\n  float clusterArea = pow(clusterSize + u_baseLength * 2.0, 2.0);\n\n  float finestIndex = getTextureData(u_finestIndexes, index, 256.0).r;\n  vec4 myPosition = getTextureData(u_physData, finestIndex, 256.0);\n  vec4 previousForce = getTextureData(u_prevForce, clusterIndex, 256.0);\n  float fScale = 1.0 + sqrt(u_iterationMultiplier);\n\n  vec2 acceleration = previousForce.xy;\n\n  // Repulsion & Collision Detection\n  for (float i = 0.0; i < 256.0 * 256.0; i++) {\n    if (i >= clusterStartIndex + clusterSize || i >= u_numNodes) {\n      break;\n    }\n    if (i < clusterStartIndex || i == index) {\n      continue;\n    }\n\n    vec4 otherClusterData = getTextureData(u_clusterData, i, 256.0);\n    float otherClusterWeight = getSquaredLogClusterWeight(otherClusterData.w);\n\n    float otherFinestIndex = getTextureData(u_finestIndexes, i, 256.0).r;\n    vec4 otherPosition = getTextureData(u_physData, otherFinestIndex, 256.0);\n\n    vec2 delta = myPosition.xy - otherPosition.xy;\n    float dist = max(length(delta), 0.0000001);\n    float maxDist = 25.0;\n    float repulsionForceScale = 0.1;\n\n    float F = (clusterArea * fScale) / (dist * dist);\n\n    if (u_isTopLevel == 1.0) {\n      repulsionForceScale = 0.2;\n    }\n\n    acceleration += ((delta / sqrt(dist)) * F) * repulsionForceScale * otherClusterWeight;\n\n    if (dist < maxDist) {\n      float collide = (maxDist - dist) / (dist * dist);\n      acceleration += delta * collide * fScale * maxDist / (maxDist + 1.0);\n    }\n  }\n\n  fragColor = vec4(acceleration, vec2(finestIndex, 0));\n}";
+declare const _default: "#version 300 es\nprecision mediump float;\nuniform sampler2D u_physData;\nuniform sampler2D u_clusterData;\nuniform sampler2D u_finestIndexes;\nuniform sampler2D u_prevForce;\n\nuniform float u_baseLength;\nuniform float u_numNodes;\nuniform float u_iterationMultiplier;\nuniform float u_isTopLevel;\n\nout vec4 fragColor;\n\nfloat PI = 3.1415926535897932384626433832795;\nfloat TIMESTEP = 1.0 / 30.0;\nfloat VELOCITYDECAY = 1.0;\n\nvec4 getTextureData(sampler2D tex, float index, float base) {\n  float x = mod(index, base);\n  float y = (index - x) / base;\n  return texture(tex, vec2(x + 0.5, y + 0.5) / base);\n}\n\nfloat getAdjustedClusterWeight(float clusterWeight) {\n  return (clusterWeight * clusterWeight) / (clusterWeight + 1.0);\n}\n\nvoid main(void) {\n  float index = (gl_FragCoord.x - 0.5) + (gl_FragCoord.y - 0.5) * 256.0;\n\n  if (index >= u_numNodes) {\n    discard;\n  }\n\n  vec4 clusterData = getTextureData(u_clusterData, index, 256.0);\n\n  float clusterIndex = clusterData.x;\n  float clusterStartIndex = clusterData.y;\n  float clusterSize = clusterData.z;\n  float clusterArea = pow(clusterSize + u_baseLength * 2.0, 2.0);\n\n  float finestIndex = getTextureData(u_finestIndexes, index, 256.0).r;\n  vec4 myPosition = getTextureData(u_physData, finestIndex, 256.0);\n  vec4 previousForce = getTextureData(u_prevForce, clusterIndex, 256.0);\n  float fScale = 1.0 + sqrt(u_iterationMultiplier);\n\n  vec2 acceleration = previousForce.xy;\n\n  // Repulsion & Collision Detection\n  for (float i = 0.0; i < 256.0 * 256.0; i++) {\n    if (i >= clusterStartIndex + clusterSize || i >= u_numNodes) {\n      break;\n    }\n    if (i < clusterStartIndex || i == index) {\n      continue;\n    }\n\n    vec4 otherClusterData = getTextureData(u_clusterData, i, 256.0);\n    float otherClusterWeight = getAdjustedClusterWeight(otherClusterData.w);\n\n    float otherFinestIndex = getTextureData(u_finestIndexes, i, 256.0).r;\n    vec4 otherPosition = getTextureData(u_physData, otherFinestIndex, 256.0);\n\n    vec2 delta = myPosition.xy - otherPosition.xy;\n    float dist = max(length(delta), 0.0000001);\n    float maxDist = 25.0;\n    float repulsionForceScale = 0.1;\n\n    float F = (clusterArea * fScale) / (dist * dist);\n\n    if (u_isTopLevel == 1.0) {\n      repulsionForceScale = 0.2;\n    }\n\n    acceleration += ((delta / sqrt(dist)) * F) * repulsionForceScale * otherClusterWeight;\n\n    if (dist < maxDist) {\n      float collide = (maxDist - dist) / (dist * dist);\n      acceleration += delta * collide * fScale * maxDist / (maxDist + 1.0);\n    }\n  }\n\n  fragColor = vec4(acceleration, vec2(finestIndex, 0));\n}";
 export default _default;

package/dist/types/layouts/forcedirectedlayout/physlayout/solarmerger/SolarMerger.d.ts

@@ -1,5 +1,11 @@
 import type { Node, Relationship } from '../../../../types/graph-element';
 import type { CoarsenedGraph, SolarRelationship } from './types';
+/**
+ * Coarsens a graph into a hierarchy of "solar systems", following the sun/planet/moon partitioning scheme from
+ * Hachul and Jünger, "Drawing Large Graphs with a Potential-Field-Based Multilevel Algorithm".
+ *
+ * @see {@link https://kups.ub.uni-koeln.de/1409/ Drawing Large Graphs with a Potential-Field-Based Multilevel Algorithm}
+ */
 export default class SolarMerger {
     graph: {
         nodes: Node[];
@@ -14,8 +20,59 @@ export default class SolarMerger {
         nodes: Node[];
         rels: Relationship[];
     }, nodeIdToIndex: Record<string, number>);
+    /**
+     * Converts the input graph into the integer-indexed adjacency-list representation {@link SolarMerger.coarsen}
+     * operates on.
+     *
+     * @param inputGraph - The graph to convert.
+     * @param nodeIdToIndex - Maps each node's original id to its integer index.
+     */
     private constructGraphObjects;
+    /**
+     * Repeatedly coarsens the graph, one solar-system level at a time, until it has at most `targetSize` nodes or
+     * cannot be coarsened further. Each level's result is recorded in {@link SolarMerger.subGraphs}.
+     *
+     * @param targetSize - The node count to coarsen down to.
+     * @returns The coarsest graph reached.
+     */
     coarsenTo(targetSize: number): CoarsenedGraph;
+    /**
+     * Repeatedly coarsens the graph by exactly `levelToCoarsenBy` solar-system levels, regardless of the resulting
+     * node count. Each level's result is recorded in {@link SolarMerger.subGraphs}.
+     *
+     * @param levelToCoarsenBy - The number of levels to coarsen by.
+     * @returns The coarsest graph reached.
+     */
     coarsenBy(levelToCoarsenBy: number): CoarsenedGraph;
+    /**
+     * @param relationships - The graph's adjacency list, indexed by node id.
+     * @returns The degree a node must exceed to be treated as a hub by {@link SolarMerger.isHub}.
+     */
+    private getHubDegreeThreshold;
+    /**
+     * Whether a node's degree is enough of an outlier that it must become its own sun rather than being absorbed as
+     * a planet/moon of another sun.
+     *
+     * @param index - The node id to check.
+     * @param relationships - The graph's adjacency list, indexed by node id.
+     * @param hubDegreeThreshold - The threshold from {@link SolarMerger.getHubDegreeThreshold}.
+     * @see {@link HubDegreeMultiplier}
+     */
+    private isHub;
+    /**
+     * Partitions `graph` into one level of solar systems and collapses each into a single node, producing the next
+     * coarser graph.
+     *
+     * Follows the three-step solar-system construction from Hachul and Jünger, "Drawing Large Graphs with a
+     * Potential-Field-Based Multilevel Algorithm" (create suns, label their neighbors as planets, assign
+     * remaining nodes as moons of their nearest planet).
+     *
+     * @param graph - The graph to coarsen by one level.
+     * @param firstIteration - Whether `graph` is the original, uncoarsened input graph.
+     * @returns The collapsed graph (`output`), the input graph with nodes reordered by solar system (`sortedInput`),
+     * and a map from the input graph's node ids to their position in `sortedInput` (`nodeSortMap`).
+     * @see {@link https://kups.ub.uni-koeln.de/1409/ Drawing Large Graphs with a Potential-Field-Based Multilevel Algorithm}
+     *
+     */
     private coarsen;
 }

package/dist/types/layouts/freeLayout/FreeLayout.d.ts

@@ -1,5 +1,5 @@
 import type { NvlState } from '../../modules/state/types';
-import type { Node } from '../../types/graph-element';
+import type { Node, PartialNode } from '../../types/graph-element';
 import type { Point } from '../../utils/geometry';
 export declare class FreeLayout {
     private state;
@@ -10,9 +10,7 @@ export declare class FreeLayout {
         state: NvlState;
     });
     setOptions(): any;
-    updateNodes(positionList: (Point & {
-        id: string;
-    })[]): void;
+    updateNodes(positionList: PartialNode[]): void;
     update(refreshPositions?: boolean): void;
     layout(nodes: Node[], nodeIds: Record<string, Node>, idToPosition: Record<string, Node>): void;
     setNodePositions(p: Record<string, Point>): void;

package/dist/types/layouts/gridLayout/GridLayout.d.ts

@@ -1,5 +1,5 @@
 import type { NvlState } from '../../modules/state/types';
-import type { Node } from '../../types/graph-element';
+import type { Node, PartialNode } from '../../types/graph-element';
 import type { Point } from '../../utils/geometry';
 export declare class GridLayout {
     state: NvlState;
@@ -10,11 +10,7 @@ export declare class GridLayout {
         state: NvlState;
     });
     setOptions(): void;
-    updateNodes(positionList: {
-        id: string;
-        x: number;
-        y: number;
-    }[]): void;
+    updateNodes(positionList: PartialNode[]): void;
     update(refreshPositions?: boolean): void;
     layout(mobxNodes: any): void;
     setNodePositions(idToPosition: Record<string, Node & Point>): void;

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

@@ -1,4 +1,4 @@
-import { type Node, type PartialNode, type PartialRelationship, type Relationship } from '../types/graph-element';
+import { type Node, type NodeWithClientPosition, type PartialNode, type PartialRelationship, type Relationship } from '../types/graph-element';
 import '../types/nvl-window-functions';
 import type { Point } from '../utils/geometry';
 import type { ExternalCallbacks } from './ExternalCallbackHandler';
@@ -61,15 +61,39 @@ export default class NvlController {
     private layoutComputingCallback;
     private currentLayoutType;
     private descriptionElement;
+    /** True when a minimap container was provided; disables the GPU-texture fast path (separate GL context). */
+    private readonly hasMinimap;
     constructor(state: NvlState, frame: HTMLElement, options: NvlOptions);
     private onWebGLContextLost;
     private fpsToFrameBudgetMs;
     private getLayoutNeedsToUpdate;
     private isWithinBudget;
+    /**
+     * Add elapsed frame time to the layout-step accumulator, capped at `layoutTimeLimit`.
+     * Prevents a slow frame (e.g. blocked GPU readback) from inflating catch-up debt and
+     * scheduling ever more work in a feedback loop; the layout falls behind gracefully instead.
+     */
+    private accumulateLayoutElapsedTime;
+    /**
+     * Whether the GPU force-directed layout is active.
+     * @returns `true` when PhysLayout is the current layout.
+     */
+    private usesGpuSimulation;
+    /**
+     * Whether the GPU-texture fast path can be taken this frame.
+     * Requires the WebGL renderer, GPU layout active, no minimap, and no CPU-position consumers
+     * (layout-step callback, HTML overlays).
+     * @returns `true` when rendering directly from the GPU position texture is safe.
+     */
+    private canRenderFromGpuTexture;
+    /** Syncs idToPosition from the GPU layout on demand; no-op for CPU layouts. */
+    syncPositionsFromLayout(): void;
     private updateMinimapZoom;
     private startMainLoop;
+    private renderNodeHtmlOverlays;
+    private renderRelationshipHtmlOverlays;
     updateHtmlOverlay(): void;
-    dumpNodes(): Node[];
+    dumpNodes(): NodeWithClientPosition[];
     dumpRelationships(): Relationship[];
     /**
      * Map a relative Canvas space to the DOM position
@@ -122,6 +146,8 @@ export default class NvlController {
     private getDataUrlForCanvas;
     private initiateFileDownload;
     private updateLayoutAndPositions;
+    private getAndUpdatePositions;
+    private getLayoutPositions;
     saveToFile(options: SaveToFileOptions): void;
     private createSvgString;
     saveToSvg(options?: SaveToFileOptions): Promise<void>;

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

@@ -8,6 +8,7 @@ export interface DataSet<T> {
     idToPosition: Record<string, Node & Point>;
     idToHtmlOverlay?: Record<string, HTMLElement>;
     version: number;
+    maxDimension: number;
     addChannel: (this: DataSet<T>, channelName: string) => void;
     removeChannel: (this: DataSet<T>, channelName: string) => void;
     clearChannel: (this: DataSet<T>, channelName: string) => void;
@@ -29,7 +30,8 @@ export interface Channel<T> {
     updates: Record<string, T>;
     removes: Record<string, T>;
 }
-export declare const getHtmlProperty: (item: Partial<Node | Relationship>) => HTMLElement | undefined;
+export declare const getHtmlKey: (item: Node | Relationship) => "html" | "captionHtml";
+export declare const getHtmlProperty: (item: Node | Relationship) => HTMLElement | undefined;
 /**
  * Creates an empty dataset in which a graph be stored and updated using mobx actions.
  * @returns A new and empty {@link DataSet}.

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

@@ -42,14 +42,6 @@ export interface ForceDirectedOptions {
      * require the Intel GPU shader workaround. This option will be removed in a future release.
      */
     intelWorkaround?: 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
-     */
-    enableCytoscape?: boolean;
     /**
      * How initial node positions are seeded before the physics simulation runs.
      * @defaultValue 'box'
@@ -237,22 +229,21 @@ export interface NvlOptions {
         minimapViewportBoxColor?: string;
     };
     /**
-     * Target minimum presentation rate (fps) while layout is active.
-     * Rendering will not drop below this rate at the cost of stabilization speed.
+     * 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 Must be within range of 1 and 120.
+     * @note Will be capped between 1 and 120.
      */
     minFps?: number;
     /**
-     * Target maximum presentation rate (fps) while layout is active.
-     * Rendering will not go above with rate. Any additional
-     * computation available is used to speed up layout stabilization.
+     * 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 Must be within range of 1 and 120.
+     * @note Will be capped between 1 and 120.
      */
     maxFps?: number;
     /**

package/dist/types/renderers/domrenderer/canvasrenderer/arrowDrawing.d.ts

@@ -18,20 +18,6 @@ export declare const calculateLabelDimensions: (fullCaption: string, measureWidt
     label: string;
     width: number;
 };
-/**
- * Calculate label transform including rotation and flip adjustments.
- *
- * @param angle - The base rotation angle in radians
- * @param fontSize - The font size in pixels (including pixel ratio scaling)
- * @param flip - Whether to flip the label (applies additional rotation)
- * @param point - The base point (used to calculate offset in flip case)
- * @returns object with final position and angle
- */
-export declare const calculateLabelTransform: (angle: number, fontSize: number, flip: boolean, point: Point) => {
-    finalX: number;
-    finalY: number;
-    finalAngle: number;
-};
 /**
  * Calculate vertical alignment offset for label based on caption alignment.
  *
@@ -55,7 +41,7 @@ export declare const calculateLabelHeightAlign: (captionAlign: string, fontSize:
  * @param flip - Whether the label is flipped
  * @returns object with position, rotation, width, and height for hit detection
  */
-export declare const calculateLabelGeometry: (point: Point, angle: number, maxWidth: number, fontSize: number, heightAlign: number, padding: number, pixelRatio: number, flip: boolean) => {
+export declare const calculateLabelGeometry: (point: Point, angle: number, maxWidth: number, fontSize: number, heightAlign: number, padding: number, pixelRatio: number) => {
     position: {
         x: number;
         y: number;
@@ -164,5 +150,5 @@ export declare const drawLoop: (ctx: CanvasRenderingContext2D, fromPoint: Point,
  * @param fontColor - The font color to use
  * @param flip - Whether to flip the label orientation (default false)
  */
-export declare const drawLabel: (ctx: CanvasRenderingContext2D, point: Point, angle: number, maxWidth: number, rel: Relationship, bundle: ArrowBundle, disabledItemStyles: DisabledItemStyles, fontColor: string, flip?: boolean) => void;
+export declare const drawLabel: (ctx: CanvasRenderingContext2D, point: Point, angle: number, maxWidth: number, rel: Relationship, bundle: ArrowBundle, disabledItemStyles: DisabledItemStyles, fontColor: string) => void;
 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/arrows/arrows.d.ts

@@ -44,12 +44,8 @@ export declare const getSelfArrowControlPoints: (rel: Relationship, node: Node,
     };
     nodeGap: number;
 };
-/**
- * Calculates position, angle and flip for a self-referencing relationship label.
- * Used by both Canvas and SVG renderers to ensure consistent positioning.
- * This function handles all the math internally including headAngle and headSelectedAdjustment calculations.
- */
-export declare const getSelfArrowLabelPosition: (apexPoint: Point, angle: number, endPoint: Point, control2Point: Point, isSelected: boolean, selectionRings: BorderStyle["rings"], relWidth?: number) => {
+/** Calculates anchor position and readable rotation for a self-referencing relationship label. */
+export declare const getSelfArrowLabelPosition: (apexPoint: Point, angle: number, endPoint: Point, control2Point: Point, isSelected: boolean, selectionRings: BorderStyle["rings"], relWidth?: number, captionSize?: number) => {
     x: number;
     y: number;
     angle: number;
@@ -173,3 +169,5 @@ export declare const getOverlayIconAlignment: (position: [number, number], width
     widthAlign: number;
     heightAlign: number;
 };
+/** Vertical offset for a self-loop caption; `top`/`bottom` mean outside/inside the loop. */
+export declare const getSelfLoopHeightAlign: (captionAlign: string, fontSize: number, lineWidth: number, padding: number, flip: 1 | -1) => number;

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,24 @@ 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 renders from its own CPU-uploaded texture and
+     * is left in insertion order.
+     */
+    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 +70,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 {};