@kortexya/nodus 0.1.0

package/types/internals/renderingBinaryPrimitives.d.ts

@@ -0,0 +1,110 @@
+import { getCurrentTime, getPixelRatio, resizeElement } from './helpers';
+export { getCurrentTime, getPixelRatio, resizeElement };
+export declare const noop: () => void;
+export declare function $warn(...args: any[]): void;
+export declare function applyCursorStyle(el: any, style: any): void;
+export declare function smartRequire(moduleName: string): any;
+export declare class Map2 {
+    private _map;
+    reset(): void;
+    set(a: any, b: any, value: any): void;
+    get(a: any, b: any): any;
+}
+export declare function createDummyDomElement(): any;
+export declare function setElementSize(el: any, width: string, height: string): void;
+export declare function nextPowerOfTwo(value: number): number;
+export declare function parseColor(value: any): number[] | null;
+export declare function createCanvas(width?: number, height?: number): HTMLCanvasElement;
+export declare function getWebglContext(canvas: HTMLCanvasElement, options: any, contextType: string): any;
+export declare const WEBGL_AVAILABLE: boolean;
+export declare const GL_OPTIONS: {
+    stencil: boolean;
+    antialias: boolean;
+    alpha: boolean;
+    premultipliedAlpha: boolean;
+    failIfMajorPerformanceCaveat: boolean;
+};
+export declare const SHAPE_TEXTURES_GL_START_UNIT = 0;
+export declare const PATTERN_TEXTURES_GL_START_UNIT = 1;
+export declare const CODE_TO_MESSAGE: Record<string, string>;
+export declare class ImageManager {
+    private _images;
+    private _crossOrigin;
+    private _whenReady;
+    private _onFetch;
+    private _nbLoaded;
+    private _nbToLoad;
+    setImgCrossOrigin(value: any): void;
+    clear(): void;
+    getImage(src: string): any;
+    private _onImgLoad;
+    onFetch(callback: (src: string) => void): void;
+    whenReady(): Promise<void>;
+    destroy(): void;
+}
+export declare class FontManager {
+    private _fontFaceSet;
+    private _fonts;
+    private _onFontLoaded;
+    private _hideUntilFontsLoaded;
+    setHideUntilFontsLoaded(value: boolean): void;
+    getFont(fontName: string): string | null;
+    onFontLoaded(callback: (fontName: string) => void): void;
+    destroy(): void;
+    private _triggerFontLoaded;
+}
+export declare function getRTLProcessors(): {
+    processBidirectionalText: (text: any) => any;
+    applyArabicShaping: (text: any) => any;
+};
+export declare function computeMaxSize(graph: any): number;
+export declare function formatRendererName(type: any): string;
+export declare function formatOptions(value: any): {
+    duration: number;
+    easing: any;
+    chain: boolean;
+};
+export declare function setAllVisible(graph: any): any;
+export declare function restoreVisibility({ nodes, edges }: any): void;
+export declare function isNodeBuffer(buffer: any): boolean;
+export declare function isTextBuffer(buffer: any): boolean;
+declare class EasingManager {
+    private _linearEasing;
+    private _nameToPolygon;
+    private _polygonToName;
+    constructor();
+    add(polygons: Record<string, number[]>): void;
+    getCoefficients(name: string): number[];
+    getName(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): string;
+}
+export declare const easingManager: EasingManager;
+export declare const DEFAULT_IMG_CROSS_ORIGIN = "anonymous";
+export declare const DEFAULT_BACKGROUND_COLOR = "white";
+export declare const DEFAULT_CURSOR_STYLE = "default";
+export declare const GRAPHICS_ENGINE_BASE_PARAMETERS: {
+    maxBlockId: number;
+    maxCoord: number;
+    maxScaledSize: number;
+    maxPixelSize: number;
+    maxMinVisibleSize: number;
+    maxDashOffset: number;
+    maxDashLength: number;
+    maxGapLength: number;
+    maxSymbolicSize: number;
+    maxPatternScale: number;
+};
+export declare const DEFAULT_RENDERER: string | null;
+export declare const DEFAULT_CORNER_RADIUS = 5;
+export declare const DEFAULT_EDGE_ARROW_SIZE_RATIO = 3;
+export declare const MIN_EDGE_TIP_SIZE = 3;
+export declare const NB_BLOCK_PER_INDEX = 10;
+export declare const MISC_BLOCK_ID_OFFSET = 9;
+export declare const VISIBLE_TAG = "_visible";
+export declare const DATA_TAG = "_data";
+export declare const EXPORT_CLASS = "_export";
+export declare const NULL_COLOR: number[];
+export declare const ELEMENT_BYTESIZE = 56;
+export declare const ELT_TEXT = 2;
+export declare const PATTERN_TEXT_OPT = 7;
+export declare const CURVE_SUBDIVISIONS = 41;
+export declare const PATTERN_UNIT_SIZE = 16;

