vortx-gl 1.0.4 → 1.0.27

package/dist/components/DatasetSelector.d.ts

@@ -0,0 +1,19 @@
+interface Dataset {
+    id: string;
+    name: string;
+    count: string;
+    size: string;
+    file: string;
+}
+type __VLS_Props = {
+    modelValue: string;
+    datasets: Dataset[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (value: string) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((value: string) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/FPSMonitor.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/components/GraphCanvas.d.ts

@@ -0,0 +1,109 @@
+import { GraphEngine } from '../engine/renderer';
+import { NodeInput, EdgeInput, Stylesheet, RadialMenuItem } from '../engine/types';
+interface GraphData {
+    nodes: Array<{
+        data: NodeInput;
+        position?: {
+            x: number;
+            y: number;
+        };
+    }>;
+    edges: Array<{
+        data: EdgeInput;
+    }>;
+}
+type __VLS_Props = {
+    data?: GraphData;
+    theme?: "dark" | "light";
+    showUI?: boolean;
+    autoFit?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    engine: import('vue').ShallowRef<GraphEngine | null, GraphEngine | null>;
+    runLayout: (id: string) => void;
+    runStressTest: (count: number) => void;
+    toggleFlow: () => void;
+    toggleTheme: () => void;
+    fitToView: () => void | undefined;
+    zoomIn: () => void | undefined;
+    zoomOut: () => void | undefined;
+    loadDataset: (id: string) => Promise<void>;
+    addNode: (input: NodeInput) => string | number | undefined;
+    removeNode: (id: string | number) => void;
+    updateNode: (input: NodeInput) => void;
+    addEdge: (input: EdgeInput) => string | undefined;
+    removeEdge: (id: string) => void;
+    updateEdge: (input: EdgeInput) => void;
+    showAllHidden: () => void | undefined;
+    setStylesheet: (sheet: Stylesheet) => void | undefined;
+    setRadialMenu: (type: "node" | "edge" | "combo", items: RadialMenuItem[]) => void | undefined;
+    selectNode: (id: number) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "nodes-selected": (ids: number[]) => any;
+    "edge-selected": (id: string | null) => any;
+    "node-selected": (id: number | null) => any;
+    "combo-selected": (id: string | null) => any;
+    "node-moved": (detail: {
+        id: number;
+        x: number;
+        y: number;
+    }) => any;
+    "canvas-click": () => any;
+    "layout-started": (layoutId: string) => any;
+    "theme-changed": (theme: "dark" | "light") => any;
+    "dataset-loaded": (datasetId: string) => any;
+    "node-added": (node: NodeInput) => any;
+    "node-removed": (id: string | number) => any;
+    "edge-added": (edge: EdgeInput) => any;
+    "edge-removed": (id: string) => any;
+    "node-updated": (node: NodeInput) => any;
+    "edge-updated": (edge: EdgeInput) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onNodes-selected"?: ((ids: number[]) => any) | undefined;
+    "onEdge-selected"?: ((id: string | null) => any) | undefined;
+    "onNode-selected"?: ((id: number | null) => any) | undefined;
+    "onCombo-selected"?: ((id: string | null) => any) | undefined;
+    "onNode-moved"?: ((detail: {
+        id: number;
+        x: number;
+        y: number;
+    }) => any) | undefined;
+    "onCanvas-click"?: (() => any) | undefined;
+    "onLayout-started"?: ((layoutId: string) => any) | undefined;
+    "onTheme-changed"?: ((theme: "dark" | "light") => any) | undefined;
+    "onDataset-loaded"?: ((datasetId: string) => any) | undefined;
+    "onNode-added"?: ((node: NodeInput) => any) | undefined;
+    "onNode-removed"?: ((id: string | number) => any) | undefined;
+    "onEdge-added"?: ((edge: EdgeInput) => any) | undefined;
+    "onEdge-removed"?: ((id: string) => any) | undefined;
+    "onNode-updated"?: ((node: NodeInput) => any) | undefined;
+    "onEdge-updated"?: ((edge: EdgeInput) => any) | undefined;
+}>, {
+    theme: "dark" | "light";
+    showUI: boolean;
+    autoFit: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    canvasRef: HTMLCanvasElement;
+    overlayCanvasRef: HTMLCanvasElement;
+    searchBarRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        nodes: import('..').NodeData[];
+    }> & Readonly<{
+        onSelect?: ((id: number) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        select: (id: number) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        inputRef: HTMLInputElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        nodes: import('..').NodeData[];
+    }> & Readonly<{
+        onSelect?: ((id: number) => any) | undefined;
+    }>, {}, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/LayoutControls.d.ts

@@ -0,0 +1,18 @@
+export interface LayoutOption {
+    id: string;
+    name: string;
+    icon: string;
+}
+type __VLS_Props = {
+    layouts: LayoutOption[];
+    currentLayout: string;
+    flowEnabled: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    toggleFlow: () => any;
+    runLayout: (id: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggleFlow?: (() => any) | undefined;
+    onRunLayout?: ((id: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/LucideIcon.d.ts

@@ -0,0 +1,10 @@
+type __VLS_Props = {
+    name: string;
+    size?: number | string;
+    strokeWidth?: number | string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: number | string;
+    strokeWidth: number | string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, SVGSVGElement>;
+export default _default;

package/dist/components/PropertyPanel.d.ts

@@ -0,0 +1,28 @@
+import { NodeMetadata, EdgeMetadata, Combo } from '../engine/types';
+type __VLS_Props = {
+    nodeId: number | null;
+    nodeMetadata: NodeMetadata | null;
+    nodeX: number;
+    nodeY: number;
+    edgeId: string | null;
+    edgeMetadata: EdgeMetadata | null;
+    combo: Combo | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:nodeX": (val: number) => any;
+    "update:nodeY": (val: number) => any;
+    "update:nodeId": (val: number | null) => any;
+    "update:edgeId": (val: string | null) => any;
+    "update:combo": (val: Combo | null) => any;
+    "update:comboLabel": (val: string) => any;
+    removeFromCombo: (nodeId: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:nodeX"?: ((val: number) => any) | undefined;
+    "onUpdate:nodeY"?: ((val: number) => any) | undefined;
+    "onUpdate:nodeId"?: ((val: number | null) => any) | undefined;
+    "onUpdate:edgeId"?: ((val: string | null) => any) | undefined;
+    "onUpdate:combo"?: ((val: Combo | null) => any) | undefined;
+    "onUpdate:comboLabel"?: ((val: string) => any) | undefined;
+    onRemoveFromCombo?: ((nodeId: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/RadialMenu.d.ts

@@ -0,0 +1,33 @@
+export interface MenuItem {
+    label: string;
+    icon: string;
+    action: string;
+}
+type __VLS_Props = {
+    show: boolean;
+    x: number;
+    y: number;
+    type: string;
+    items: MenuItem[];
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        center?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    action: (action: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAction?: ((action: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SearchBar.d.ts

@@ -0,0 +1,12 @@
+import { NodeData } from '../engine/types';
+type __VLS_Props = {
+    nodes: NodeData[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    select: (id: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((id: number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/ViewControls.d.ts

@@ -0,0 +1,18 @@
+type __VLS_Props = {
+    theme: "dark" | "light";
+    flowEnabled: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    toggleTheme: () => any;
+    fit: () => any;
+    zoomIn: () => any;
+    zoomOut: () => any;
+    toggleFlow: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onToggleTheme?: (() => any) | undefined;
+    onFit?: (() => any) | undefined;
+    onZoomIn?: (() => any) | undefined;
+    onZoomOut?: (() => any) | undefined;
+    onToggleFlow?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/engine/Minimap.d.ts

@@ -0,0 +1,25 @@
+import { GraphEngine } from './renderer';
+/**
+ * Renders an aerial-view minimap of the graph into its own canvas.
+ *
+ * ```ts
+ * const minimap = new Minimap(engine, canvas);
+ * minimap.start();
+ * // …
+ * minimap.destroy();
+ * ```
+ */
+export declare class Minimap {
+    private engine;
+    private canvas;
+    private ctx;
+    private intervalId;
+    private intervalMs;
+    constructor(engine: GraphEngine, canvas: HTMLCanvasElement, intervalMs?: number);
+    /** Begin periodic redraw. Returns a cleanup function for symmetry with addEventListener. */
+    start(): () => void;
+    /** Stop redraws and release the interval handle. Safe to call multiple times. */
+    destroy(): void;
+    /** Force an immediate redraw. Useful after a fitView or dataset swap. */
+    draw(): void;
+}

package/dist/engine/api/adapter.d.ts

@@ -0,0 +1,35 @@
+import { NodeInput, EdgeInput } from '../types';
+import { BackendGraphData, BackendNodeElement, BackendEdgeElement } from './types';
+/**
+ * Map a backend node to the renderer's NodeInput.
+ *
+ * Fields with first-class renderer support — `colorOnSelect`, `groupCount` —
+ * are lifted to top-level inputs. Fields the renderer doesn't know about
+ * (iri, codeValue, parentConcept, …) ride along on `data` so consumers can
+ * still read them back via `getAllNodes()`.
+ *
+ * `backgroundImage` is a server-resolved URL (or `data:` base64) and is passed
+ * straight through as the renderer's `image`.
+ */
+export declare const adaptNode: (element: BackendNodeElement) => NodeInput;
+/**
+ * Map a backend edge to the renderer's EdgeInput.
+ *
+ * Backend `classes` is a bare string ("edges") — we normalize to an array so
+ * downstream code can treat node and edge classes uniformly. Selection-time
+ * styling (`colorOnSelect`, `widthOnSelect`) is lifted to first-class inputs.
+ */
+export declare const adaptEdge: (element: BackendEdgeElement) => EdgeInput;
+/**
+ * Adapt a full backend payload into the renderer's input shape.
+ *
+ * ```ts
+ * const { nodes, edges } = adaptGraphData(apiResponse);
+ * nodes.forEach((n) => engine.addNode(n));
+ * edges.forEach((e) => engine.addEdge(e));
+ * ```
+ */
+export declare const adaptGraphData: (data: BackendGraphData) => {
+    nodes: NodeInput[];
+    edges: EdgeInput[];
+};

package/dist/engine/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './adapter';

package/dist/engine/api/types.d.ts

@@ -0,0 +1,86 @@
+/** Discriminator on `NodeElement.classes` — drives the rendering style. */
+export type NodeClass = "nodes" | "nodeGroup";
+/** Discriminator on `EdgeElement.classes` — backend currently emits a bare string here, not an array. */
+export type EdgeClass = "edges";
+/** Stable category tag carried on every node — useful for filtering/grouping. */
+export type CodeValue = "SID-ACC" | "SN-PST" | "SN-CMNT" | "TAG" | "WWW" | (string & {});
+/**
+ * Backend node payload.
+ *
+ * `hidden` is typed as boolean here to match the consumer's existing `IGraph.ts`.
+ * The original spec described it as the string `'true'|'false'`; if the API
+ * actually emits strings, normalize at the network boundary (not here).
+ */
+export interface BackendNodeData {
+    /** Numeric node id used as the join key for edges. */
+    id: number;
+    iri: string;
+    label: string;
+    shownValue: string;
+    displayName: string;
+    /** Current fill — may have been overridden from `defaultColor` (e.g. highlight assignment). */
+    color: string;
+    /** Base fill when not highlighted. */
+    defaultColor: string;
+    /** Fill swap applied on select — NOT the selection ring color. */
+    colorOnSelect: string;
+    hidden: boolean;
+    deletable: boolean;
+    parentConcept: string;
+    /**
+     * Server-resolved icon URL. Can be a CDN path, a proxy endpoint, or an inline
+     * `data:` base64 payload — the renderer treats it as an opaque image source.
+     */
+    backgroundImage: string;
+    /** Diameter in CSS pixels (consistently 50 in observed data). */
+    width: number;
+    height: number;
+    codeValue: CodeValue;
+    geolocations: unknown[];
+    /** Group UUID — present when this node represents a collapsed cluster (`classes: ['nodeGroup']`). */
+    group?: string;
+    /** Number of nodes collapsed into this group. */
+    groupCount?: number;
+}
+export interface BackendNodeElement {
+    data: BackendNodeData;
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Style discriminator — array form (single class today: `['nodes']` or `['nodeGroup']`). */
+    classes: NodeClass[];
+}
+/**
+ * Backend edge payload.
+ *
+ * `width` encodes group size visually: 1 = single, 5-7/12/15 = bundled. The real
+ * count is `ids.length`. `label` already contains the human-readable count when
+ * bundled (e.g. `"Follows (24)"`) — render as-is, don't reparse.
+ */
+export interface BackendEdgeData {
+    id: string;
+    iri: string;
+    label: string;
+    source: number;
+    target: number;
+    color: string;
+    defaultColor: string;
+    colorOnSelect: string;
+    hidden: boolean;
+    /** Edge line style. Backend defaults to "solid"; resolver supports "dashed"/"dotted" too. */
+    style?: "solid" | "dashed" | "dotted";
+    width: number;
+    widthOnSelect: number;
+    /** Real edge ids bundled into this visual edge. `ids.length === 1` for un-grouped. */
+    ids: string[];
+}
+export interface BackendEdgeElement {
+    data: BackendEdgeData;
+    /** Style discriminator — backend emits a bare string, not an array (contrast with nodes). */
+    classes: EdgeClass;
+}
+export interface BackendGraphData {
+    nodes: BackendNodeElement[];
+    edges: BackendEdgeElement[];
+}

package/dist/engine/config.d.ts

@@ -0,0 +1,117 @@
+export declare const GraphConfig: {
+    readonly zoom: {
+        /** Edge labels need a readable run of pixels between endpoints, and the
+         * label text is a fixed ~18 px CSS — only show once nodes are large
+         * enough that labels don't dwarf them. zoom 0.5 → pointSize ≈ 25 px. */
+        readonly hideEdgeLabelsBelow: 0.5;
+        /** Same logic for node labels. Fixed-size labels look oversized when the
+         * node beside them is smaller than the label glyph height. */
+        readonly hideNodeLabelsBelow: 0.5;
+        /** Arrow heads are small triangles — illegible below ~11 px nodes. */
+        readonly hideArrowsBelow: 0.15;
+        /** Count badge + expand button anchor on the node; need ~21 px node. */
+        readonly hideBadgesBelow: 0.4;
+        /** Below this, GPU edge pass may fall back to gl.LINES on big graphs. */
+        readonly simplifyEdgesBelow: 0.15;
+        /** Below this the per-edge/per-node text+arrow block is skipped entirely. */
+        readonly fullStyleBelow: 0.05;
+        readonly sensitivity: 1.2;
+        readonly fitOnLoad: true;
+    };
+    readonly performance: {
+        readonly lodNodeThreshold: 2000;
+        readonly edgeCullThreshold: 5000;
+        readonly instanceBatchSize: 512;
+        readonly viewportCullMargin: 100;
+        readonly targetFPS: 60;
+        readonly fullStyleRange: 1500;
+        readonly smallGraphThreshold: 3000;
+        readonly maxLabelsPerFrame: 800;
+    };
+    readonly interaction: {
+        readonly panInertia: true;
+        readonly panDecay: 0.88;
+        readonly dragMode: "single";
+        readonly selectionMode: "additive";
+        readonly contextMenu: true;
+        readonly hoverThrottleMs: 32;
+        readonly zoomSettleMs: 120;
+        readonly longPressMs: 500;
+        readonly tapTimeMs: 250;
+        readonly tapDistancePx: 10;
+    };
+    readonly style: {
+        readonly selectionRingColor: "#4A9EFF";
+        readonly selectionRingWidthPx: 3;
+        readonly selectionRingRadiusFactor: 1.1;
+        readonly nodeGroupBadgeRadiusPx: 10;
+        readonly nodeGroupBadgeFill: "#76ABE7";
+        readonly nodeGroupBadgeText: "#ffffff";
+        readonly nodeGroupBadgeTextPx: 10;
+        readonly nodeGroupStackShadowOffsets: readonly number[];
+        readonly nodeGroupStackShadowOpacity: 0.2;
+        readonly nodeExpandButtonRadiusPx: 10;
+        readonly nodeExpandButtonFill: "#1a1a1a";
+        readonly nodeExpandButtonIcon: "#ffffff";
+        readonly nodeExpandButtonIconPx: 12;
+        readonly nodeShape: "circle";
+        readonly edgeStyle: "bezier";
+        readonly labelFontSize: 11;
+        readonly iconMode: "canvas";
+        /** CSS pixels of inset between the icon and the node's outer border. */
+        readonly nodeIconPaddingPx: 4;
+        readonly minimap: true;
+        readonly background: "#f5f5f5";
+        readonly minimapIntervalMs: 500;
+        /**
+         * When a selected node is outside the viewport, draw a small dot + arrow
+         * stub at the canvas edge pointing toward it. Useful on small graphs;
+         * noisy on large multi-selections (one indicator per off-screen
+         * selected node). Set false to suppress.
+         */
+        readonly showOffscreenSelectionIndicator: true;
+    };
+    readonly graphOptions: {
+        /** Cytoscape: text-opacity 1 vs 0 on `.nodes`. */
+        readonly showEntityLabel: true;
+        /** Cytoscape: text-opacity 1 vs 0 on `edges`. */
+        readonly showEdgeLabel: true;
+        /** Cytoscape: background-image set vs 'none' on `.nodes`. */
+        readonly showEntityIcon: true;
+        /** Cytoscape: bypasses the icon atlas — solid fill only. */
+        readonly showEntityPlainColor: false;
+        /** Cytoscape: data(<field>) inside the label mapper — pick the field. */
+        readonly entityLabel: "shownValue";
+    };
+};
+export type GraphConfigType = typeof GraphConfig;
+/** Recursively make every field of an object optional. */
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends ReadonlyArray<infer _U> ? T[K] : T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
+export type PartialGraphConfig = DeepPartial<GraphConfigType>;
+export type ResolvedGraphConfig = {
+    zoom: {
+        [K in keyof GraphConfigType["zoom"]]: GraphConfigType["zoom"][K];
+    };
+    performance: {
+        [K in keyof GraphConfigType["performance"]]: GraphConfigType["performance"][K];
+    };
+    interaction: {
+        [K in keyof GraphConfigType["interaction"]]: GraphConfigType["interaction"][K];
+    };
+    style: {
+        [K in keyof GraphConfigType["style"]]: GraphConfigType["style"][K];
+    };
+    graphOptions: {
+        [K in keyof GraphConfigType["graphOptions"]]: GraphConfigType["graphOptions"][K];
+    };
+};
+/**
+ * Public shape of the graphOptions section — exported so consumers can build
+ * a typed override before passing to createGraphRenderer or recomputeStyles.
+ *
+ * // STYLE: matches the Cytoscape `defaultOptions` bag 1:1.
+ */
+export type GraphOptions = ResolvedGraphConfig["graphOptions"];
+export declare function resolveConfig(overrides?: PartialGraphConfig): ResolvedGraphConfig;

package/dist/engine/core/Camera.d.ts

@@ -0,0 +1,34 @@
+import { mat3, vec2 } from 'gl-matrix';
+import { EngineContext } from './context';
+export declare class Camera {
+    viewMatrix: mat3;
+    private static readonly MAX_ZOOM;
+    private static readonly MIN_ZOOM;
+    private _invMatrix;
+    private _posScratch;
+    private ctx;
+    constructor(ctx: EngineContext);
+    get zoom(): number;
+    get offset(): vec2;
+    updateMatrix(): void;
+    unproject(screenX: number, screenY: number): vec2;
+    fitToView(): void;
+    fitGroupToView(groupId: string): void;
+    calculateFit(minX: number, minY: number, maxX: number, maxY: number): {
+        zoom: number;
+        offset: vec2;
+    };
+    private _performFit;
+    zoomIn(): void;
+    zoomOut(): void;
+    setCenter(x: number, y: number): void;
+    setZoom(zoom: number): void;
+    zoomAt(mouseX: number, mouseY: number, delta: number): void;
+    pan(dx: number, dy: number): void;
+    getViewportWorldBounds(): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+}

package/dist/engine/core/ComboStore.d.ts

@@ -0,0 +1,23 @@
+import { EngineContext } from './context';
+import { Combo } from '../types';
+export declare class ComboStore {
+    combos: Map<string, Combo>;
+    private representativeToCombo;
+    private nodeToCombo;
+    private ctx;
+    constructor(ctx: EngineContext);
+    createGroup(id: string, label: string, nodeIds: (string | number)[]): void;
+    removeGroup(id: string): void;
+    addToGroup(groupId: string, nodeId: string | number): void;
+    removeFromGroup(groupId: string, nodeId: string | number): void;
+    getComboByRepresentative(id: number): string | null;
+    toggleComboCollapse(groupId: string): void;
+    moveGroup(groupId: string, dx: number, dy: number, skipSync?: boolean): void;
+    calculateBounds(groupId: string): void;
+    findNodeGroup(nodeId: string | number): string | null;
+    getAllGroups(): {
+        id: string;
+        label: string;
+        nodeIds: (string | number)[];
+    }[];
+}

package/dist/engine/core/EdgeStore.d.ts

@@ -0,0 +1,37 @@
+import { EngineContext } from './context';
+import { EdgeMetadata, EdgeInput, EdgeData } from '../types';
+export declare class EdgeStore {
+    list: Array<{
+        id: string;
+        u: number;
+        v: number;
+        metadata: EdgeMetadata;
+    }>;
+    idMap: Map<string, number>;
+    indexToUserIdMap: Map<string, string>;
+    indexToId: string[];
+    metadata: Map<string, EdgeMetadata>;
+    hiddenEdges: Set<string>;
+    indices: Uint32Array | null;
+    count: number;
+    hasCustomEdges: boolean;
+    hasEdgeLabels: boolean;
+    private _customEdgeCount;
+    private _labeledEdgeCount;
+    _bulkMode: boolean;
+    private autoEdgeId;
+    private ctx;
+    constructor(ctx: EngineContext);
+    addEdge(input: EdgeInput): string;
+    bulkAddEdges(inputs: ReadonlyArray<EdgeInput>): void;
+    updateEdge(input: EdgeInput): void;
+    removeEdge(edgeId: string): void;
+    removeAllConnected(nodeIndex: number): void;
+    remapNodeIndex(oldIndex: number, newIndex: number): void;
+    resetFlags(): void;
+    rebuildEdgeBuffer(): void;
+    private calculateCurvatures;
+    rebuildIndexToUserIdMap(): void;
+    private _removeEdgeInternal;
+    getAllEdges(): EdgeData[];
+}

package/dist/engine/core/NodeStore.d.ts

@@ -0,0 +1,34 @@
+import { EngineContext } from './context';
+import { NodeMetadata, NodeInput, NodeData, Stylesheet, GraphStyle } from '../types';
+export declare class NodeStore {
+    count: number;
+    capacity: number;
+    positions: Float32Array | null;
+    colorData: Float32Array;
+    idData: Float32Array;
+    shapeData: Float32Array;
+    sizeData: Float32Array;
+    nodeIdMap: Map<string | number, number>;
+    reverseIdMap: Map<number, string | number>;
+    metadata: Map<number, NodeMetadata>;
+    lockedNodes: Set<number>;
+    hiddenNodes: Set<number>;
+    hasGroupNodes: boolean;
+    _bulkMode: boolean;
+    private autoNodeId;
+    private stylesheet;
+    private ctx;
+    constructor(ctx: EngineContext);
+    setStylesheet(sheet: Stylesheet): void;
+    resolveStyle(classes?: string[]): GraphStyle;
+    resolveNodeIndex(nodeId: string | number): number | null;
+    ensureCapacity(minCount: number): void;
+    addNode(input: NodeInput): string | number;
+    bulkAddNodes(inputs: ReadonlyArray<NodeInput>): void;
+    updateNode(input: NodeInput): void;
+    removeNode(nodeId: string | number): void;
+    getAllNodes(): NodeData[];
+    parseColor(color?: string | [number, number, number, number?]): [number, number, number, number];
+    private loadNodeImage;
+    private mapShapeToId;
+}