@kortexya/nodus 0.1.0

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@kortexya/nodus",
+  "version": "0.1.0",
+  "description": "Nodus \u2014 a high-performance graph visualization engine (WebGL/WebGPU/Canvas/SVG).",
+  "homepage": "https://kortexya.com",
+  "author": "Kortexya <david.loiret@kortexya.com>",
+  "license": "UNLICENSED",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "nodus.src.bundle.js",
+  "type": "module",
+  "scripts": {
+    "build:wasm": "wasm-pack build crates/nodus-wasm --target bundler --out-dir ../../pkg",
+    "build:render-wasm": "wasm-pack build crates/nodus-render-wasm --target bundler --out-dir pkg-render --release",
+    "build": "npm run build:wasm && npm run build:render-wasm && npm run clean:dist && vite build --config vite.build.config.ts && npm run build:types",
+    "diff:ast-lsp": "node scripts/ast-lsp-diff.mjs",
+    "clean:dist": "rm -f nodus.src.bundle.js nodus_wasm-*.js nodus_render_wasm-*.js __vite-plugin-wasm-helper-*.js chunk-*.js && rm -rf assets types",
+    "build:types": "tsc -p tsconfig.json --declaration --emitDeclarationOnly --noEmit false --outDir types",
+    "prepublishOnly": "npm run build",
+    "release": "bash scripts/release.sh"
+  },
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./nodus.src.bundle.js",
+      "default": "./nodus.src.bundle.js"
+    },
+    "./esm": "./nodus.src.bundle.js"
+  },
+  "files": [
+    "nodus.src.bundle.js",
+    "types",
+    "nodus_wasm-*.js",
+    "nodus_render_wasm-*.js",
+    "/__vite-plugin-wasm-helper-*.js",
+    "chunk-*.js",
+    "assets",
+    "README.md"
+  ],
+  "optionalDependencies": {
+    "@mapbox/mapbox-gl-rtl-text": "^0.2.0",
+    "@types/leaflet": ">=1.x",
+    "leaflet": ">=1.x",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "playwright": "^1.59.1",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.9",
+    "vite-plugin-wasm": "^3.6.0"
+  },
+  "dependencies": {
+    "delaunator": "^5.1.0",
+    "fflate": "^0.8.2"
+  },
+  "sideEffects": true,
+  "types": "./types/index.d.ts"
+}