package/types/internals/utilsExports.d.ts

@@ -0,0 +1,408 @@
+/**
+ * Barrel module that gathers Nodus's shared utility functions into a single
+ * `utils` namespace.
+ *
+ * Helpers defined elsewhere are re-exported from their source modules; the
+ * remaining helpers are implemented inline below.
+ */
+import { isArray, toArray, flattenArray, removeFromArray, isInteger, throttle } from '../utils';
+import { flatten, unflatten, setProperty, getProperty, requestAnimFrame, cancelAnimFrame, getCurrentTime, getPixelRatio, resizeElement, getStyle, forEach, getDocument, getResizeObserver } from './helpers';
+import { Map2, parseColor, createCanvas, getWebglContext, applyCursorStyle, smartRequire, nextPowerOfTwo, createDummyDomElement, setElementSize } from './renderingBinaryPrimitives';
+import { FlexArray } from './FlexArray';
+import { IndexList } from './IndexList';
+import { BoundingBox } from '../geometry/BoundingBox';
+import { PrioritySet } from './AlgorithmsPrimitives';
+import { ElementSet } from './ElementSet';
+import { createSvgElement } from './LayersPrimitives';
+import { ensureTransferable } from '../algorithms/forceFactory';
+import { formatAngle } from './labels/helpers';
+import { getValues, isRawObject } from './MappingPrimitives';
+import { isHTMLElement } from './TooltipPrimitives';
+/**
+ * Collects the dotted key paths of every leaf value in an object.
+ *
+ * Uses the narrow `isObject` (constructor check) so that FlexArray instances are
+ * treated as leaf values rather than recursed into. This is critical: the variant
+ * in AttributePathPrimitives.ts uses a broader check (`typeof value === 'object'`)
+ * that would incorrectly recurse into FlexArray internals.
+ */
+export declare function getFlattenedKeys(obj: any, prefix?: string, out?: string[]): string[];
+export declare const SVG_NS = "http://www.w3.org/2000/svg";
+export declare const XML_NS = "http://www.w3.org/2000/xmlns/";
+export declare const XLINK = "http://www.w3.org/1999/xlink";
+export declare function insertSortAsc(arr: any[], scores: {
+    get(id: any): number;
+}): any[];
+export declare function insertSortDesc(arr: any[], scores: {
+    get(id: any): number;
+}): any[];
+export declare function concatenateArrays(...arrays: any[]): any[];
+export declare function binaryIndexOf(arr: number[], target: number): number;
+export declare function propertyPathToString(path: string | string[]): string;
+export declare function toPropertyPath(path: any): string[];
+export declare function lightDebounce(fn: () => void, delay: number): () => void;
+export declare function debounce(fn: (...args: any[]) => any, wait?: number, immediate?: boolean): ((...args: any[]) => any) & {
+    clear(): void;
+    flush(): void;
+};
+export declare function processQueue(items: any[], handler: (...args: any[]) => Promise<any>): Promise<any>;
+export declare function isLittleEndian(): boolean;
+export declare function promiseQueue(fns: Array<() => Promise<any>>): Promise<any>;
+export declare function hash8(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number): number;
+export declare function unorderedHash(a: number, b: number): number;
+export declare function deepCopy<T>(value: T): T;
+export declare function extendList(target: any[], items: any[]): void;
+export declare function traverse(obj: any, callback: (value: any) => void): void;
+export declare function indexByName(obj: any): Record<string, any>;
+export declare function getLeafValues(obj: any, result?: any[]): any[];
+export declare function getOptions(value: any, defaults: any): any;
+export declare function isObject(value: any): boolean;
+export declare function mergeValues(target: any, source: any): any;
+export declare function pick(obj: any, keys: string[] | null | undefined): any;
+export declare const merge: (...objects: any[]) => any;
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function mix(a: number, b: number, t: number): number;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function computeMax(arr: number[]): number;
+export declare function computeMin(arr: number[]): number;
+export declare const getBaseLog: (value: number, base: number) => number;
+export declare function mapKeys(map: Map<any, any>): any[];
+export declare function mapValues(map: Map<any, any>): any[];
+export declare const setKeys: (set: Set<any>) => any[];
+export declare const setValues: (set: Set<any>) => any[];
+export declare function parseColorRgba(value: string, out?: number[]): number[] | null;
+export declare function formatHex(n: number): string;
+export declare function componentsToRGBA([r, g, b, a]: number[]): string;
+export declare function parseColorHex(value: string): number[] | null;
+export declare const toHexa: (color: any) => string | null;
+export declare const rgbaToRgb: (color: string) => {
+    color: string;
+    opacity: number;
+};
+export declare function getDate(): string;
+export declare function getTime(): string;
+export declare function setAttributes(el: any, attrs: any): void;
+export declare function createElement(html: string): any;
+export declare function createTextNode(text: string): any;
+export declare function baseURI(doc: any): string;
+export declare function escapeDOMAttribute(value: any, escapeNewlines?: boolean): string;
+export declare function fadeElement(el: HTMLElement, from: number, to: number, duration: number): Promise<void>;
+export declare function createBlob(data: any, type: string): any;
+export declare function isBlob(value: any): boolean;
+export declare function dataUrlToBlob(dataUrl: string): any;
+export declare function promptDownload(data: any, filename: string, format?: string, mimeType?: string): any;
+export declare function getImage(src: string): Promise<HTMLImageElement | null>;
+export declare function clearCanvas(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, width?: number, height?: number): void;
+export declare function setCtxFont(ctx: CanvasRenderingContext2D, fontFamily: string, fontSize: number, fontStyle?: string): void;
+export declare function isWebGLSupported(): boolean;
+export declare const createWebGL2Context: (options?: any) => WebGL2RenderingContext;
+export declare const getGlContext: (_options: any, _onSuccess: any, onError: (err: Error) => void) => {
+    context: WebGL2RenderingContext;
+    cleanUp: () => void;
+} | null;
+export declare function displayPixelsOnScreen(pixels: Uint8Array | Uint8ClampedArray, width?: number, height?: number, delay?: number): void;
+export declare class DummyXHR {
+    method: string | null;
+    url: string | null;
+    status: number;
+    readyState: number;
+    headers: Record<string, string>;
+    responseText: string | null;
+    response: any;
+    responseType?: string;
+    onreadystatechange: () => void;
+    onerror: (e?: any) => void;
+    static onCreate: ((xhr: DummyXHR) => void) | null;
+    static onSend: ((xhr: DummyXHR) => void) | null;
+    constructor();
+    open(method: string, url: string): void;
+    respond(status: number, headers: Record<string, string>, body: string): void;
+    send(): void;
+}
+export declare class DummyFileReader {
+    onload: (() => void) | null;
+    result: any;
+    private _blob;
+    static onCreate: ((reader: DummyFileReader) => void) | null;
+    static onRead: ((reader: DummyFileReader) => void) | null;
+    constructor();
+    readAsDataURL(blob: any): void;
+    load(data: any): void;
+}
+export declare function fetchBinary(url: string): Promise<Blob>;
+export declare function fetchBinaryAsBase64(url: string): Promise<string>;
+export declare function ensureRequireInitialized(): Promise<void>;
+export declare const workerIsAvailable: boolean;
+export declare function formatWorkerMessage(data: any): any;
+export declare function createWorker(factory: any): Worker;
+export declare class DummyTextNode {
+    private _text;
+    constructor(text: string);
+    serialize(): string;
+    cloneNode(): DummyTextNode;
+}
+export declare const createDummyXmlDocument: () => any;
+export declare function serializeXMLDocument(doc: any): string | undefined;
+export declare const createXmlDocument: () => any;
+export declare function resolvePath(url: string, base: string): string;
+export declare function getDocumentFontRules(): Promise<Array<{
+    name: string;
+    formats: any[];
+    originalRule: string;
+}>>;
+export declare function getEmbeddedFontRules(fontRules: Array<{
+    formats: Array<{
+        format: string;
+        url: string;
+    }>;
+    originalRule: string;
+}>, embedFonts: boolean): Promise<string[]>;
+export declare function fontSizeToBadgeScale(fontSize: number, nodeSize: number, halfScale?: number): number;
+export declare class PathMap {
+    private _keys;
+    private _values;
+    private _size;
+    private _cachedPath;
+    private _cachedIndex;
+    get size(): number;
+    set(path: any[], value: any): void;
+    get(path: any[]): any;
+    has(path: any[]): boolean;
+    keys(): any[][];
+    private _getIndex;
+}
+export declare function objToValueList(obj: any, result?: Array<{
+    path: string[];
+    value: any;
+}>, currentPath?: string[]): Array<{
+    path: string[];
+    value: any;
+}> | undefined;
+export declare class DummyDomElement {
+    onmousewheel: () => void;
+    __dummy: boolean;
+    style: any;
+    clientWidth: number;
+    clientHeight: number;
+    childNodes: any[];
+    get offsetWidth(): number;
+    get offsetHeight(): number;
+    get firstChild(): any;
+    get parentNode(): any;
+    get classList(): any;
+    get innerHTML(): string;
+    set innerHTML(_value: string);
+    appendChild(child: any): any;
+    removeChild(): void;
+    addEventListener(): void;
+    removeEventListener(): void;
+    insertBefore(): void;
+    contains(): boolean;
+}
+export declare class DummyCanvasRenderingContext2D {
+    private _fontSize;
+    set font(value: string);
+    set fillStyle(_value: string);
+    set textBaseline(_value: string);
+    set textAlign(_value: string);
+    set strokeStyle(_value: string);
+    set lineWidth(_value: number);
+    fill(): void;
+    stroke(): void;
+    clearRect(): void;
+    fillRect(): void;
+    strokeRect(): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(): void;
+    lineTo(): void;
+    rect(): void;
+    arc(): void;
+    save(): void;
+    restore(): void;
+    clip(): void;
+    translate(): void;
+    rotate(): void;
+    fillText(): void;
+    setLineDash(): void;
+    quadraticCurveTo(): void;
+    bezierCurveTo(): void;
+    drawImage(): void;
+    measureText(text: string): {
+        width: number;
+    };
+    getImageData(): {
+        width: number;
+        height: number;
+        data: Uint8ClampedArray;
+    };
+}
+export declare class DummyCanvas {
+    style: any;
+    width: number;
+    height: number;
+    __context: DummyCanvasRenderingContext2D;
+    get __dummy(): boolean;
+    get parentNode(): any;
+    getContext(type: string): any;
+    toDataURL(format?: string): string;
+    addEventListener(): void;
+    removeEventListener(): void;
+    getBoundingClientRect(): {
+        left: number;
+        top: number;
+        bottom: number;
+        right: number;
+        width: number;
+        height: number;
+    };
+}
+export declare class EventTarget {
+    private _events;
+    on(event: string, handler: (...args: any[]) => void): this;
+    off(event: string, handler?: (...args: any[]) => void): this;
+    fire(event: string, ...args: any[]): this;
+    once(event: string, handler: (...args: any[]) => void): this;
+    hasListener(event: string, handler: (...args: any[]) => void): boolean;
+    clearEvents(): void;
+    getListeners(event: string): any[] | null | undefined;
+}
+export declare const utils: {
+    BUTTON_MAPPING: Record<number, "left" | "middle" | "right">;
+    BoundingBox: typeof BoundingBox;
+    DummyCanvas: typeof DummyCanvas;
+    DummyCanvasRenderingContext2D: typeof DummyCanvasRenderingContext2D;
+    DummyDomElement: typeof DummyDomElement;
+    DummyFileReader: typeof DummyFileReader;
+    DummyTextNode: typeof DummyTextNode;
+    DummyXHR: typeof DummyXHR;
+    ElementSet: typeof ElementSet;
+    EventTarget: typeof EventTarget;
+    FlexArray: typeof FlexArray;
+    IndexList: typeof IndexList;
+    MOUSE_WHEEL_THROTTLE: number;
+    Map2: typeof Map2;
+    PathMap: typeof PathMap;
+    PrioritySet: typeof PrioritySet;
+    SVG_NS: string;
+    XLINK: string;
+    XML_NS: string;
+    applyCursorStyle: typeof applyCursorStyle;
+    baseURI: typeof baseURI;
+    binaryIndexOf: typeof binaryIndexOf;
+    cancelAnimFrame: typeof cancelAnimFrame;
+    clamp: typeof clamp;
+    clearCanvas: typeof clearCanvas;
+    componentsToRGBA: typeof componentsToRGBA;
+    computeMax: typeof computeMax;
+    computeMin: typeof computeMin;
+    concatenateArrays: typeof concatenateArrays;
+    createBlob: typeof createBlob;
+    createCanvas: typeof createCanvas;
+    createDummyDomElement: typeof createDummyDomElement;
+    createDummyXmlDocument: () => any;
+    createElement: typeof createElement;
+    createSvgElement: typeof createSvgElement;
+    createTextNode: typeof createTextNode;
+    createWebGL2Context: (options?: any) => WebGL2RenderingContext;
+    createWorker: typeof createWorker;
+    createXmlDocument: () => any;
+    dataUrlToBlob: typeof dataUrlToBlob;
+    debounce: typeof debounce;
+    deepCopy: typeof deepCopy;
+    displayPixelsOnScreen: typeof displayPixelsOnScreen;
+    ensureRequireInitialized: typeof ensureRequireInitialized;
+    ensureTransferable: typeof ensureTransferable;
+    escapeDOMAttribute: typeof escapeDOMAttribute;
+    extendList: typeof extendList;
+    fadeElement: typeof fadeElement;
+    fetch: (url: string) => Promise<string>;
+    fetchBinary: typeof fetchBinary;
+    fetchBinaryAsBase64: typeof fetchBinaryAsBase64;
+    flatten: typeof flatten;
+    flattenArray: typeof flattenArray;
+    fontSizeToBadgeScale: typeof fontSizeToBadgeScale;
+    forEach: typeof forEach;
+    formatAngle: typeof formatAngle;
+    formatHex: typeof formatHex;
+    formatWorkerMessage: typeof formatWorkerMessage;
+    getBaseLog: (value: number, base: number) => number;
+    getCurrentTime: typeof getCurrentTime;
+    getDate: typeof getDate;
+    getDocument: typeof getDocument;
+    getDocumentFontRules: typeof getDocumentFontRules;
+    getEmbeddedFontRules: typeof getEmbeddedFontRules;
+    getFlattenedKeys: typeof getFlattenedKeys;
+    getGlContext: (_options: any, _onSuccess: any, onError: (err: Error) => void) => {
+        context: WebGL2RenderingContext;
+        cleanUp: () => void;
+    } | null;
+    getImage: typeof getImage;
+    getLeafValues: typeof getLeafValues;
+    getOptions: typeof getOptions;
+    getPixelRatio: typeof getPixelRatio;
+    getProperty: typeof getProperty;
+    getResizeObserver: typeof getResizeObserver;
+    getStyle: typeof getStyle;
+    getTime: typeof getTime;
+    getValues: typeof getValues;
+    getWebglContext: typeof getWebglContext;
+    hash8: typeof hash8;
+    htmlSanitizer: {
+        sanitize: (html: string) => string;
+    };
+    indexArrayToArray: <T>(indices: ArrayLike<number>, data: T[]) => T[];
+    indexByName: typeof indexByName;
+    insertSortAsc: typeof insertSortAsc;
+    insertSortDesc: typeof insertSortDesc;
+    isArray: typeof isArray;
+    isBlob: typeof isBlob;
+    isHTMLElement: typeof isHTMLElement;
+    isInteger: typeof isInteger;
+    isLittleEndian: typeof isLittleEndian;
+    isObject: typeof isObject;
+    isRawObject: typeof isRawObject;
+    isWebGLSupported: typeof isWebGLSupported;
+    lerp: typeof lerp;
+    lightDebounce: typeof lightDebounce;
+    mapKeys: typeof mapKeys;
+    mapValues: typeof mapValues;
+    merge: (...objects: any[]) => any;
+    mergeValues: typeof mergeValues;
+    mix: typeof mix;
+    nextPowerOfTwo: typeof nextPowerOfTwo;
+    objToValueList: typeof objToValueList;
+    parseColor: typeof parseColor;
+    parseColorHex: typeof parseColorHex;
+    parseColorRgba: typeof parseColorRgba;
+    pick: typeof pick;
+    processQueue: typeof processQueue;
+    promiseQueue: typeof promiseQueue;
+    promptDownload: typeof promptDownload;
+    propertyPathToString: typeof propertyPathToString;
+    removeFromArray: typeof removeFromArray;
+    requestAnimFrame: typeof requestAnimFrame;
+    resizeElement: typeof resizeElement;
+    resolvePath: typeof resolvePath;
+    rgbaToRgb: (color: string) => {
+        color: string;
+        opacity: number;
+    };
+    serializeXMLDocument: typeof serializeXMLDocument;
+    setAttributes: typeof setAttributes;
+    setCtxFont: typeof setCtxFont;
+    setElementSize: typeof setElementSize;
+    setKeys: (set: Set<any>) => any[];
+    setProperty: typeof setProperty;
+    setValues: (set: Set<any>) => any[];
+    smartRequire: typeof smartRequire;
+    throttle: typeof throttle;
+    toArray: typeof toArray;
+    toHexa: (color: any) => string | null;
+    toPropertyPath: typeof toPropertyPath;
+    traverse: typeof traverse;
+    unflatten: typeof unflatten;
+    unorderedHash: typeof unorderedHash;
+    workerIsAvailable: boolean;
+};
+export default utils;

