@fusefactory/fuse-three-forcegraph 1.0.5 → 1.0.6

package/dist/index.d.mts

@@ -1,10 +1,48 @@
 import CameraControls from "camera-controls";
 import * as THREE from "three";
 
+//#region core/Clock.d.ts
+/**
+ * Clock - Unified timing for the force graph package
+ */
+declare class Clock {
+  private previousTime;
+  private elapsedTime;
+  private deltaTime;
+  private isRunning;
+  private maxDeltaTime;
+  constructor();
+  /**
+       * Start the clock
+       */
+  start(): void;
+  /**
+       * Stop the clock
+       */
+  stop(): void;
+  /**
+       * Update the clock - call once per frame
+       * @returns delta time in seconds
+       */
+  update(): number;
+  /**
+       * Get delta time in seconds
+       */
+  getDeltaTime(): number;
+  /**
+       * Get total elapsed time in seconds
+       */
+  getElapsedTime(): number;
+  /**
+       * Check if clock is running
+       */
+  getIsRunning(): boolean;
+}
+//#endregion
 //#region types/iCameraMode.d.ts
 declare enum CameraMode {
   Orbit = "orbit",
-  Map = "map"
+  Map = "map",
 }
 //#endregion
 //#region rendering/CameraController.d.ts
@@ -42,70 +80,70 @@ declare class CameraController {
   constructor(domelement: HTMLElement, config?: CameraConfig);
   private setupDefaultControls;
   /**
-   * Set camera control mode
-   */
+       * Set camera control mode
+       */
   setMode(mode: CameraMode): void;
   /**
-   * Set camera boundary
-   */
+       * Set camera boundary
+       */
   setBoundary(box: THREE.Box3): void;
   /**
-   * Update camera controls (should be called in render loop)
-   * Only autorotate if enabled and user is inactive
-   */
+       * Update camera controls (should be called in render loop)
+       * Only autorotate if enabled and user is inactive
+       */
   update(delta: number): boolean;
   /**
-   * Set autorotate enabled/disabled
-   */
+       * Set autorotate enabled/disabled
+       */
   setAutorotate(enabled: boolean, speed?: number): void;
   /**
-   * Set user activity state
-   */
+       * Set user activity state
+       */
   setUserIsActive(isActive: boolean): void;
   /**
-   * Configure camera controls
-   */
+       * Configure camera controls
+       */
   configureControls(config: ControlsConfig): void;
   /**
-   * Resize camera when window resizes
-   */
+       * Resize camera when window resizes
+       */
   resize(width: number, height: number): void;
   /**
-   * Animate camera to look at a specific target from a specific position
-   */
+       * Animate camera to look at a specific target from a specific position
+       */
   setLookAt(position: THREE.Vector3, target: THREE.Vector3, enableTransition?: boolean): Promise<void>;
   /**
-   * Reset camera to default position
-   */
-  reset(enableTransition?: boolean): Promise<void>;
+       * Reset camera to default position
+       */
+  reset(position?: THREE.Vector3, target?: THREE.Vector3, enableTransition?: boolean): Promise<void>;
   /**
-   * Enable/disable controls
-   */
+       * Enable/disable controls
+       */
   setEnabled(enabled: boolean): void;
   /**
-   * Get current camera target (look-at point)
-   */
+       * Get current camera target (look-at point)
+       */
   getTarget(out?: THREE.Vector3): THREE.Vector3;
   /**
-   * Dispose camera manager and clean up
-   */
+       * Dispose camera manager and clean up
+       */
   dispose(): void;
   /**
-   * Clear camera bounds (remove boundary restrictions)
-   */
+       * Clear camera bounds (remove boundary restrictions)
+       */
   clearBounds(): void;
   /**
-   * Get current scene bounds
-   */
+       * Get current scene bounds
+       */
   getSceneBounds(): THREE.Box3 | null;
   /**
-   * Update scene bounds used by the camera manager.
-   * Stores the bounds for future use (e.g. constraining controls).
-   */
+       * Update scene bounds used by the camera manager.
+       * Stores the bounds for future use (e.g. constraining controls).
+       */
   updateBounds(box: THREE.Box3): void;
   /**
-   * Unified configuration method
-   */
+       * Unified configuration method
+       */
   setOptions(options: {
     controls?: ControlsConfig;
     autoRotate?: boolean;
@@ -113,6 +151,9 @@ declare class CameraController {
   }): void;
 }
 //#endregion
+//#region rendering/PostProcessing.d.ts
+type AntialiasingMode = 'msaa' | 'smaa' | 'fxaa' | 'none';
+//#endregion
 //#region types/iGraphLink.d.ts
 interface GraphLink {
   source: string;
@@ -142,7 +183,7 @@ declare enum NodeState {
   // = 1 rendered, not influencing simulation,
   Fixed = 2,
   // = 2 rendered, influencing simulation, but not moving
-  Active = 3
+  Active = 3,
 }
 //#endregion
 //#region types/iGraphData.d.ts
@@ -242,85 +283,29 @@ interface TooltipConfig {
   cursorHandler?: CursorHandler;
 }
 //#endregion
-//#region rendering/PostProcessing.d.ts
-type AntialiasingMode = 'msaa' | 'smaa' | 'fxaa' | 'none';
-//#endregion
-//#region core/EventEmitter.d.ts
-declare class EventEmitter {
-  private listeners;
-  protected listenerCount(event: string): number;
-  on(event: string, listener: Function): () => void;
-  off(event: string, listener: Function): void;
-  emit(event: string, ...args: any[]): void;
-}
-//#endregion
-//#region controls/InputProcessor.d.ts
+//#region textures/PickBuffer.d.ts
 /**
- * Manages pointer/mouse input and emits interaction events
- * Uses GPU picking for efficient node detection
+ * Manages GPU picking buffer for mouse interaction
+ * Separate from simulation buffers as it has different lifecycle
  */
-declare class InputProcessor extends EventEmitter {
-  private pickFn;
-  private canvas;
-  private viewport;
-  private readonly CLICK_THRESHOLD;
-  private readonly HOVER_TO_POP_MS;
-  private pointer;
-  private canvasPointer;
-  private isPointerDown;
-  private isDragging;
-  private mouseDownTime;
-  private draggedIndex;
-  private currentHoverIndex;
-  private hoverStartTime;
-  private hoverProgress;
-  private hasPopped;
-  private isTouch;
-  private readonly TOUCH_MOVE_THRESHOLD;
-  private pointerDownX;
-  private pointerDownY;
-  private lastClientX;
-  private lastClientY;
-  constructor(pickFn: (x: number, y: number) => number, // Injected
-  canvas: HTMLCanvasElement, viewport: {
-    width: number;
-    height: number;
-  });
-  private setupEventListeners;
-  private handlePointerMove;
-  private handlePointerDown;
-  private handlePointerUp;
-  private handlePointerLeave;
-  private updateHover;
-  /**
-   * Update hover state even when pointer is stationary
-   * Called from render loop
-   */
-  update(): void;
-  private updatePointer;
+declare class PickBuffer {
+  private renderer;
+  private pickTarget;
+  constructor(renderer: THREE.WebGLRenderer);
   /**
-   * Update viewport dimensions on resize
-   */
+       * Ensure pick buffer matches viewport size
+       */
   resize(width: number, height: number): void;
-  dispose(): void;
-}
-//#endregion
-//#region controls/handlers/HoverHandler.d.ts
-declare class HoverHandler extends EventEmitter {
-  private getNodeByIndex;
-  constructor(getNodeByIndex: (index: number) => GraphNode | null);
-  private handleHoverStart;
-  private handleHover;
-  private handlePop;
-  private handleHoverEnd;
-  dispose(): void;
-}
-//#endregion
-//#region controls/handlers/ClickHandler.d.ts
-declare class ClickHandler extends EventEmitter {
-  private getNodeByIndex;
-  constructor(getNodeByIndex: (index: number) => GraphNode | null);
-  private handleClick;
+  private createPickBuffer;
+  /**
+       * Read node ID at pixel coordinates
+       */
+  readIdAt(x: number, y: number): number;
+  /**
+       * Render scene to pick buffer
+       */
+  render(scene: THREE.Scene, camera: THREE.Camera): void;
+  getTarget(): THREE.WebGLRenderTarget | null;
   dispose(): void;
 }
 //#endregion
@@ -338,51 +323,51 @@ declare class SimulationBuffers {
   private isInitialized;
   constructor(renderer: THREE.WebGLRenderer);
   /**
-   * Check if buffers are initialized
-   */
+       * Check if buffers are initialized
+       */
   isReady(): boolean;
   /**
-   * Initialize buffers with point count and initial positions
-   */
+       * Initialize buffers with point count and initial positions
+       */
   init(pointsCount: number, initialPositions?: Float32Array): void;
   /**
-   * Resize buffers (re-initializes with new size)
-   */
+       * Resize buffers (re-initializes with new size)
+       */
   resize(pointsCount: number, preserveData?: boolean): void;
   private calculateTextureSize;
   private createDynamicBuffer;
   /**
-   * Initialize position buffers from initial data
-   */
+       * Initialize position buffers from initial data
+       */
   setInitialPositions(positionArray: Float32Array): void;
   /**
-   * Update current and previous positions, but keep original positions intact
-   */
+       * Update current and previous positions, but keep original positions intact
+       */
   updateCurrentPositions(positionArray: Float32Array): void;
   /**
-   * Set original positions (anchors) separately from current positions
-   */
+       * Set original positions (anchors) separately from current positions
+       */
   setOriginalPositions(positionArray: Float32Array): void;
   /**
-   * Initialize velocity buffers (usually to zero)
-   */
+       * Initialize velocity buffers (usually to zero)
+       */
   initVelocities(): void;
   /**
-   * Swap position buffers (ping-pong)
-   */
+       * Swap position buffers (ping-pong)
+       */
   swapPositions(): void;
   /**
-   * Swap velocity buffers (ping-pong)
-   */
+       * Swap velocity buffers (ping-pong)
+       */
   swapVelocities(): void;
   /**
-   * Reset positions to original state
-   */
+       * Reset positions to original state
+       */
   resetPositions(): void;
   /**
-   * Read current positions back from GPU (expensive operation)
-   * Returns RGBA float array (x, y, z, state)
-   */
+       * Read current positions back from GPU (expensive operation)
+       * Returns RGBA float array (x, y, z, state)
+       */
   readPositions(): Float32Array;
   getCurrentPositionTarget(): THREE.WebGLRenderTarget | null;
   getPreviousPositionTarget(): THREE.WebGLRenderTarget | null;
@@ -401,619 +386,569 @@ declare class SimulationBuffers {
   dispose(): void;
 }
 //#endregion
-//#region types/iAttractor.d.ts
-/**
- * Simple 3D vector type
- */
-interface Vec3 {
-  x: number;
-  y: number;
-  z: number;
-}
-/**
- * Attractor - A point in space that attracts nodes of specific groups
- */
-interface Attractor {
-  /** Unique identifier */
-  id: string;
-  /** Position in world space */
-  position: Vec3;
-  /** Radius of attraction (default: 0.0) - nodes within this radius are not pulled further */
-  radius?: number;
-  /** Groups of nodes attracted to this attractor (empty = attracts all) */
-  groups: string[];
-  /** Strength of attraction (default: 1.0) */
-  strength?: number;
-}
-/**
- * Resolved attractor with defaults applied
- */
-interface ResolvedAttractor {
-  id: string;
-  position: Vec3;
-  groups: string[];
-  strength: number;
-  radius: number;
-}
-//#endregion
-//#region textures/StaticAssets.d.ts
+//#region rendering/links/LinksRenderer.d.ts
 /**
- * Manages read-only GPU textures created at initialization
- * These never change during simulation (except for mode changes)
- *
- * Node data: radii, colors
- * Link data: source/target indices, properties
+ * LinksRenderer - Renders links as line segments
+ * Uses shared SimulationBuffers for node positions
+ * Manages link-specific opacity and highlighting
  */
-declare class StaticAssets {
-  private nodeRadiiTexture;
-  private nodeColorsTexture;
-  private linkIndicesTexture;
-  private linkPropertiesTexture;
-  private nodeLinkMapTexture;
-  private nodeTextureSize;
-  private linkTextureSize;
-  constructor();
+declare class LinksRenderer {
+  private scene;
+  private renderer;
+  private lines;
+  private links;
+  private nodeIndexMap;
+  private linkIndexMap;
+  private interpolationSteps;
+  params: {
+    noiseStrength: number;
+    defaultAlpha: number;
+    highlightAlpha: number;
+    dimmedAlpha: number;
+    is2D: boolean;
+  };
+  private linkOpacity;
+  private simulationBuffers;
+  constructor(scene: THREE.Scene, renderer: THREE.WebGLRenderer);
   /**
-   * Set/update node radii texture
-   */
-  setNodeRadii(radii: Float32Array, textureSize: number): void;
+       * Create link geometry and materials
+       * Receives shared buffers as dependencies
+       */
+  create(links: GraphLink[], nodes: GraphNode[], simulationBuffers: SimulationBuffers): void;
   /**
-   * Set/update node colors texture
-   */
-  setNodeColors(colors: Float32Array, textureSize: number): void;
+       * Update position texture from simulation
+       * This is the SHARED texture used by both nodes and links
+       */
+  setPositionTexture(positionTexture: THREE.Texture): void;
   /**
-   * Set link indices (source/target pairs)
-   * Format: [sourceX, sourceY, targetX, targetY] per link
-   */
-  setLinkIndices(linkIndices: Float32Array, textureSize: number): void;
+       * Update shader uniforms (called each frame)
+       */
+  update(time: number): void;
   /**
-   * Set link properties (strength, distance, etc.)
-   */
-  setLinkProperties(linkProperties: Float32Array, textureSize: number): void;
-  setNodeLinkMap(linkMap: Float32Array, textureSize: number): void;
+       * Update link opacity (called every frame)
+       */
+  updateOpacity(): void;
   /**
-   * Create a data texture with proper settings for GPU compute
-   */
-  private createTexture;
-  getNodeRadiiTexture(): THREE.DataTexture | null;
-  getNodeColorsTexture(): THREE.DataTexture | null;
-  getLinkIndicesTexture(): THREE.DataTexture | null;
-  getLinkPropertiesTexture(): THREE.DataTexture | null;
-  getLinkMapTexture(): THREE.DataTexture | null;
-  getNodeTextureSize(): number;
-  getLinkTextureSize(): number;
+       * Highlight links connected to a specific node
+       */
+  highlightConnectedLinks(nodeId: string, step?: number): void;
   /**
-   * Check if assets are ready
-   */
-  hasNodeAssets(): boolean;
-  hasLinkAssets(): boolean;
+       * Highlight links connected to any of the given nodes
+       */
+  highlightConnectedToNodes(nodeIds: Set<string>, step?: number): void;
   /**
-   * Cleanup
-   */
-  dispose(): void;
-}
-declare const staticAssets: StaticAssets;
-//#endregion
-//#region simulation/BasePass.d.ts
-interface PassContext {
-  scene: THREE.Scene;
-  camera: THREE.Camera;
-  quad: THREE.BufferGeometry;
-  simBuffers: SimulationBuffers;
-  assets: StaticAssets;
-  renderer: THREE.WebGLRenderer;
-  config: ForceConfig;
-  textureSize: number;
-}
-/**
- * Base class for GPU force simulation passes
- * Each pass operates on simulation buffers and can read from static assets
- */
-declare abstract class BasePass {
-  protected material: THREE.ShaderMaterial | null;
-  protected enabled: boolean;
+       * Clear all highlights (return to defaultAlpha)
+       */
+  clearHighlights(step?: number): void;
   /**
-   * Get the name/identifier for this pass
-   */
-  abstract getName(): string;
+       * Update noise strength parameter
+       */
+  setNoiseStrength(strength: number): void;
   /**
-   * Initialize the shader material for this pass
-   */
-  abstract initMaterial(context: PassContext): void;
+       * Update alpha parameters
+       */
+  setAlphaParams(params: {
+    defaultAlpha?: number;
+    highlightAlpha?: number;
+    dimmedAlpha?: number;
+  }): void;
   /**
-   * Update uniforms before executing the pass
-   */
-  abstract updateUniforms(context: PassContext): void;
+       * Unified configuration method
+       */
+  setOptions(options: LinkOptions): void;
   /**
-   * Execute the pass (renders to current velocity target)
-   */
-  execute(context: PassContext): void;
+       * Refresh shader uniforms when params change
+       */
+  refreshUniforms(): void;
   /**
-   * Render the compute shader
-   */
-  protected render(context: PassContext): void;
+       * Handle window resize
+       */
+  resize(width: number, height: number): void;
   /**
-   * Create a shader material helper
-   */
-  protected createMaterial(vertexShader: string, fragmentShader: string, uniforms: {
-    [uniform: string]: THREE.IUniform;
-  }): THREE.ShaderMaterial;
+       * Set visibility of links
+       */
+  setVisible(visible: boolean): void;
   /**
-   * Safe uniform setter - avoids TypeScript strict null check issues
-   */
-  protected setUniform(name: string, value: unknown): void;
+       * Check if links are visible
+       */
+  isVisible(): boolean;
   /**
-   * Enable or disable this pass
-   */
-  setEnabled(enabled: boolean): void;
+       * Cleanup
+       */
+  dispose(): void;
   /**
-   * Check if pass is enabled
-   */
-  isEnabled(): boolean;
+       * Build node index mapping
+       */
+  private buildNodeMapping;
   /**
-   * Get the material for external access
-   */
-  getMaterial(): THREE.ShaderMaterial | null;
+       * Builds the instanced link geometry and per-link attribute buffers used by the renderer.
+       *
+       * This method:
+       * - Creates a line-segment template with interpolation parameter `t` for each vertex pair.
+       * - Encodes link endpoints as texture-space coordinates (`instanceLinkA` / `instanceLinkB`)
+       *   so shaders can fetch node positions from a node texture.
+       * - Derives endpoint colors from source/target node categories.
+       * - Assigns a stable per-instance alpha lookup index.
+       * - Computes a category-based visibility rank from the **target node category**.
+       *
+       * Rank/alpha behavior:
+       * - Categories are ranked by `groupOrder` (unknown categories are appended).
+       * - The rank is converted to an attenuation factor with inverted weighting:
+       *   `instanceRank = 1.0 - 0.75 * (rank / maxRank)`.
+       * - This means rank `0` keeps full weight (`1.0`), while the highest rank trends to `0.25`.
+       *
+       * Also returns a `linkIndexMap` keyed as `"sourceId-targetId"` for quick instance lookup.
+       *
+       * @param links - Graph links to encode as geometry instances.
+       * @param nodes - Graph nodes used for category/color lookup.
+       * @param nodeTextureSize - Width/height of the square node data texture used for index-to-UV conversion.
+       * @param groupOrder - Preferred category ordering for rank assignment (earlier = stronger visibility).
+       * @returns An object containing:
+       * - `geometry`: the populated `THREE.InstancedBufferGeometry`
+       * - `linkIndexMap`: map from link id (`"sourceId-targetId"`) to instance index
+       */
+  private createLinkGeometry;
   /**
-   * Cleanup resources
-   */
-  dispose(): void;
-}
-//#endregion
-//#region simulation/passes/AttractorPass.d.ts
-/**
- * Attractor force pass - attracts nodes to attractor points based on group membership
- *
- * Usage:
- *   attractorPass.setAttractors([
- *     { id: 'center', position: { x: 0, y: 0, z: 0 }, categories: ['root'] }, // categories acts as groups
- *     { id: 'left', position: { x: -100, y: 0, z: 0 }, categories: ['artwork', 'series'] }
- *   ])
- */
-declare class AttractorPass extends BasePass {
-  private attractors;
-  private groupMap;
-  private attractorsTexture;
-  private attractorGroupsTexture;
-  private attractorParamsTexture;
-  private nodeGroupsTexture;
-  getName(): string;
-  initMaterial(context: PassContext): void;
-  updateUniforms(context: PassContext): void;
-  /**
-   * Set attractors for the simulation
-   */
-  setAttractors(attractors: Attractor[]): void;
-  /**
-   * Add a single attractor
-   */
-  addAttractor(attractor: Attractor): void;
-  /**
-   * Remove an attractor by ID
-   */
-  removeAttractor(id: string): void;
-  /**
-   * Update an existing attractor's position
-   */
-  updateAttractorPosition(id: string, position: Vec3): void;
-  /**
-   * Get current attractors
-   */
-  getAttractors(): ResolvedAttractor[];
-  /**
-   * Set node groups from graph data
-   * Call this when graph data changes or grouping criteria changes
-   */
-  setNodeGroups(groups: string[][], textureSize: number): void;
+       * Build all link-related textures for simulation
+       * - linkIndicesData: child node INDEX per link entry (organized by parent)
+       * - linkPropertiesData: strength/distance per link entry
+       * - nodeLinkMapData: per-node metadata (startX, startY, count, hasLinks)
+       */
+  private buildLinkTextures;
   /**
-   * Get the group map (group name -> index)
-   */
-  getGroupMap(): Map<string, number>;
-  private createAttractorTextures;
-  private updateAttractorTextures;
-  dispose(): void;
+       * Create render material with all uniforms
+       */
+  private createRenderMaterial;
+}
+interface LinkOptions {
+  visible?: boolean;
+  noiseStrength?: number;
+  alpha?: {
+    default?: number;
+    highlight?: number;
+    dimmed?: number;
+  };
 }
 //#endregion
-//#region simulation/ForceSimulation.d.ts
-/**
- * ForceSimulation - GPU-based force simulation
- *
- * Simple architecture:
- * - Single shared config object (ForceConfig)
- * - All passes read directly from config via PassContext
- * - Enable flags control which passes execute
- * - No manual syncing required
- */
-declare class ForceSimulation {
+//#region rendering/nodes/NodesRenderer.d.ts
+declare class NodesRenderer {
+  private scene;
   private renderer;
+  private points;
+  private pickMaterial;
+  private nodeIndexMap;
+  private idArray;
+  private nodeOpacity;
+  private targets;
+  params: {
+    defaultAlpha: number;
+    highlightAlpha: number;
+    dimmedAlpha: number;
+  };
   private simulationBuffers;
-  private computeScene;
-  private computeCamera;
-  private computeQuad;
-  private velocityCarryPass;
-  private collisionPass;
-  private manyBodyPass;
-  private gravityPass;
-  private linkPass;
-  private elasticPass;
-  private attractorPass;
-  private dragPass;
-  private integratePass;
-  private forcePasses;
-  readonly config: ForceConfig;
-  private isInitialized;
-  private iterationCount;
-  constructor(renderer: THREE.WebGLRenderer);
-  private createComputeQuad;
-  /**
-   * Initialize simulation with buffers
-   */
-  initialize(simulationBuffers: SimulationBuffers): void;
-  private createContext;
-  /**
-   * Check if a pass should execute based on config
-   */
-  private shouldExecutePass;
+  private pickBuffer;
+  constructor(scene: THREE.Scene, renderer: THREE.WebGLRenderer);
+  create(nodes: GraphNode[], simulationBuffers: SimulationBuffers, pickBuffer: PickBuffer): void;
+  setPositionTexture(positionTexture: THREE.Texture): void;
+  pick(pixelX: number, pixelY: number, camera: THREE.Camera): number;
+  highlight(nodeIds: string[], step?: number): void;
+  clearHighlights(step?: number): void;
   /**
-   * Run one simulation step
-   */
-  step(deltaTime?: number): void;
+       * Update node opacity (called every frame)
+       */
+  updateOpacity(): void;
+  resize(width: number, height: number): void;
+  dispose(): void;
+  private buildNodeMapping;
   /**
-   * Get config for GUI binding
-   * Modify this object directly - changes take effect on next step()
-   */
-  getConfig(): ForceConfig;
+       * Create all node data in one pass
+       * Returns: colors, sizes, radii, nodeIds, pointIndices, alphaIndex
+       */
+  private createNodeData;
+  private createGeometry;
+  private createRenderMaterial;
+  private createPickMaterial;
+}
+//#endregion
+//#region rendering/GraphScene.d.ts
+/**
+ * GraphScene - Manages the 3D scene, camera, and renderers
+ * Responsibilities:
+ * - Scene setup and lifecycle
+ * - Node and link rendering
+ * - Camera control
+ * - Tooltip management
+ * - Mode application (visual changes)
+ */
+declare class GraphScene {
+  readonly scene: THREE.Scene;
+  readonly renderer: THREE.WebGLRenderer;
+  readonly camera: CameraController;
+  private nodeRenderer;
+  private clock;
+  private linkRenderer;
+  private postProcessing;
+  private antialiasingMode;
+  constructor(canvas: HTMLCanvasElement, cameraConfig?: CameraConfig, antialiasing?: AntialiasingMode);
   /**
-   * Re-heat the simulation (set alpha to 1)
-   */
-  reheat(amt?: number): void;
-  startDrag(index: number, targetWorldPos: THREE.Vector3): void;
-  updateDrag(targetWorldPos: THREE.Vector3): void;
-  endDrag(): void;
+       * Initialize scene with nodes and links
+       */
+  create(nodes: GraphNode[], links: GraphLink[], simulationBuffers: SimulationBuffers, pickBuffer: PickBuffer, groupOrder?: string[]): void;
   /**
-   * Set attractors for category-based attraction
-   * @param attractors Array of attractor definitions
-   */
-  setAttractors(attractors: Attractor[]): void;
+       * Apply visual mode (colors, sizes, camera position)
+       */
+  applyMode(mode: string, options?: {
+    transitionDuration?: number;
+    cameraTransitionDuration?: number;
+  }): void;
   /**
-   * Add a single attractor
-   */
-  addAttractor(attractor: Attractor): void;
+       * Update position textures from simulation
+       */
+  updatePositions(positionTexture: THREE.Texture): void;
   /**
-   * Remove an attractor by ID
-   */
-  removeAttractor(id: string): void;
+       * Update time-based uniforms (called each frame with elapsed time)
+       */
+  update(elapsedTime: number): void;
   /**
-   * Update an attractor's position (useful for animated attractors)
-   */
-  updateAttractorPosition(id: string, position: Vec3): void;
+       * GPU picking at canvas coordinates
+       */
+  pick(pixelX: number, pixelY: number): number;
   /**
-   * Get current attractors
-   */
-  getAttractors(): Attractor[];
+       * Render the scene
+       */
+  render(): void;
   /**
-   * Set node logic for attractor matching
-   * Call this when graph data changes
-   */
-  setNodeGroups(groups: (string | string[])[]): void;
-  setNodeGroupsFromData<T>(data: T[], accessor: (item: T, index: number) => string | string[] | undefined): void;
+       * Handle window resize
+       */
+  resize(width: number, height: number): void;
   /**
-   * Get the attractor pass for direct access
-   */
-  getAttractorPass(): AttractorPass;
-  getAlpha(): number;
-  getIterationCount(): number;
-  reset(): void;
+       * Cleanup all resources
+       */
   dispose(): void;
-}
-//#endregion
-//#region controls/handlers/DragHandler.d.ts
-declare class DragHandler extends EventEmitter {
-  private getNodeByIndex;
-  private cameraController?;
-  private forceSimulation?;
-  private viewport?;
-  private isDragging;
-  private raycaster;
-  private dragPlane;
-  private pointer;
-  constructor(getNodeByIndex: (index: number) => GraphNode | null, cameraController?: CameraController, forceSimulation?: ForceSimulation, viewport?: {
-    width: number;
-    height: number;
-  });
   /**
-   * Set up drag plane perpendicular to camera, passing through a world point
-   */
-  private setupDragPlane;
-  private handleDragStart;
-  private handleDrag;
-  private handleDragEnd;
-  /**
-   * Convert screen coordinates to world position on drag plane
-   */
-  private screenToWorld;
-  /**
-   * Update viewport dimensions on resize
-   */
-  resize(width: number, height: number): void;
-  dispose(): void;
+       * Switch antialiasing mode at runtime.
+       * Cannot switch to 'msaa' at runtime (requires renderer recreation).
+       * For 'smaa', 'fxaa', or 'none': creates or updates the post-processing pipeline.
+       */
+  setAntialiasing(mode: AntialiasingMode): void;
+  private applyDefaultMode;
+  getCamera(): CameraController;
+  getNodeRenderer(): NodesRenderer | null;
+  getLinkRenderer(): LinksRenderer | null;
 }
 //#endregion
-//#region textures/PickBuffer.d.ts
+//#region types/iAttractor.d.ts
 /**
- * Manages GPU picking buffer for mouse interaction
- * Separate from simulation buffers as it has different lifecycle
+ * Simple 3D vector type
  */
-declare class PickBuffer {
-  private renderer;
-  private pickTarget;
-  constructor(renderer: THREE.WebGLRenderer);
-  /**
-   * Ensure pick buffer matches viewport size
-   */
-  resize(width: number, height: number): void;
-  private createPickBuffer;
-  /**
-   * Read node ID at pixel coordinates
-   */
-  readIdAt(x: number, y: number): number;
-  /**
-   * Render scene to pick buffer
-   */
-  render(scene: THREE.Scene, camera: THREE.Camera): void;
-  getTarget(): THREE.WebGLRenderTarget | null;
-  dispose(): void;
+interface Vec3 {
+  x: number;
+  y: number;
+  z: number;
+}
+/**
+ * Attractor - A point in space that attracts nodes of specific groups
+ */
+interface Attractor {
+  /** Unique identifier */
+  id: string;
+  /** Position in world space */
+  position: Vec3;
+  /** Radius of attraction (default: 0.0) - nodes within this radius are not pulled further */
+  radius?: number;
+  /** Groups of nodes attracted to this attractor (empty = attracts all) */
+  groups: string[];
+  /** Strength of attraction (default: 1.0) */
+  strength?: number;
+}
+/**
+ * Resolved attractor with defaults applied
+ */
+interface ResolvedAttractor {
+  id: string;
+  position: Vec3;
+  groups: string[];
+  strength: number;
+  radius: number;
 }
 //#endregion
-//#region rendering/links/LinksRenderer.d.ts
+//#region textures/StaticAssets.d.ts
 /**
- * LinksRenderer - Renders links as line segments
- * Uses shared SimulationBuffers for node positions
- * Manages link-specific opacity and highlighting
+ * Manages read-only GPU textures created at initialization
+ * These never change during simulation (except for mode changes)
+ *
+ * Node data: radii, colors
+ * Link data: source/target indices, properties
  */
-declare class LinksRenderer {
-  private scene;
-  private renderer;
-  private lines;
-  private links;
-  private nodeIndexMap;
-  private linkIndexMap;
-  private interpolationSteps;
-  params: {
-    noiseStrength: number;
-    defaultAlpha: number;
-    highlightAlpha: number;
-    dimmedAlpha: number;
-    is2D: boolean;
-  };
-  private linkOpacity;
-  private simulationBuffers;
-  constructor(scene: THREE.Scene, renderer: THREE.WebGLRenderer);
-  /**
-   * Create link geometry and materials
-   * Receives shared buffers as dependencies
-   */
-  create(links: GraphLink[], nodes: GraphNode[], simulationBuffers: SimulationBuffers): void;
+declare class StaticAssets {
+  private nodeRadiiTexture;
+  private nodeColorsTexture;
+  private linkIndicesTexture;
+  private linkPropertiesTexture;
+  private nodeLinkMapTexture;
+  private nodeTextureSize;
+  private linkTextureSize;
+  constructor();
   /**
-   * Update position texture from simulation
-   * This is the SHARED texture used by both nodes and links
-   */
-  setPositionTexture(positionTexture: THREE.Texture): void;
+       * Set/update node radii texture
+       */
+  setNodeRadii(radii: Float32Array, textureSize: number): void;
   /**
-   * Update shader uniforms (called each frame)
-   */
-  update(time: number): void;
+       * Set/update node colors texture
+       */
+  setNodeColors(colors: Float32Array, textureSize: number): void;
   /**
-   * Update link opacity (called every frame)
-   */
-  updateOpacity(): void;
+       * Set link indices (source/target pairs)
+       * Format: [sourceX, sourceY, targetX, targetY] per link
+       */
+  setLinkIndices(linkIndices: Float32Array, textureSize: number): void;
   /**
-   * Highlight links connected to a specific node
-   */
-  highlightConnectedLinks(nodeId: string, step?: number): void;
+       * Set link properties (strength, distance, etc.)
+       */
+  setLinkProperties(linkProperties: Float32Array, textureSize: number): void;
+  setNodeLinkMap(linkMap: Float32Array, textureSize: number): void;
   /**
-   * Highlight links connected to any of the given nodes
-   */
-  highlightConnectedToNodes(nodeIds: Set<string>, step?: number): void;
+       * Create a data texture with proper settings for GPU compute
+       */
+  private createTexture;
+  getNodeRadiiTexture(): THREE.DataTexture | null;
+  getNodeColorsTexture(): THREE.DataTexture | null;
+  getLinkIndicesTexture(): THREE.DataTexture | null;
+  getLinkPropertiesTexture(): THREE.DataTexture | null;
+  getLinkMapTexture(): THREE.DataTexture | null;
+  getNodeTextureSize(): number;
+  getLinkTextureSize(): number;
   /**
-   * Clear all highlights (return to defaultAlpha)
-   */
-  clearHighlights(step?: number): void;
+       * Check if assets are ready
+       */
+  hasNodeAssets(): boolean;
+  hasLinkAssets(): boolean;
   /**
-   * Update noise strength parameter
-   */
-  setNoiseStrength(strength: number): void;
+       * Cleanup
+       */
+  dispose(): void;
+}
+declare const staticAssets: StaticAssets;
+//#endregion
+//#region simulation/BasePass.d.ts
+interface PassContext {
+  scene: THREE.Scene;
+  camera: THREE.Camera;
+  quad: THREE.BufferGeometry;
+  simBuffers: SimulationBuffers;
+  assets: StaticAssets;
+  renderer: THREE.WebGLRenderer;
+  config: ForceConfig;
+  textureSize: number;
+}
+/**
+ * Base class for GPU force simulation passes
+ * Each pass operates on simulation buffers and can read from static assets
+ */
+declare abstract class BasePass {
+  protected material: THREE.ShaderMaterial | null;
+  protected enabled: boolean;
   /**
-   * Update alpha parameters
-   */
-  setAlphaParams(params: {
-    defaultAlpha?: number;
-    highlightAlpha?: number;
-    dimmedAlpha?: number;
-  }): void;
+       * Get the name/identifier for this pass
+       */
+  abstract getName(): string;
   /**
-   * Unified configuration method
-   */
-  setOptions(options: LinkOptions): void;
+       * Initialize the shader material for this pass
+       */
+  abstract initMaterial(context: PassContext): void;
   /**
-   * Refresh shader uniforms when params change
-   */
-  refreshUniforms(): void;
+       * Update uniforms before executing the pass
+       */
+  abstract updateUniforms(context: PassContext): void;
   /**
-   * Handle window resize
-   */
-  resize(width: number, height: number): void;
+       * Execute the pass (renders to current velocity target)
+       */
+  execute(context: PassContext): void;
   /**
-   * Set visibility of links
-   */
-  setVisible(visible: boolean): void;
+       * Render the compute shader
+       */
+  protected render(context: PassContext): void;
   /**
-   * Check if links are visible
-   */
-  isVisible(): boolean;
+       * Create a shader material helper
+       */
+  protected createMaterial(vertexShader: string, fragmentShader: string, uniforms: {
+    [uniform: string]: THREE.IUniform;
+  }): THREE.ShaderMaterial;
   /**
-   * Cleanup
-   */
-  dispose(): void;
+       * Safe uniform setter - avoids TypeScript strict null check issues
+       */
+  protected setUniform(name: string, value: unknown): void;
   /**
-   * Build node index mapping
-   */
-  private buildNodeMapping;
+       * Enable or disable this pass
+       */
+  setEnabled(enabled: boolean): void;
   /**
-   * Builds the instanced link geometry and per-link attribute buffers used by the renderer.
-   *
-   * This method:
-   * - Creates a line-segment template with interpolation parameter `t` for each vertex pair.
-   * - Encodes link endpoints as texture-space coordinates (`instanceLinkA` / `instanceLinkB`)
-   *   so shaders can fetch node positions from a node texture.
-   * - Derives endpoint colors from source/target node categories.
-   * - Assigns a stable per-instance alpha lookup index.
-   * - Computes a category-based visibility rank from the **target node category**.
-   *
-   * Rank/alpha behavior:
-   * - Categories are ranked by `groupOrder` (unknown categories are appended).
-   * - The rank is converted to an attenuation factor with inverted weighting:
-   *   `instanceRank = 1.0 - 0.75 * (rank / maxRank)`.
-   * - This means rank `0` keeps full weight (`1.0`), while the highest rank trends to `0.25`.
-   *
-   * Also returns a `linkIndexMap` keyed as `"sourceId-targetId"` for quick instance lookup.
-   *
-   * @param links - Graph links to encode as geometry instances.
-   * @param nodes - Graph nodes used for category/color lookup.
-   * @param nodeTextureSize - Width/height of the square node data texture used for index-to-UV conversion.
-   * @param groupOrder - Preferred category ordering for rank assignment (earlier = stronger visibility).
-   * @returns An object containing:
-   * - `geometry`: the populated `THREE.InstancedBufferGeometry`
-   * - `linkIndexMap`: map from link id (`"sourceId-targetId"`) to instance index
-   */
-  private createLinkGeometry;
+       * Check if pass is enabled
+       */
+  isEnabled(): boolean;
   /**
-   * Build all link-related textures for simulation
-   * - linkIndicesData: child node INDEX per link entry (organized by parent)
-   * - linkPropertiesData: strength/distance per link entry
-   * - nodeLinkMapData: per-node metadata (startX, startY, count, hasLinks)
-   */
-  private buildLinkTextures;
+       * Get the material for external access
+       */
+  getMaterial(): THREE.ShaderMaterial | null;
   /**
-   * Create render material with all uniforms
-   */
-  private createRenderMaterial;
-}
-interface LinkOptions {
-  visible?: boolean;
-  noiseStrength?: number;
-  alpha?: {
-    default?: number;
-    highlight?: number;
-    dimmed?: number;
-  };
+       * Cleanup resources
+       */
+  dispose(): void;
 }
 //#endregion
-//#region rendering/nodes/NodesRenderer.d.ts
-declare class NodesRenderer {
-  private scene;
-  private renderer;
-  private points;
-  private pickMaterial;
-  private nodeIndexMap;
-  private idArray;
-  private nodeOpacity;
-  private targets;
-  params: {
-    defaultAlpha: number;
-    highlightAlpha: number;
-    dimmedAlpha: number;
-  };
-  private simulationBuffers;
-  private pickBuffer;
-  constructor(scene: THREE.Scene, renderer: THREE.WebGLRenderer);
-  create(nodes: GraphNode[], simulationBuffers: SimulationBuffers, pickBuffer: PickBuffer): void;
-  setPositionTexture(positionTexture: THREE.Texture): void;
-  pick(pixelX: number, pixelY: number, camera: THREE.Camera): number;
-  highlight(nodeIds: string[], step?: number): void;
-  clearHighlights(step?: number): void;
+//#region simulation/passes/AttractorPass.d.ts
+/**
+ * Attractor force pass - attracts nodes to attractor points based on group membership
+ *
+ * Usage:
+ *   attractorPass.setAttractors([
+ *     { id: 'center', position: { x: 0, y: 0, z: 0 }, categories: ['root'] }, // categories acts as groups
+ *     { id: 'left', position: { x: -100, y: 0, z: 0 }, categories: ['artwork', 'series'] }
+ *   ])
+ */
+declare class AttractorPass extends BasePass {
+  private attractors;
+  private groupMap;
+  private attractorsTexture;
+  private attractorGroupsTexture;
+  private attractorParamsTexture;
+  private nodeGroupsTexture;
+  getName(): string;
+  initMaterial(context: PassContext): void;
+  updateUniforms(context: PassContext): void;
   /**
-   * Update node opacity (called every frame)
-   */
-  updateOpacity(): void;
-  resize(width: number, height: number): void;
-  dispose(): void;
-  private buildNodeMapping;
+       * Set attractors for the simulation
+       */
+  setAttractors(attractors: Attractor[]): void;
   /**
-   * Create all node data in one pass
-   * Returns: colors, sizes, radii, nodeIds, pointIndices, alphaIndex
-   */
-  private createNodeData;
-  private createGeometry;
-  private createRenderMaterial;
-  private createPickMaterial;
+       * Add a single attractor
+       */
+  addAttractor(attractor: Attractor): void;
+  /**
+       * Remove an attractor by ID
+       */
+  removeAttractor(id: string): void;
+  /**
+       * Update an existing attractor's position
+       */
+  updateAttractorPosition(id: string, position: Vec3): void;
+  /**
+       * Get current attractors
+       */
+  getAttractors(): ResolvedAttractor[];
+  /**
+       * Set node groups from graph data
+       * Call this when graph data changes or grouping criteria changes
+       */
+  setNodeGroups(groups: string[][], textureSize: number): void;
+  /**
+       * Get the group map (group name -> index)
+       */
+  getGroupMap(): Map<string, number>;
+  private createAttractorTextures;
+  private updateAttractorTextures;
+  dispose(): void;
 }
 //#endregion
-//#region rendering/GraphScene.d.ts
+//#region simulation/ForceSimulation.d.ts
 /**
- * GraphScene - Manages the 3D scene, camera, and renderers
- * Responsibilities:
- * - Scene setup and lifecycle
- * - Node and link rendering
- * - Camera control
- * - Tooltip management
- * - Mode application (visual changes)
+ * ForceSimulation - GPU-based force simulation
+ *
+ * Simple architecture:
+ * - Single shared config object (ForceConfig)
+ * - All passes read directly from config via PassContext
+ * - Enable flags control which passes execute
+ * - No manual syncing required
  */
-declare class GraphScene {
-  readonly scene: THREE.Scene;
-  readonly renderer: THREE.WebGLRenderer;
-  readonly camera: CameraController;
-  private nodeRenderer;
-  private clock;
-  private linkRenderer;
-  private postProcessing;
-  private antialiasingMode;
-  constructor(canvas: HTMLCanvasElement, cameraConfig?: CameraConfig, antialiasing?: AntialiasingMode);
+declare class ForceSimulation {
+  private renderer;
+  private simulationBuffers;
+  private computeScene;
+  private computeCamera;
+  private computeQuad;
+  private velocityCarryPass;
+  private collisionPass;
+  private manyBodyPass;
+  private gravityPass;
+  private linkPass;
+  private elasticPass;
+  private attractorPass;
+  private dragPass;
+  private integratePass;
+  private forcePasses;
+  readonly config: ForceConfig;
+  private isInitialized;
+  private iterationCount;
+  private readonly FIXED_DT;
+  private readonly MAX_STEPS_PER_FRAME;
+  private timeAccumulator;
+  constructor(renderer: THREE.WebGLRenderer);
+  private createComputeQuad;
   /**
-   * Initialize scene with nodes and links
-   */
-  create(nodes: GraphNode[], links: GraphLink[], simulationBuffers: SimulationBuffers, pickBuffer: PickBuffer, groupOrder?: string[]): void;
+       * Initialize simulation with buffers
+       */
+  initialize(simulationBuffers: SimulationBuffers): void;
+  private createContext;
   /**
-   * Apply visual mode (colors, sizes, camera position)
-   */
-  applyMode(mode: string, options?: {
-    transitionDuration?: number;
-    cameraTransitionDuration?: number;
-  }): void;
+       * Check if a pass should execute based on config
+       */
+  private shouldExecutePass;
   /**
-   * Update position textures from simulation
-   */
-  updatePositions(positionTexture: THREE.Texture): void;
+       * Run simulation steps using a fixed timestep accumulator.
+       * Regardless of monitor refresh rate, physics always steps at 1/60s intervals.
+       */
+  step(deltaTime?: number): void;
   /**
-   * Update time-based uniforms (called each frame with elapsed time)
-   */
-  update(elapsedTime: number): void;
+       * Execute one fixed-rate physics step (always at 1/60s)
+       */
+  private fixedStep;
   /**
-   * GPU picking at canvas coordinates
-   */
-  pick(pixelX: number, pixelY: number): number;
+       * Get config for GUI binding
+       * Modify this object directly - changes take effect on next step()
+       */
+  getConfig(): ForceConfig;
   /**
-   * Render the scene
-   */
-  render(): void;
+       * Re-heat the simulation (set alpha to 1)
+       */
+  reheat(amt?: number): void;
+  startDrag(index: number, targetWorldPos: THREE.Vector3): void;
+  updateDrag(targetWorldPos: THREE.Vector3): void;
+  endDrag(): void;
   /**
-   * Handle window resize
-   */
-  resize(width: number, height: number): void;
+       * Set attractors for category-based attraction
+       * @param attractors Array of attractor definitions
+       */
+  setAttractors(attractors: Attractor[]): void;
   /**
-   * Cleanup all resources
-   */
-  dispose(): void;
+       * Add a single attractor
+       */
+  addAttractor(attractor: Attractor): void;
   /**
-   * Switch antialiasing mode at runtime.
-   * Cannot switch to 'msaa' at runtime (requires renderer recreation).
-   * For 'smaa', 'fxaa', or 'none': creates or updates the post-processing pipeline.
-   */
-  setAntialiasing(mode: AntialiasingMode): void;
-  private applyDefaultMode;
-  getCamera(): CameraController;
-  getNodeRenderer(): NodesRenderer | null;
-  getLinkRenderer(): LinksRenderer | null;
+       * Remove an attractor by ID
+       */
+  removeAttractor(id: string): void;
+  /**
+       * Update an attractor's position (useful for animated attractors)
+       */
+  updateAttractorPosition(id: string, position: Vec3): void;
+  /**
+       * Get current attractors
+       */
+  getAttractors(): Attractor[];
+  /**
+       * Set node logic for attractor matching
+       * Call this when graph data changes
+       */
+  setNodeGroups(groups: (string | string[])[]): void;
+  setNodeGroupsFromData<T>(data: T[], accessor: (item: T, index: number) => string | string[] | undefined): void;
+  /**
+       * Get the attractor pass for direct access
+       */
+  getAttractorPass(): AttractorPass;
+  getAlpha(): number;
+  getIterationCount(): number;
+  reset(): void;
+  dispose(): void;
 }
 //#endregion
 //#region ui/TooltipManager.d.ts
@@ -1028,35 +963,35 @@ declare class TooltipManager {
   private onCloseCallback?;
   constructor(container: HTMLElement, canvas: HTMLCanvasElement, config?: TooltipConfig);
   /**
-   * Show grab cursor when hovering over a node
-   */
+       * Show grab cursor when hovering over a node
+       */
   showGrabIcon(x: number, y: number, progress: number): void;
   hideGrabIcon(): void;
   /**
-   * Show preview tooltip (triggered by pop event when hover reaches 1.0)
-   */
+       * Show preview tooltip (triggered by pop event when hover reaches 1.0)
+       */
   showPreview(node: GraphNode, x: number, y: number): void;
   hidePreview(): void;
   /**
-   * Show full tooltip (triggered by click)
-   */
+       * Show full tooltip (triggered by click)
+       */
   showFull(node: GraphNode, x: number, y: number): void;
   hideFull(): void;
   /**
-   * Set callback for when tooltip is closed
-   */
+       * Set callback for when tooltip is closed
+       */
   setOnCloseCallback(callback: () => void): void;
   /**
-   * Add close button to tooltip
-   */
+       * Add close button to tooltip
+       */
   private addCloseButton;
   /**
-   * Remove close button from tooltip
-   */
+       * Remove close button from tooltip
+       */
   private removeCloseButton;
   /**
-   * Hide all tooltips
-   */
+       * Hide all tooltips
+       */
   hideAll(): void;
   showMainTooltip(content: string, x: number, y: number): void;
   hideMainTooltip(): void;
@@ -1064,12 +999,123 @@ declare class TooltipManager {
   hideChainTooltips(): void;
   updateMainTooltipPos(x: number, y: number): void;
   /**
-   * Set main tooltip visibility (doesn't affect open state or content)
-   */
+       * Set main tooltip visibility (doesn't affect open state or content)
+       */
   setMainTooltipVisibility(visible: boolean): void;
   dispose(): void;
 }
 //#endregion
+//#region core/EventEmitter.d.ts
+declare class EventEmitter {
+  private listeners;
+  protected listenerCount(event: string): number;
+  on(event: string, listener: Function): () => void;
+  off(event: string, listener: Function): void;
+  emit(event: string, ...args: any[]): void;
+}
+//#endregion
+//#region controls/handlers/ClickHandler.d.ts
+declare class ClickHandler extends EventEmitter {
+  private getNodeByIndex;
+  constructor(getNodeByIndex: (index: number) => GraphNode | null);
+  private handleClick;
+  dispose(): void;
+}
+//#endregion
+//#region controls/handlers/DragHandler.d.ts
+declare class DragHandler extends EventEmitter {
+  private getNodeByIndex;
+  private cameraController?;
+  private forceSimulation?;
+  private viewport?;
+  private isDragging;
+  private raycaster;
+  private dragPlane;
+  private pointer;
+  constructor(getNodeByIndex: (index: number) => GraphNode | null, cameraController?: CameraController, forceSimulation?: ForceSimulation, viewport?: {
+    width: number;
+    height: number;
+  });
+  /**
+       * Set up drag plane perpendicular to camera, passing through a world point
+       */
+  private setupDragPlane;
+  private handleDragStart;
+  private handleDrag;
+  private handleDragEnd;
+  /**
+       * Convert screen coordinates to world position on drag plane
+       */
+  private screenToWorld;
+  /**
+       * Update viewport dimensions on resize
+       */
+  resize(width: number, height: number): void;
+  dispose(): void;
+}
+//#endregion
+//#region controls/handlers/HoverHandler.d.ts
+declare class HoverHandler extends EventEmitter {
+  private getNodeByIndex;
+  constructor(getNodeByIndex: (index: number) => GraphNode | null);
+  private handleHoverStart;
+  private handleHover;
+  private handlePop;
+  private handleHoverEnd;
+  dispose(): void;
+}
+//#endregion
+//#region controls/InputProcessor.d.ts
+/**
+ * Manages pointer/mouse input and emits interaction events
+ * Uses GPU picking for efficient node detection
+ */
+declare class InputProcessor extends EventEmitter {
+  private pickFn;
+  private canvas;
+  private viewport;
+  private readonly CLICK_THRESHOLD;
+  private readonly HOVER_TO_POP_MS;
+  private pointer;
+  private canvasPointer;
+  private isPointerDown;
+  private isDragging;
+  private mouseDownTime;
+  private draggedIndex;
+  private currentHoverIndex;
+  private hoverStartTime;
+  private hoverProgress;
+  private hasPopped;
+  private isTouch;
+  private readonly TOUCH_MOVE_THRESHOLD;
+  private pointerDownX;
+  private pointerDownY;
+  private lastClientX;
+  private lastClientY;
+  constructor(pickFn: (x: number, y: number) => number, // Injected
+  canvas: HTMLCanvasElement, viewport: {
+    width: number;
+    height: number;
+  });
+  private setupEventListeners;
+  private handlePointerMove;
+  private handlePointerDown;
+  private handlePointerUp;
+  private handlePointerLeave;
+  private updateHover;
+  /**
+       * Update hover state even when pointer is stationary
+       * Called from render loop
+       */
+  update(): void;
+  private updatePointer;
+  /**
+       * Update viewport dimensions on resize
+       */
+  resize(width: number, height: number): void;
+  dispose(): void;
+}
+//#endregion
 //#region controls/InteractionManager.d.ts
 declare class InteractionManager {
   private graphScene?;
@@ -1090,9 +1136,9 @@ declare class InteractionManager {
   private wireEvents;
   private wireTooltipEvents;
   /**
-   * Wire visual feedback events (opacity, highlighting)
-   * Centralized control of visual responses to interactions
-   */
+       * Wire visual feedback events (opacity, highlighting)
+       * Centralized control of visual responses to interactions
+       */
   private wireVisualFeedbackEvents;
   getPointerInput(): InputProcessor;
   getHoverHandler(): HoverHandler;
@@ -1101,51 +1147,13 @@ declare class InteractionManager {
   getTooltipManager(): TooltipManager;
   isTooltipStickyOpen(): boolean;
   /**
-   * Update viewport dimensions on resize
-   */
+       * Update viewport dimensions on resize
+       */
   resize(width: number, height: number): void;
   cleanup(): void;
   dispose(): void;
 }
 //#endregion
-//#region core/Clock.d.ts
-/**
- * Clock - Unified timing for the force graph package
- */
-declare class Clock {
-  private previousTime;
-  private elapsedTime;
-  private deltaTime;
-  private isRunning;
-  private maxDeltaTime;
-  constructor();
-  /**
-   * Start the clock
-   */
-  start(): void;
-  /**
-   * Stop the clock
-   */
-  stop(): void;
-  /**
-   * Update the clock - call once per frame
-   * @returns delta time in seconds
-   */
-  update(): number;
-  /**
-   * Get delta time in seconds
-   */
-  getDeltaTime(): number;
-  /**
-   * Get total elapsed time in seconds
-   */
-  getElapsedTime(): number;
-  /**
-   * Check if clock is running
-   */
-  getIsRunning(): boolean;
-}
-//#endregion
 //#region core/GraphStore.d.ts
 /**
  * GraphStore - Central data management
@@ -1166,68 +1174,68 @@ declare class GraphStore {
   private nodeToLinks;
   constructor();
   /**
-   * Set graph data (replaces all)
-   */
+       * Set graph data (replaces all)
+       */
   setData(data: GraphData): void;
   /**
-   * Add nodes
-   */
+       * Add nodes
+       */
   addNodes(nodes: GraphNode[]): void;
   /**
-   * Remove nodes (and connected links)
-   */
+       * Remove nodes (and connected links)
+       */
   removeNodes(nodeIds: string[]): void;
   /**
-   * Add links
-   */
+       * Add links
+       */
   addLinks(links: GraphLink[]): void;
   /**
-   * Remove links
-   */
+       * Remove links
+       */
   removeLinks(linkIds: string[]): void;
   /**
-   * Get all nodes as array
-   */
+       * Get all nodes as array
+       */
   getNodes(): GraphNode[];
   /**
-   * Get all links as array
-   */
+       * Get all links as array
+       */
   getLinks(): GraphLink[];
   /**
-   * Get connected node IDs for a given node
-   */
+       * Get connected node IDs for a given node
+       */
   getConnectedNodeIds(nodeId: string): string[];
   /**
-   * Get node by ID
-   */
+       * Get node by ID
+       */
   getNodeById(id: string): GraphNode | null;
   /**
-   * Get node by index
-   */
+       * Get node by index
+       */
   getNodeByIndex(index: number): GraphNode | null;
   /**
-   * Get node index
-   */
+       * Get node index
+       */
   getNodeIndex(id: string): number;
   /**
-   * Get link by ID
-   */
+       * Get link by ID
+       */
   getLinkById(id: string): GraphLink | null;
   /**
-   * Get links connected to node
-   */
+       * Get links connected to node
+       */
   getNodeLinks(nodeId: string): GraphLink[];
   /**
-   * Get node count
-   */
+       * Get node count
+       */
   getNodeCount(): number;
   /**
-   * Get link count
-   */
+       * Get link count
+       */
   getLinkCount(): number;
   /**
-   * Clear all data
-   */
+       * Clear all data
+       */
   clear(): void;
   private getLinkId;
   private addLinkConnectivity;
@@ -1269,132 +1277,133 @@ declare class Engine {
   private smoothedTooltipPos;
   constructor(canvas: HTMLCanvasElement, options?: EngineOptions);
   /**
-   * Handle window resize event
-   */
+       * Handle window resize event
+       */
   private handleWindowResize;
   /**
-   * Set graph data
-   */
+       * Set graph data
+       */
   setData(data: GraphData): void;
   /**
-   * Update node states based on a callback
-   * This allows changing visibility/behavior without resetting the simulation
-   */
+       * Update node states based on a callback
+       * This allows changing visibility/behavior without resetting the simulation
+       */
   updateNodeStates(callback: (node: GraphNode) => NodeState): void;
   /**
-   * Set target positions for elastic force (tree layout, etc.)
-   * Writes positions into the "original positions" GPU buffer that ElasticPass reads from,
-   * without touching current positions or node states.
-   * Must be called AFTER applyPreset() since updateNodeStates() overwrites original positions.
-   */
+       * Set target positions for elastic force (tree layout, etc.)
+       * Writes positions into the "original positions" GPU buffer that ElasticPass reads from,
+       * without touching current positions or node states.
+       * Must be called AFTER applyPreset() since updateNodeStates() overwrites original positions.
+       */
   setTargetPositions(targets: Map<string, {
     x: number;
     y: number;
     z: number;
   }>): void;
   /**
-   * Reheat the simulation
-   */
+       * Reheat the simulation
+       */
   reheat(alpha?: number): void;
   /**
-   * Set alpha decay
-   */
+       * Set alpha decay
+       */
   setAlphaDecay(decay: number): void;
   /**
-   * Get current alpha
-   */
+       * Get current alpha
+       */
   getAlpha(): number;
-  /**Apply a preset to the graph
-   */
+  /**
+        Apply a preset to the graph
+       */
   applyPreset(preset: GraphPreset): void;
   /**
-   *
-   * Start render loop
-   */
+       *
+       * Start render loop
+       */
   start(): void;
   /**
-   * Stop render loop
-   */
+       * Stop render loop
+       */
   stop(): void;
   /**
-   * Render loop
-   */
+       * Render loop
+       */
   private animate;
   /**
-   * GPU pick node at canvas coordinates
-   */
+       * GPU pick node at canvas coordinates
+       */
   pickNode(x: number, y: number): string | null;
   /**
-   * Get node by ID
-   */
+       * Get node by ID
+       */
   getNodeById(id: string): GraphNode | null;
   /**
-   * Highlight nodes
-   */
+       * Highlight nodes
+       */
   highlightNodes(nodeIds: string[]): void;
   /**
-   * Clear highlights
-   */
+       * Clear highlights
+       */
   clearHighlights(): void;
   /**
-   * Get node position in 3D space
-   */
+       * Get node position in 3D space
+       */
   getNodePosition(nodeId: string): THREE.Vector3 | null;
   /**
-   * Get node screen position from world position
-   * Returns position and visibility info (whether node is on screen and in front of camera)
-   */
+       * Get node screen position from world position
+       * Returns position and visibility info (whether node is on screen and in front of camera)
+       */
   getNodeScreenPosition(nodeId: string): {
     x: number;
     y: number;
     visible: boolean;
   } | null;
   /**
-   * Update sticky tooltip position to follow node during camera movement
-   * Uses lerp smoothing to filter out micro-jitter from force simulation
-   */
+       * Update sticky tooltip position to follow node during camera movement
+       * Uses lerp smoothing to filter out micro-jitter from force simulation
+       */
   private updateStickyTooltipPosition;
   /**
-   * Programmatically select a node (highlight + tooltip)
-   */
+       * Programmatically select a node (highlight + tooltip)
+       */
   selectNode(nodeId: string): void;
   /**
-   * Resize canvas and all dependent components
-   */
+       * Resize canvas and all dependent components
+       */
   resize(width: number, height: number): void;
   /**
-   * Get the unified clock for timing information
-   */
+       * Get the unified clock for timing information
+       */
   getClock(): Clock;
   /**
-   * Get all nodes
-   */
+       * Get all nodes
+       */
   get nodes(): GraphNode[];
   /**
-   * Get all links
-   */
+       * Get all links
+       */
   get links(): GraphLink[];
   /**
-   * Get force simulation for external configuration (GUI binding)
-   */
+       * Get force simulation for external configuration (GUI binding)
+       */
   get simulation(): ForceSimulation;
   /**
-   * Get camera controller for external configuration
-   */
+       * Get camera controller for external configuration
+       */
   get camera(): CameraController;
   /**
-   * Set camera mode (Orbit, Map, Fly)
-   */
+       * Set camera mode (Orbit, Map, Fly)
+       */
   setCameraMode(mode: CameraMode): void;
   /**
-   * Set antialiasing mode at runtime.
-   * Supports switching between 'smaa', 'fxaa', and 'none'.
-   * Cannot switch to 'msaa' at runtime (requires renderer recreation).
-   */
+       * Set antialiasing mode at runtime.
+       * Supports switching between 'smaa', 'fxaa', and 'none'.
+       * Cannot switch to 'msaa' at runtime (requires renderer recreation).
+       */
   setAntialiasing(mode: AntialiasingMode): void;
   /**
-   * Animate camera to look at a specific target from a specific position
-   */
+       * Animate camera to look at a specific target from a specific position
+       */
   setCameraLookAt(position: {
     x: number;
     y: number;
@@ -1405,16 +1414,16 @@ declare class Engine {
     z: number;
   }, transitionDuration?: number): Promise<void>;
   /**
-   * Focus camera on a specific target node
-   */
+       * Focus camera on a specific target node
+       */
   setCameraFocus(target: {
     x: number;
     y: number;
     z: number;
   }, distance: number, transitionDuration?: number): Promise<void>;
   /**
-   * Cleanup
-   */
+       * Cleanup
+       */
   dispose(): void;
   private calculateTextureSize;
 }
@@ -1463,68 +1472,68 @@ declare class StyleRegistry {
   private defaultNodeStyle;
   private defaultLinkStyle;
   /**
-   * Convert color input to THREE.Color
-   */
+       * Convert color input to THREE.Color
+       */
   private toColor;
   /**
-   * Set the default style for nodes without a category
-   */
+       * Set the default style for nodes without a category
+       */
   setDefaultNodeStyle(style: Partial<NodeStyle>): void;
   /**
-   * Set the default style for links without a category
-   */
+       * Set the default style for links without a category
+       */
   setDefaultLinkStyle(style: Partial<LinkStyle>): void;
   /**
-   * Register a style for a node category
-   */
+       * Register a style for a node category
+       */
   setNodeStyle(category: string, style: NodeStyle): void;
   /**
-   * Register multiple node styles at once
-   */
+       * Register multiple node styles at once
+       */
   setNodeStyles(styles: Record<string, NodeStyle>): void;
   /**
-   * Register a style for a link category
-   */
+       * Register a style for a link category
+       */
   setLinkStyle(category: string, style: LinkStyle): void;
   /**
-   * Register multiple link styles at once
-   */
+       * Register multiple link styles at once
+       */
   setLinkStyles(styles: Record<string, LinkStyle>): void;
   /**
-   * Get the resolved style for a node category
-   */
+       * Get the resolved style for a node category
+       */
   getNodeStyle(category?: string): ResolvedNodeStyle;
   /**
-   * Get the resolved style for a link category
-   */
+       * Get the resolved style for a link category
+       */
   getLinkStyle(category?: string): ResolvedLinkStyle;
   /**
-   * Check if a node category exists
-   */
+       * Check if a node category exists
+       */
   hasNodeStyle(category: string): boolean;
   /**
-   * Check if a link category exists
-   */
+       * Check if a link category exists
+       */
   hasLinkStyle(category: string): boolean;
   /**
-   * Remove a node style
-   */
+       * Remove a node style
+       */
   removeNodeStyle(category: string): void;
   /**
-   * Remove a link style
-   */
+       * Remove a link style
+       */
   removeLinkStyle(category: string): void;
   /**
-   * Clear all styles
-   */
+       * Clear all styles
+       */
   clear(): void;
   /**
-   * Get all registered node categories
-   */
+       * Get all registered node categories
+       */
   getNodeCategories(): string[];
   /**
-   * Get all registered link categories
-   */
+       * Get all registered link categories
+       */
   getLinkCategories(): string[];
 }
 declare const styleRegistry: StyleRegistry;