package/types/Nodus.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Nodus main class — the public entry point for the library.
+ *
+ * Lifecycle and structure:
+ *   - The constructor stores the user params and delegates to `_init`.
+ *   - `_init` builds the internal `NodusModules` container and instantiates
+ *     every public API module (styles, algorithms, layouts, view, ...).
+ *   - `safelyBindToInstance()` binds all prototype methods to the instance so
+ *     they can be passed around as standalone callbacks.
+ *   - The mixin API modules (ClassesAPI, CaptorAPI, DomAPI, GraphAPI,
+ *     GraphicsAPI, SelectionAPI, DisabledAPI, SettingsAPI) are merged onto the
+ *     prototype via `applyMixins` at module load time.
+ */
+import { Node } from './core/Node';
+import { Edge } from './core/Edge';
+import { NodeList } from './core/NodeList';
+import { EdgeList } from './core/EdgeList';
+import { NodusModules } from './internals/NodusModules';
+import { StylesAPI } from './modules/StylesAPI';
+import { AlgorithmsAPI } from './modules/AlgorithmsAPI';
+import { ExportAPI as ExportsAPI } from './modules/ExportAPI';
+import { KeyboardAPI } from './modules/KeyboardAPI';
+import { GeneratorsAPI } from './modules/GeneratorsAPI';
+import { LayoutsAPI } from './modules/LayoutsAPI';
+import { TransformationsAPI } from './modules/TransformationsAPI';
+import { ToolsAPI } from './modules/ToolsAPI';
+import { ViewAPI } from './modules/ViewAPI';
+import { MouseAPI } from './modules/MouseAPI';
+import { EventsAPI } from './modules/EventsAPI';
+import { SchemaAPI } from './modules/SchemaAPI';
+import { RulesAPI } from './modules/RulesAPI';
+import { GeoAPI } from './modules/GeoAPI';
+import { LayersAPI } from './modules/LayersAPI';
+import { HypergraphAPI } from './modules/HypergraphAPI';
+import { DebugAPI } from './modules/DebugAPI';
+import { ClassesAPI } from './modules/ClassesAPI';
+import { CaptorAPI } from './modules/CaptorAPI';
+import { DomAPI } from './modules/DomAPI';
+import { GraphAPI } from './modules/GraphAPI';
+import { GraphicsAPI } from './modules/GraphicsAPI';
+import { SelectionAPI } from './modules/SelectionAPI';
+import { DisabledAPI } from './modules/DisabledAPI';
+import { SettingsAPI } from './modules/SettingsAPI';
+import * as geometry from './geometry/index';
+import * as parse from './modules/ParseAPI';
+export interface Nodus<ND, ED> extends ClassesAPI, CaptorAPI, DomAPI, GraphAPI, GraphicsAPI, SelectionAPI<ND, ED>, DisabledAPI<ND, ED>, SettingsAPI {
+}
+export declare class Nodus<ND = any, ED = any> {
+    node: (id: any) => Node<ND, ED>;
+    edge: (id: any) => Edge<ED, ND>;
+    nodeList: (indexes?: Uint32Array) => NodeList<ND, ED>;
+    edgeList: (indexes?: Uint32Array) => EdgeList<ED, ND>;
+    _onReady: Array<(nodus: this) => void>;
+    build: {
+        version: string;
+        commit: string;
+        buildTime: string;
+    };
+    modules: NodusModules;
+    _initParameters: any;
+    _debug: boolean;
+    _token: number;
+    styles: StylesAPI;
+    algorithms: AlgorithmsAPI;
+    export: ExportsAPI;
+    keyboard: KeyboardAPI;
+    generate: GeneratorsAPI;
+    layouts: LayoutsAPI;
+    transformations: TransformationsAPI;
+    tools: ToolsAPI;
+    view: ViewAPI;
+    mouse: MouseAPI;
+    events: EventsAPI;
+    schema: SchemaAPI;
+    rules: RulesAPI;
+    geo: GeoAPI;
+    layers: LayersAPI;
+    hypergraph: HypergraphAPI;
+    debug: DebugAPI;
+    static libraries: Record<string, any>;
+    static geometry: typeof geometry;
+    static parse: typeof parse;
+    static build: {
+        version: string;
+        commit: string;
+        buildTime: string;
+    };
+    static algorithms: any;
+    static utils: any;
+    constructor(params?: any);
+    _init(params: any): void;
+    safelyBindToInstance(): void;
+    onReady(cb: (nodus: this) => void): void;
+    _destroy(): void;
+    destroy(): void;
+    isDestroyed(): boolean;
+    reset(): void;
+    isDebug(): boolean;
+}
+export default Nodus;

package/types/algorithms/concentric/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Concentric layout algorithm.
+ *
+ * Places nodes on concentric circles around a central node.
+ * Nodes are sorted by a configurable metric (degree, radius,
+ * data property, or random) and distributed ring-by-ring.
+ */
+export interface ConcentricOptions {
+    centralNode: number;
+    centerX?: number;
+    centerY?: number;
+    sortBy?: string;
+    clockwise?: boolean;
+    allowOverlap?: boolean;
+    circleHopRatio?: number;
+}
+export interface ConcentricInput {
+    nodeCount: number;
+    sources: number[];
+    targets: number[];
+    nodeRadii: number[];
+    nodeData?: any[];
+    nodeDegrees?: number[];
+}
+export interface ConcentricResult {
+    x: number[];
+    y: number[];
+}
+export declare function concentric(input: ConcentricInput, options: ConcentricOptions): ConcentricResult;