package/types/internals/wasmBackend.d.ts

@@ -0,0 +1,38 @@
+export type Subsystem = 'geometry' | 'graph' | 'attr' | 'spatial' | 'transform' | 'layout' | 'hyper' | 'render';
+export type Backend = 'ts' | 'wasm';
+export declare const SUBSYSTEMS: readonly Subsystem[];
+/**
+ * Override backends. `{ all: 'wasm' }` sets every subsystem; per-key entries
+ * win over `all`. Anything unspecified resets to the 'ts' default.
+ */
+export declare function configureBackends(config?: (Partial<Record<Subsystem, Backend>> & {
+    all?: Backend;
+}) | null): void;
+/** Parse `impl`/`flags` from a query string (used by the differential harness). */
+export declare function configureBackendsFromQuery(search: string): void;
+export declare function backendFor(s: Subsystem): Backend;
+export declare function useWasm(s: Subsystem): boolean;
+/** Snapshot of the current flags (for debugging / tests). */
+export declare function backendFlags(): Record<Subsystem, Backend>;
+/** The injected wasm exports, or null if not loaded. Sync — safe on hot paths. */
+export declare function wasmExports(): any;
+/** Inject the loaded wasm bindings. The host loads `pkg/` and calls this. */
+export declare function setWasmExports(mod: any): void;
+/**
+ * Opt-in async activator for the Rust/WASM backend. Dynamically imports the compiled
+ * bindings (`pkg/`, a CODE-SPLIT import so it is NOT eagerly bundled into the workers),
+ * injects them, and routes the requested subsystems through wasm. ADDITIVE + non-breaking:
+ * with no call, the library is 100% TS as before.
+ *
+ *   import { enableWasmBackend } from '@kortexya/nodus';
+ *   await enableWasmBackend({ attr: 'wasm' });   // wasm-backed numeric store
+ *   await enableWasmBackend();                    // { all: 'wasm' }
+ *
+ * Idempotent: the bindings load once. Activates MAIN-THREAD subsystems (e.g. the `attr`
+ * store bridge + inline layout/hyper); worker-run subsystems need worker-side injection
+ * (separate). Returns the loaded module (or null if loading fails — the library transparently
+ * stays on the TS path).
+ */
+export declare function enableWasmBackend(config?: (Partial<Record<Subsystem, Backend>> & {
+    all?: Backend;
+}) | null): Promise<any>;