package/types/algorithms/concentricFactory.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Concentric layout factory.
+ *
+ * Wraps the concentric layout algorithm as a layout descriptor. Nodes are
+ * placed on concentric circles based on their shortest-path distance from a
+ * central node. The COMPUTE — the (quirky) simplified Dijkstra and the ring
+ * placement trig — runs in Rust (wasm `layout_concentric_distances` /
+ * `layout_concentric_place`, byte-exact; grid-concentric-parity.mjs holds the
+ * frozen TS oracle). Ring building, the per-ring SORTS, and the PLACEMENT
+ * TRIG stay TS. The sorts carry V8 comparator semantics; the placement uses
+ * the BROWSER'S Math.cos/sin deliberately: Chrome 149 shipped different
+ * (correctly-rounded) sin/cos than node-22's V8, so any fixed wasm trig
+ * diverges from the live reference by 1 ULP on ~3% of inputs ON SOME browser
+ * version — byte parity with dev means floating with the browser's Math, and
+ * only the browser's own functions do that. (Discovered when the wasm
+ * placement drifted 1 ULP vs dev in Chrome 149 while matching node exactly.)
+ * wasm is REQUIRED for the Dijkstra (Phase-5 rule).
+ */
+interface Nodus {
+    modules: {
+        layouts: {
+            register(descriptor: LayoutDescriptor): void;
+            start(name: string, opts: any): Promise<any>;
+        };
+        graph: any;
+    };
+}
+interface LayoutDescriptor {
+    name: string;
+    configure(opts: any, modules: any): any;
+    context(): any;
+    update(msg: any, context: any): any;
+    isRunning(): boolean;
+    onSync(msg: any): any;
+}
+declare const concentricDescriptor: LayoutDescriptor;
+/**
+ * Create and register the concentric layout on an Nodus instance.
+ *
+ * @returns A function `(opts) => Promise<any>` that starts the layout.
+ */
+export default function concentricFactory(nodus: Nodus): (opts: any) => Promise<any>;
+export { concentricDescriptor };

package/types/algorithms/force/Alea.d.ts

@@ -0,0 +1,13 @@
+export declare function setSeed(seed: string | number): void;
+export declare function seededRandom(): number;
+export declare function randomize(): number;
+export declare class Alea {
+    private c;
+    private s0;
+    private s1;
+    private s2;
+    constructor(seed: string | number);
+    next(): number;
+    nextDouble(): number;
+    nextInt32(): number;
+}

package/types/algorithms/force/BVH.d.ts

@@ -0,0 +1,35 @@
+export declare class Node {
+    left: Node | null;
+    right: Node | null;
+    data: any | null;
+    code: number | null;
+    cx: number;
+    cy: number;
+    r: number;
+    mass: number;
+    constructor(code: number | null, data: any | null, left: Node | null, right: Node | null);
+}
+export declare function buildIterative(elements: any[], ids: Uint32Array, codes: Uint32Array, start: number, end: number): Node;
+export declare function buildIterativeBuckets(elements: any[], ids: Uint32Array, codes: Uint32Array, start: number, end: number, bucketSize: number): Node;
+export declare function hilbert(x: number, y: number): number;
+export declare function morton2(x: number, y: number): number;
+export declare function radixSort(ids: Uint32Array, codes: Uint32Array): void;
+export declare class BVH {
+    bucketSize: number;
+    private _root;
+    private _minX;
+    private _minY;
+    private _maxX;
+    private _maxY;
+    private _hw;
+    private _hh;
+    constructor(elements: any[], options: {
+        getX: (e: any) => number;
+        getY: (e: any) => number;
+        bucketSize?: number;
+        sfc?: number;
+    });
+    get root(): Node | null;
+    preOrder(callback: (node: Node) => boolean | void): this;
+    postOrder(callback: (node: Node) => void): this;
+}

package/types/algorithms/force/LayoutData.d.ts

@@ -0,0 +1,40 @@
+export declare class LayoutData {
+    X: Float64Array;
+    Y: Float64Array;
+    R: Float64Array;
+    fx: Float32Array;
+    fy: Float32Array;
+    vx: Float32Array;
+    vy: Float32Array;
+    pinned: Uint8Array;
+    masses: Float32Array;
+    weights: Float32Array;
+    lengths: Float32Array;
+    sources: Uint32Array;
+    targets: Uint32Array;
+    degrees: Uint32Array;
+    layer: Uint32Array;
+    parent: Int32Array;
+    cluster: Int32Array;
+    component: Uint32Array;
+    components: number[][];
+    layers: number[][];
+    nodeIds: number[];
+    edgeIds: number[];
+    groups: number[][];
+    maxR: Float32Array;
+    cellSize: number;
+    cells: any[];
+    hasGroups: boolean;
+    movements: number[];
+    surfaces: number[];
+    movementsPrev: number[];
+    surfacesPrev: number[];
+    bucketSize: number;
+    constructor(graph: {
+        nodes: any[];
+        edges: any[];
+    }, doTopology: boolean | undefined, groups: any);
+    nodeToGroup?: Int32Array;
+    updateGroups(): void;
+}

package/types/algorithms/force/Packing.d.ts

@@ -0,0 +1,31 @@
+export declare function unorderedPair(u: number, v: number): number;
+export declare function orderedPair(u: number, v: number): number;
+export declare function alignSiblings(data: any, minAngle?: number, offset?: number): void;
+export declare function potpack(boxes: any[]): void;
+export declare function boxpack(boxes: any[], margin?: number): void;
+export declare class ComponentBox {
+    ids: number[];
+    xmin: number;
+    ymin: number;
+    xmax: number;
+    ymax: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    cx: number;
+    cy: number;
+    radius: number;
+    mx: number;
+    my: number;
+    m: number;
+    maxr: number;
+    add(id: number, x: number, y: number, r: number): void;
+    measure(margin?: number): this;
+}
+export declare function spiralpack(boxes: ComponentBox[], margin: number | undefined, X: number[], Y: number[], R: number[]): void;
+export declare function groupAndMeasure(X: number[], Y: number[], R: number[], components: number[][]): {
+    boxes: ComponentBox[];
+    biggest: number;
+};
+export declare function postprocessing(nodeIds: number[], data: any, options: any): void;

package/types/algorithms/force/Physics.d.ts

@@ -0,0 +1,61 @@
+import { BVH } from './BVH';
+interface PhysicsState {
+    sources: Uint32Array;
+    targets: Uint32Array;
+    X: Float64Array | Float32Array | number[];
+    Y: Float64Array | Float32Array | number[];
+    R: Float64Array | Float32Array | number[];
+    fx: Float32Array;
+    fy: Float32Array;
+    vx: Float32Array;
+    vy: Float32Array;
+    degrees: Uint32Array;
+    masses: Float32Array;
+    weights: Float32Array;
+    pinned: Uint8Array;
+    movements: number[];
+    surfaces: number[];
+    layers: number[][];
+    layer: Uint32Array;
+    nodeToGroup?: Int32Array;
+    hasGroups: boolean;
+    cells: any[];
+    cellSize: number;
+}
+interface PhysicsOptions {
+    charge: number;
+    edgeStrength: number;
+    edgeLength: number;
+    friction: number;
+    elasticity: number;
+    margin: number;
+    cx?: number;
+    cy?: number;
+    gravity: number;
+    theta: number;
+    inertia: number;
+    maxDisplacement: number;
+    barnesHutOptimization: boolean;
+    bucketSize?: number;
+}
+export declare function repulsion(alpha: number, nodeIndexes: number[], data: PhysicsState, options: PhysicsOptions): void;
+export declare function repulsionBH(alpha: number, nodeIndexes: number[], prevBvh: BVH | null, data: PhysicsState, options: PhysicsOptions): BVH;
+export declare function collisionForce(alpha: number, nodeIndexes: number[], bvh: BVH, data: PhysicsState, options: PhysicsOptions): void;
+export declare function center(alpha: number, nodeIndexes: number[], data: PhysicsState, options: PhysicsOptions): void;
+export declare function velocityVerlet(nodeIndexes: number[], inertia: number, data: PhysicsState, options: PhysicsOptions): number;
+export declare function attraction(alpha: number, edgeIndexes: number[], state: {
+    sources: Uint32Array;
+    targets: Uint32Array;
+    X: Float64Array | Float32Array | number[];
+    Y: Float64Array | Float32Array | number[];
+    R: Float64Array | Float32Array | number[];
+    fx: Float32Array;
+    fy: Float32Array;
+    degrees: Uint32Array;
+    masses: Float32Array;
+    weights: Float32Array;
+}, options: {
+    edgeStrength: number;
+    edgeLength: number;
+}): void;
+export {};

package/types/algorithms/force/SEC.d.ts