package/types/internals/wasmColumns.d.ts

@@ -0,0 +1,61 @@
+/**
+ * WASM-backed numeric column support for FlexArray (the B2 store bridge).
+ *
+ * When `useWasm('attr')` is on, a numeric FlexArray backs its `_buffer` with a TypedArray
+ * VIEW over WASM linear memory (at the Rust FlexColumn's `ptr()`), instead of a JS-owned
+ * buffer. `.get(i)` / `.set(i, v)` then read/write the view directly — no per-call JS↔WASM
+ * boundary crossing, and the view's own TypedArray store-coercion (ToUint8/16/Int32/fround)
+ * is byte-identical to the old JS buffer.
+ *
+ * THE B2 INVARIANT: when any FlexColumn grows, WASM `memory.grow()` may REALLOC and move the
+ * whole heap — detaching EVERY existing view (a detached ArrayBuffer reads length 0). WASM
+ * exposes this as a NEW `memory.buffer` object identity. So this registry watches the buffer
+ * identity: after any column grow, if the buffer moved, it re-derives EVERY registered view
+ * once. Between grows the identity is stable, so hot-path get/set never needs a per-access
+ * check — preserving the intersector's monomorphism.
+ *
+ * LIVE since wasmInit routes `attr: 'wasm'` at startup. The cross-subsystem detach hazard
+ * (ANY wasm allocation — a layout/hyper batch op allocating Vecs between FlexArray accesses —
+ * can grow linear memory and detach every view) is covered by the SELF-HEALING accessors:
+ * `sharedRawGet_wasm` / `sharedSet_wasm` / `sharedGetMultiple_wasm` check
+ * `_buffer.length === 0` (a detached view reads length 0; columns are never legitimately
+ * empty — flex_capacity ≥ 8) and call `afterGrow()` to re-derive every registered view.
+ * One cheap monomorphic length check per access; wasm `memory.grow` ALWAYS detaches per spec,
+ * so the check is sound. Proven under stress by `b2-store-stress.html`: repeated add-800-nodes
+ * (FlexColumn grows) interleaved with wasm layouts (Vec allocs) and attribute writes/reads —
+ * 0 mismatches across every grow/move.
+ */
+/** dtype tags shared with `nodus_core::flex::DType::from_tag`. */
+export declare const enum DTypeTag {
+    U8 = 0,
+    U16 = 1,
+    I32 = 2,
+    F32 = 3,
+    F64 = 4
+}
+/** The minimal surface a wasm-backed FlexArray exposes to the registry. */
+export interface WasmBacked {
+    _rederiveView(): void;
+}
+type AnyTypedArray = Uint8Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+/** Map a FlexArray storage type to a numeric dtype tag, or null if it stays JS-side. */
+export declare function dtypeTagFor(storage: unknown): DTypeTag | null;
+/** Build a TypedArray view of `count` elements over wasm memory at byte offset `ptr`. */
+export declare function viewOver(tag: DTypeTag, ptr: number, count: number): AnyTypedArray;
+declare class WasmColumnRegistry {
+    private columns;
+    private lastBuffer;
+    /** True when numeric FlexArrays should be wasm-backed (flag on + bindings + FlexColumn). */
+    enabled(): boolean;
+    register(col: WasmBacked): void;
+    unregister(col: WasmBacked): void;
+    /**
+     * Call right after a FlexColumn grow. If wasm memory moved (new buffer identity), re-derive
+     * every registered view so no detached buffer survives. O(#columns), only on an actual move.
+     */
+    afterGrow(): void;
+    /** Test/teardown hook. */
+    reset(): void;
+}
+export declare const wasmColumns: WasmColumnRegistry;
+export {};

package/types/internals/wasmInit.d.ts

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

package/types/modules/APIModule.d.ts

@@ -0,0 +1,8 @@
+/**
+ * APIModule: base class for all public-facing API modules.
+ * Binary: `APIModule = class { constructor(e) { this._nodus = e } }`
+ */
+export declare class APIModule {
+    protected _nodus: any;
+    constructor(nodus: any);
+}

package/types/modules/AlgorithmsAPI.d.ts

@@ -0,0 +1,15 @@
+import { APIModule } from './APIModule';
+export declare class AlgorithmsAPI extends APIModule {
+    shortestPath: (opts: any) => any;
+    hasCycle: (opts?: any) => boolean;
+    getAllSimpleCycles: (opts?: any) => any;
+    detectCycle: (opts?: any) => any;
+    minimumSpanningTree: (opts?: any) => any;
+    dfs: (opts: any) => any;
+    bfs: (opts: any) => any;
+    betweenness: (opts?: any) => any;
+    getMinimumEnclosingCircle: (nodes: any) => any;
+    circlePack: (opts: any) => any;
+    fishEyeExpand: (opts: any) => any;
+    constructor(nodus: any);
+}

package/types/modules/BrandAPI.d.ts

@@ -0,0 +1,6 @@
+import { APIModule } from './APIModule';
+export declare class BrandAPI extends APIModule {
+    set: (opts: any, position?: any) => void;
+    remove: () => void;
+    constructor(nodus: any);
+}

package/types/modules/CaptorAPI.d.ts

@@ -0,0 +1,9 @@
+/**
+ * CaptorAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `CaptorAPI = class { getHoveredElement(){...} getPointerInformation(){...} }`
+ */
+export declare class CaptorAPI {
+    modules: any;
+    getHoveredElement(): any;
+    getPointerInformation(): any;
+}

package/types/modules/ClassesAPI.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ClassesAPI mixin — merged into Nodus via applyMixins.
+ * Binary: `ClassesAPI = class { getNodesByClassName(e,t){...} ... }`
+ */
+export declare class ClassesAPI {
+    modules: any;
+    getNodesByClassName(className: string, opts?: any): any;
+    getEdgesByClassName(className: string, opts?: any): any;
+}