@@ -0,0 +1,14 @@
+export interface Circle {
+    x: number;
+    y: number;
+    r: number;
+}
+export declare function from1(x: number, y: number, r: number): Circle;
+export declare function from2(x1: number, y1: number, r1: number, x2: number, y2: number, r2: number): Circle;
+export declare function from3(x1: number, y1: number, r1: number, x2: number, y2: number, r2: number, x3: number, y3: number, r3: number): Circle;
+export declare function contains(c: Circle, x: number, y: number, r: number): boolean;
+export declare function containsWeak(c: Circle, x: number, y: number, r: number): boolean;
+export declare function containsWeakAll(c: Circle, ids: number[], getX: (i: number) => number, getY: (i: number) => number, getR: (i: number) => number): boolean;
+export declare function enclose(ids: number[], getX: (i: number) => number, getY: (i: number) => number, getR: (i: number) => number): Circle;
+export declare function shuffle<T>(array: T[]): T[];
+export declare function med(ids: number[], getX: (i: number) => number, getY: (i: number) => number, getR: (i: number) => number): Circle;

package/types/algorithms/force/Topology.d.ts

@@ -0,0 +1,3 @@
+export declare function initTopology(nodes: any[], edges: any[], data: any): void;
+export declare function decomposition(data: any): void;
+export declare function topology(nodes: any[], edges: any[], data: any): void;

package/types/algorithms/force/index.d.ts

@@ -0,0 +1,54 @@
+import { LayoutData } from './LayoutData';
+export declare enum IntegratorType {
+    verlet = 0,
+    euler = 1
+}
+export declare class Settings {
+    onUpdate: (data: any) => void;
+    update: (nodes: any[], X: ArrayLike<number>, Y: ArrayLike<number>) => void;
+    onEnd: (iterations: number) => void;
+    charge: number;
+    maxIterations: number;
+    minMovement: number;
+    edgeLength: number;
+    edgeStrength: number;
+    friction: number;
+    elasticity: number;
+    margin: number;
+    cx: number | undefined;
+    cy: number | undefined;
+    gravity: number;
+    theta: number;
+    batch: number | undefined;
+    inertia: number;
+    integrator: IntegratorType;
+    multilevel: boolean;
+    placement: string;
+    placementOffset: number;
+    alignSiblings: boolean;
+    bucketSize: number | undefined;
+    maxDisplacement: number;
+    siblingsMinAngle: number;
+    siblingsOffset: number;
+    steps: number;
+    scaling: number;
+    defaultRadius: number;
+    autoStop: any;
+    gpuAcceleration: boolean;
+    barnesHutOptimization: boolean;
+    constructor(options?: any);
+}
+export declare function force(graph: {
+    nodes: any[];
+    edges: any[];
+}, options?: any): {
+    setOptions(opts: any): /*elided*/ any;
+    setGraph(g: {
+        nodes: any[];
+        edges: any[];
+    }): /*elided*/ any;
+    start(): /*elided*/ any;
+    stop(): /*elided*/ any;
+    iterations(): any;
+    data(): LayoutData;
+};

package/types/algorithms/force-gpu/ParticleSystem.d.ts

@@ -0,0 +1,45 @@
+import { type GpuTexture } from './webgl/helpers';
+export declare function squareTextureSize(n: number, pow2?: boolean): {
+    w: number;
+    h: number;
+};
+export interface AtlasSlot {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare function packRects(rects: AtlasSlot[]): {
+    w: number;
+    h: number;
+    fill: number;
+};
+export declare function slotLocalToGlobal(i: number, totalW: number, slot: AtlasSlot): number;
+export interface SimGraph {
+    nodes: any[];
+    edges: any[];
+}
+export interface SimItem {
+    N: number;
+    E: number;
+    particlesPositionsSlot: AtlasSlot;
+    particlesChargesSlot: AtlasSlot;
+    adjacencyOffsetsSlot: AtlasSlot;
+    adjacencyListsSlot: AtlasSlot;
+    stiffnessSlot: AtlasSlot;
+    nodesExtraPropertiesSlot: AtlasSlot;
+}
+export interface SimTextures {
+    particlesPositions: () => GpuTexture;
+    particlesCharges: () => GpuTexture;
+    adjacencyOffsets: () => GpuTexture;
+    adjacencyLists: () => GpuTexture;
+    stiffness: () => GpuTexture;
+    nodesExtraProperties: () => GpuTexture;
+}
+export interface SimLayout {
+    items: SimItem[];
+    texture: SimTextures;
+}
+export declare function buildSimLayout(gl: WebGL2RenderingContext, graphs: SimGraph[]): SimLayout;
+export declare function destroySimLayout(gl: WebGL2RenderingContext, layout: SimLayout): void;

package/types/algorithms/force-gpu/Settings.d.ts

@@ -0,0 +1,60 @@
+declare const DEFAULT_AUTOSTOP_SETTINGS: {
+    duration: number;
+    alpha: number;
+};
+export declare class Settings {
+    onUpdate: (e: any) => void;
+    update: (_n: any, _x: any, _y: any) => void;
+    nextTick: (fn: () => void) => any;
+    cancelTick: (h: any) => void;
+    onEnd: (status: number) => void;
+    charge: number;
+    maxIterations: number;
+    minMovement: number;
+    edgeLength: number;
+    edgeStrength: number;
+    friction: number;
+    elasticity: number;
+    margin: number;
+    cx: number | undefined;
+    cy: number | undefined;
+    gravity: number;
+    theta: number;
+    batch: number | undefined;
+    inertia: number;
+    integrator: number;
+    multilevel: boolean;
+    placement: 'none' | 'grid' | 'circle';
+    placementOffset: number;
+    alignSiblings: boolean;
+    bucketSize: number | undefined;
+    maxDisplacement: number;
+    siblingsMinAngle: number;
+    siblingsOffset: number;
+    steps: number;
+    scaling: number;
+    defaultRadius: number;
+    autoStop: typeof DEFAULT_AUTOSTOP_SETTINGS | false;
+    gpuAcceleration: boolean;
+    barnesHutOptimization: boolean;
+    order?: number;
+    depth?: number;
+    sortingMethod?: 'ibr' | 'simple';
+    groups?: {
+        [groupId: string]: any[];
+    };
+    [key: string]: any;
+    constructor(e?: any);
+}
+export declare const GPU_DEFAULTS: {
+    readonly charge: 10;
+    readonly edgeStrength: 0.5;
+    readonly edgeLength: 30;
+    readonly elasticity: 0.9;
+    readonly margin: 1;
+    readonly gravity: 0.01;
+    readonly inertia: 0.9;
+    readonly maxDisplacement: 1000;
+    readonly steps: 200;
+};
+export {};

package/types/algorithms/force-gpu/Simulation.d.ts

@@ -0,0 +1,7 @@
+import type { SimLayout } from './ParticleSystem';
+import { type AnimationLoop } from './kernels/utils';
+import type { Settings } from './Settings';
+export interface SimulationHandle extends AnimationLoop {
+    destroy: () => void;
+}
+export declare function createSimulation(gl: WebGL2RenderingContext, layout: SimLayout, settings: Settings): SimulationHandle;

package/types/algorithms/force-gpu/getGlContext.d.ts

@@ -0,0 +1,10 @@
+export interface GlContextHandle {
+    context: WebGL2RenderingContext;
+    cleanUp: () => void;
+}
+export declare function createWebGL2Context(opts?: {
+    canvas?: HTMLCanvasElement;
+    width?: number;
+    height?: number;
+}): WebGL2RenderingContext;
+export declare function getGlContext(_kind: string, _attrs: any, onLost: (err: any) => void): GlContextHandle | null;

package/types/algorithms/force-gpu/gpuLayout.d.ts

@@ -0,0 +1,14 @@
+import { type SimGraph } from './ParticleSystem';
+export interface GpuLayoutHandle {
+    setOptions: (opts?: any) => GpuLayoutHandle;
+    setGraph: (g?: SimGraph) => GpuLayoutHandle;
+    start: () => GpuLayoutHandle;
+    stop: () => GpuLayoutHandle;
+    step: () => GpuLayoutHandle;
+    data: (cleanup?: boolean) => {
+        X: number[];
+        Y: number[];
+    };
+    iterations: () => number;
+}
+export declare function gpuLayout(graph: SimGraph, gl: WebGL2RenderingContext, opts?: any): GpuLayoutHandle;

package/types/algorithms/force-gpu/index.d.ts

@@ -0,0 +1,2 @@
+export { gpuLayout, type GpuLayoutHandle } from './gpuLayout';
+export { getGlContext, createWebGL2Context, type GlContextHandle } from './getGlContext';