@kortexya/nodus 0.1.0

package/types/internals/rendering/curveHelpers.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Rendering curve helpers.
+ *
+ * These functions handle animation interpolation, color mixing, edge text
+ * angle computation, line dash patterns, and curve segment length approximation.
+ */
+/**
+ * Compute the animation progress ratio for a given time, using polynomial
+ * easing coefficients looked up from the easing manager.
+ *
+ * @param currentTime - Current timestamp.
+ * @param beginTime   - Animation start timestamp.
+ * @param duration    - Total animation duration.
+ * @param easing      - Name of the easing function.
+ * @returns A value in [0, 1] representing the animation progress.
+ */
+export declare function computeAnimationRatio(currentTime: number, beginTime: number, duration: number, easing: string): number;
+/**
+ * Linearly interpolate between two CSS colour values.
+ *
+ * @param colorA     - Start colour (CSS string).
+ * @param colorB     - End colour (CSS string).
+ * @param ratio      - Interpolation ratio for RGB channels.
+ * @param alphaRatio - Interpolation ratio for the alpha channel.
+ * @returns An `rgba(…)` CSS colour string.
+ */
+export declare function mixColor(colorA: string, colorB: string, ratio: number, alphaRatio: number): string;
+interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Compute the angle at which edge label text should be drawn.
+ *
+ * The tangent vector is flipped when necessary so that the text always reads
+ * left-to-right and respects self-loop and offset-angle orientation.
+ *
+ * @param tangent     - Tangent vector at the label position (mutated in place).
+ * @param isSelfLoop  - Whether the edge is a self-loop.
+ * @param offsetAngle - The view rotation offset angle.
+ * @returns The text drawing angle in radians.
+ */
+export declare function computeEdgeTextAngle(tangent: Point, isSelfLoop: boolean, offsetAngle: number): number;
+/**
+ * Compute the line-dash array for a dashed edge of a given total length.
+ *
+ * The dash/gap pattern is tiled to fill the available space between the
+ * source and target clips, then a final partial segment is appended.
+ *
+ * @param totalLength - Total edge length in pixels.
+ * @param thickness   - Edge thickness (multiplies dash/gap lengths).
+ * @param sourceClip  - Clip length at the source end.
+ * @param targetClip  - Clip length at the target end.
+ * @param dashLength  - Dash length (in multiples of thickness).
+ * @param gapLength   - Gap length (in multiples of thickness).
+ * @returns An array suitable for `setLineDash`.
+ */
+export declare function computeLineDash(totalLength: number, thickness: number, sourceClip: number, targetClip: number, dashLength: number, gapLength: number): number[];
+/**
+ * Approximate the arc length of a cubic Bézier curve using Gaussian
+ * quadrature (7-point rule).
+ *
+ * For curves that are nearly flat (control points nearly collinear) a
+ * cheaper one-sided estimate is used; otherwise a two-sided symmetric
+ * estimate is computed.
+ *
+ * @param p0 - Start point.
+ * @param p1 - First control point.
+ * @param p2 - Second control point.
+ * @param p3 - End point.
+ * @returns Approximate arc length.
+ */
+export declare function getCubicSegmentLength(p0: Point, p1: Point, p2: Point, p3: Point): number;
+/**
+ * Compute the arc length of a quadratic Bézier curve segment using a
+ * closed-form analytical solution.
+ *
+ * @param curvature   - Edge curvature value.
+ * @param chordLength - Straight-line distance between endpoints.
+ * @param tScale      - Parameter-space extent (usually 1 for the full curve).
+ * @returns Approximate arc length.
+ */
+export declare function getQuadraticSegmentLength(curvature: number, chordLength: number, tScale: number): number;
+/**
+ * Approximate the arc length of a self-loop cubic Bézier by treating the
+ * control-point triangle's circumradius as a circle and scaling by π.
+ *
+ * @param p0    - Start point.
+ * @param p1    - First control point.
+ * @param p2    - Second control point.
+ * @param _p3   - End point (unused, kept for API consistency).
+ * @param scale - Scale factor.
+ * @returns Approximate arc length.
+ */
+export declare function getSelfLoopSegmentLengthApprox(p0: Point, p1: Point, p2: Point, _p3: Point, scale: number): number;
+export {};

package/types/internals/rendering/drawerHelpers.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared helpers used by both NodeDrawer and EdgeDrawer.
+ *
+ * Provides depth/layer math, color inheritance resolution, text wrapping,
+ * and the shape-name/sentinel constants consumed across the rendering layer.
+ */
+import { NB_BLOCK_PER_INDEX } from './constants';
+export { NB_BLOCK_PER_INDEX };
+export interface DepthInfo {
+    edgeHalo: number;
+    nodeHaloStroke: number;
+    nodeHalo: number;
+    edgeBody: number;
+    edgeTextBackground: number;
+    edgeText: number;
+    nodeBody: number;
+    nodeTextBackground: number;
+    nodeText: number;
+}
+export declare function createDepthInfo(): DepthInfo;
+export declare function layerToDepth(layer: number, depth?: DepthInfo): DepthInfo;
+export declare function inheritColor(value: string, parentColor: string | string[], angle?: number): string;
+export declare function inheritSourceTargetColor(value: string, sourceColor: string | string[], targetColor: string | string[]): string;
+export declare const isValidTextContent: (value: any) => boolean;
+export declare function splitText(text: string, maxLineLength: number): string;
+export declare const SHIFTED = "shifted";
+export declare const OPEN_ARROW = "open-arrow";
+export declare const OPEN_ARROW_TAIL = "arrow-tail-open";
+export declare const OPEN_ARROW_HEAD = "arrow-head-open";
+export declare const OPEN_ARROW_NONE = "arrow-none-ex-open";
+export declare const OPEN_ARROW_BOTH = "arrow-both-open";
+export declare const SDF_TEXT = -1;

package/types/internals/rendering/float16.d.ts

@@ -0,0 +1,25 @@
+/**
+ * IEEE 754 half-precision (float16) conversion utilities and a simple
+ * `isNumber` guard.
+ */
+/**
+ * Check whether a value is a finite number.
+ *
+ * @param value - The value to test.
+ * @returns `true` when `value` is a finite JS number.
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Encode a 64-bit JavaScript number into a 16-bit half-precision float (IEEE 754).
+ *
+ * @param value - The number to encode.
+ * @returns A 16-bit unsigned integer representing the half-float.
+ */
+export declare const toFloat16: (value: number) => number;
+/**
+ * Decode a 16-bit half-precision float back into a JavaScript number.
+ *
+ * @param bits - The 16-bit unsigned integer to decode.
+ * @returns The corresponding 64-bit float value.
+ */
+export declare const fromFloat16: (bits: number) => number;

package/types/internals/rendering/hitDetection.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Hit-detection functions for nodes and edges.
+ *
+ * Provides three routines:
+ *   - detectNode - finds the topmost node under a screen point.
+ *   - checkBadge - internal helper that tests a node's corner badges.
+ *   - detectEdge - finds the topmost edge under a screen point.
+ *
+ * These functions test whether a screen-space point hits a node or edge,
+ * accounting for shape, curvature, self-loops, bent edges, badges, and text.
+ */
+interface Point {
+    x: number;
+    y: number;
+}
+/** Something that has graphToScreenCoordinates, getZoom, getAngle, etc. */
+interface ViewTransformProvider {
+    getZoom(): number;
+    getAngle(): number;
+    graphToScreenCoordinates(pt: Point): Point;
+    screenToGraphCoordinates(pt: Point): Point;
+    getCornerCos(index: number): number;
+    getCornerSin(index: number): number;
+}
+/** The data-store (FlexArrays) provider. */
+interface DataStoreProvider {
+    update(): void;
+    getFlexArrays(): any;
+}
+/** Shape hit-testing + text measurement provider. */
+interface ShapeHitProvider {
+    checkShapeHit(shape: string | number, normalizedX: number, normalizedY: number): boolean;
+    measureText(text: string, font: any, style: any, scale: number): {
+        width: number;
+        height: number;
+    };
+}
+/** The graph object provider (nodes, edges, object lists). */
+interface GraphObjectProvider {
+    getNodes(): {
+        _indexes: number[];
+    };
+    getEdges(): {
+        _indexes: number[];
+    };
+    getObjectList(isNode: boolean): {
+        get(index: number): any | null;
+    };
+    getAttribute(isNode: boolean, name: string): {
+        get(index: number): any;
+    };
+}
+/**
+ * Find the topmost node at screen position (`screenX`, `screenY`).
+ *
+ * @param screenX           - X coordinate in screen/pixel space.
+ * @param screenY           - Y coordinate in screen/pixel space.
+ * @param checkText         - Whether to also check text bounding boxes.
+ * @param checkBadges       - Whether to also check badge hit-areas.
+ * @param tolerance         - Extra pixel tolerance around the node shape.
+ * @param candidateIndexes  - Pre-filtered array of node indices to test (or null for all).
+ * @param graphObjects      - Graph object provider (nodes, edges, object lists).
+ * @param dataStore         - Data store for flex-array access.
+ * @param viewTransform     - View/camera transform.
+ * @param shapeHitProvider  - Shape hit-testing + text measurement.
+ * @param excludedNodes     - Set of node indices to skip.
+ * @param getTextContent    - Callback resolving a text reference to a string.
+ * @returns The graph object at that position, or null.
+ */
+export declare function detectNode(screenX: number, screenY: number, checkText: boolean, checkBadges: boolean, tolerance: number, candidateIndexes: number[] | null, graphObjects: GraphObjectProvider, dataStore: DataStoreProvider, viewTransform: ViewTransformProvider, shapeHitProvider: ShapeHitProvider, excludedNodes: Set<number>, getTextContent: (ref: any) => string | null): any | null;
+/**
+ * Find the topmost edge at screen position (`screenX`, `screenY`).
+ *
+ * @param screenX           - X coordinate in screen/pixel space.
+ * @param screenY           - Y coordinate in screen/pixel space.
+ * @param _checkText        - Reserved (unused in current implementation).
+ * @param tolerance         - Extra pixel tolerance around the edge shape.
+ * @param candidateIndexes  - Pre-filtered array of edge indices to test (or null for all).
+ * @param graphObjects      - Graph object provider.
+ * @param viewTransform     - View/camera transform.
+ * @param dataStore         - Data store for flex-array access.
+ * @param bentEnable        - Whether bent edges are enabled (or the bend config).
+ * @param bentVertical      - Bent-edge vertical layout flag.
+ * @param excludedNodes     - Set of node indices whose edges should be skipped.
+ * @param excludedNodeId    - A single node id whose self-loop edges should be skipped.
+ * @returns The graph edge object at that position, or null.
+ */
+export declare function detectEdge(screenX: number, screenY: number, _checkText: boolean, tolerance: number, candidateIndexes: number[] | null, graphObjects: GraphObjectProvider, viewTransform: ViewTransformProvider, movingNodes: Set<number>, dataStore: DataStoreProvider, bentEnable: any, bentVertical: any, excludedNodeId: number | undefined): any | null;
+export {};

package/types/internals/rendering/loadGraph.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Functions that load graph data into the graphics engine's GPU buffer system.
+ *
+ * - `loadGraphInGraphicsEngine` iterates changed nodes/edges, encoding visual
+ *   attributes into buffer memory via NodeDrawer / EdgeDrawer.
+ * - `loadRequiredShapes` ensures every shape referenced by any element is
+ *   registered in the engine.
+ * - `setRoundness` updates polygon shapes with rounded corners.
+ */
+import type { Graph } from '../Graph';
+import type { ShapeDefinition } from './shapeHelpers';
+interface ImageManager {
+    getImage(url: string): any;
+}
+/** Options passed to `loadGraphInGraphicsEngine`. */
+export interface LoadGraphOptions {
+    graph: Graph;
+    elements: {
+        nodes: ElementList;
+        edges: ElementList;
+    };
+    engine: GraphicsEngine;
+    imageManager: ImageManager;
+    fontManager: FontManager;
+    view: ViewState;
+    attributes: AttributesSnapshot;
+    boundaries: BoundaryInfo;
+    formatText: (text: string | null) => string;
+}
+interface ElementList {
+    size: number;
+    _indexes: number[];
+}
+interface GraphicsEngine {
+    setGlobalBoundaries(params: GlobalBoundaryParams): boolean;
+    createGroup(): any;
+    storeGroup(blockId: number, group: any): void;
+    freeBlock(blockId: number): void;
+    getBentEdges(): {
+        bentEnable: boolean;
+        bentVertical: boolean;
+    };
+    registerShape(name: string, shape: ShapeDefinition): void;
+    updateShape(name: string, shape: ShapeDefinition): void;
+    measureText(text: string, font: string, style: string, scale?: number): {
+        width: number;
+        height: number;
+    };
+}
+interface FontManager {
+    getFont(name: string): string;
+}
+interface ViewState {
+    angle?: number;
+}
+interface AttributesSnapshot {
+    nodes: {
+        current: any;
+        previous: any;
+    };
+    edges: {
+        current: any;
+        previous: any;
+    };
+}
+interface BoundaryInfo {
+    maxSize: number;
+    maxMinVisibleSize: number;
+}
+interface GlobalBoundaryParams {
+    maxBlockId: number;
+    maxScaledSize: number;
+    maxMinVisibleSize: number;
+    maxSymbolicSize: number;
+    maxDashLength: number;
+    maxGapLength: number;
+    maxPatternScale: number;
+    maxCoord: number;
+}
+/**
+ * Loads changed graph elements into the rendering engine's GPU buffers.
+ *
+ * For every changed node / edge it creates the corresponding Drawer, computes
+ * visual attributes, and writes them into buffer memory via the engine.
+ */
+export declare function loadGraphInGraphicsEngine({ graph, elements, engine, imageManager, fontManager, view, attributes, boundaries, formatText, }: LoadGraphOptions): void;
+/**
+ * Registers all shapes that are referenced by the current graph attributes
+ * with the graphics engine.
+ *
+ * Common shapes (circle, square, triangle, …) are always registered.
+ * Uncommon node shapes and edge extremity shapes are registered only if they
+ * appear in the current attribute values.
+ */
+export declare function loadRequiredShapes(engine: GraphicsEngine, attributes: AttributesSnapshot): void;
+/**
+ * Recomputes polygon shapes with rounded corners at the given `radius` and
+ * pushes the updated shapes to the engine.
+ *
+ * Affects: star, pentagon, hexagon, square, cross, diamond.
+ */
+export declare function setRoundness(engine: GraphicsEngine, radius: number): void;
+export {};

package/types/internals/rendering/objectInfo.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Factory and reset helpers for the rendering data structures
+ * (ObjectInfo, AnimationInfo, ElementInfo).
+ */
+import type { ObjectInfo, AnimationInfo, ElementInfo } from './types';
+/**
+ * Create a fresh {@link ObjectInfo} with sensible defaults.
+ * Every numeric field starts at 0, colours at null, and booleans at false.
+ */
+export declare function createGenericObjectInfo(): ObjectInfo;
+/**
+ * Reset an existing {@link ObjectInfo} in-place, re-using the allocated
+ * `pattern` sub-object when possible to reduce GC pressure.
+ *
+ * @param info - The object info to reset (defaults to a new empty object).
+ * @returns The same reference, now zeroed out.
+ */
+export declare function resetObjectInfo(info?: Partial<ObjectInfo>): ObjectInfo;
+/**
+ * Reset an existing {@link AnimationInfo} in-place.
+ *
+ * @param info - The animation info to reset (defaults to a new empty object).
+ * @returns The same reference, now reset to "no animation".
+ */
+export declare function resetAnimationInfo(info?: Partial<AnimationInfo>): AnimationInfo;
+/**
+ * Create a complete {@link ElementInfo} with default start / end states
+ * and a zeroed-out animation.
+ */
+export declare function createElementInfo(): ElementInfo;
+/**
+ * Resize an HTML canvas element, accounting for a device-pixel ratio.
+ *
+ * @param canvas  - The canvas element to resize.
+ * @param width   - Desired CSS width in pixels.
+ * @param height  - Desired CSS height in pixels.
+ * @param dpr     - Device pixel ratio (e.g. `window.devicePixelRatio`).
+ */
+export declare function resizeCanvas(canvas: HTMLCanvasElement, width: number, height: number, dpr: number): void;
+/**
+ * Standard sigmoid function.
+ *
+ * @param x - Input value.
+ * @returns A value in (0, 1).
+ */
+export declare function sigmoid(x: number): number;

package/types/internals/rendering/packing.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure GPU instance-buffer packing primitives (the renderer's CPU-side data layer).
+ *
+ * Extracted from MemoryManager so they are a single, exported, testable source of truth and
+ * can be differentially gated against the Rust port (`nodus-core::render_pack`). Each is pure
+ * integer/bit arithmetic — no DOM, no store — so it is byte-exact across JS and WASM.
+ */
+/** Extract the bit field `[low, high)` from `value`. `(value % 2^high) >> low`. */
+export declare function extractBits(value: number, low: number, high: number): number;
+/** `value - 128` (decode a u8 as a signed byte). */
+export declare function unsignedToSignedByte(value: number): number;
+/** `value - 32768` (decode a u16 as a signed int16). */
+export declare function unsignedToSignedInt16(value: number): number;
+/**
+ * Pack rgba (each in [0,1]) into a 16-bit value: 4 bits per channel,
+ * `r | g<<4 | b<<8 | a<<12`, each channel `round(15·c)`. Mirrors MemoryManager's
+ * `_colorToBytes` (minus the colour PARSE, which stays JS-side / DOM-coupled).
+ */
+export declare function colorRgbaToBytes(r: number, g: number, b: number, a: number): number;
+/**
+ * Decode a packed rgba16 into its four channel values: `[r255, g255, b255, alpha]` where the
+ * RGB are `(255·channel/15)|0` integers and alpha is the raw `channel/15` fraction. The CSS
+ * string assembly + zero→null stays in MemoryManager (JS number→string formatting is not a
+ * portable parity surface). Mirrors the numeric core of `bytesToColor`.
+ */
+export declare function bytesToColorComponents(value: number): [number, number, number, number];
+/** `round(min(value, max) · factor)` — the dash/gap/symbolic/min-visible/pattern-scale shape. */
+export declare function quantizeRound(value: number, max: number, factor: number): number;
+/** `ceil(min(value, max) · factor)` — the scaled-size shape. */
+export declare function quantizeCeil(value: number, max: number, factor: number): number;
+/** Quantize an angle to one of 8 buckets: `round(((θ + 2π) mod 2π) · 8/2π)`. */
+export declare function offsetAngleToBytes(value: number): number;
+/** `round(15 · min(value, 1))` (4-bit opacity). */
+export declare function opacityToBytes(value: number): number;
+/** `clamp(value, -128, 127) + 128` (signed byte → unsigned). */
+export declare function signedToUnsignedByte(value: number): number;
+/** `clamp(value, -32768, 32767) + 32768` (signed int16 → unsigned). */
+export declare function signedToUnsignedInt16(value: number): number;
+/** word0: shapeId(4) | pieceId(4) | dash(2) | gap(2) | head(1) | tail(1) | bodyTri/rotate(1) | selfLoop(1). */
+export declare function packWord0(shapeId: number, pieceId: number, dash: number, gap: number, hasHead: number, hasTail: number, bodyTri: number, selfLoop: number): number;
+/** word1: patternScale(8) | offsetAngle(3) | isText(1) | adjustAngle(1) | isBadge(1) | bentEnable(1) | bentVertical(1). */
+export declare function packWord1(patternScale: number, offsetAngle: number, isText: number, adjustAngle: number, isBadge: number, bentEnable: number, bentVertical: number): number;
+/** word2: opacity(4) | globalMinVisible(4) | strokeMinVisible(4) | patternMinVisible(4). */
+export declare function packWord2(opacity: number, globalMin: number, strokeMin: number, patternMin: number): number;
+/** word3: symbolicSize(8) | curvature(8). */
+export declare function packWord3(symbolicSize: number, curvature: number): number;

package/types/internals/rendering/shapeHelpers.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Shape geometry helper functions used by the rendering layer.
+ *
+ * Provides polygon generation (regular/star polygons), point-in-polygon and
+ * signed-distance-field (SDF) queries, rounded-corner expansion, and open-arrow
+ * point construction.
+ */
+export interface ShapePoint {
+    x: number;
+    y: number;
+    r?: number;
+}
+export interface ShapeDefinition {
+    getDistanceFromStrokeVertically: (x: number, y: number) => number;
+    getDistanceFromStrokeHorizontally: (x: number, y: number) => number;
+    points: ShapePoint[];
+    hole?: ShapePoint[];
+    isSimple: boolean;
+}
+export declare function isPointInPolygon(px: number, py: number, polygon: ShapePoint[]): boolean;
+export declare function distanceToPolygon(px: number, py: number, polygon: ShapePoint[]): number;
+export declare function computeCircularPolygon(sides: number, innerRadius?: number, startAngle?: number): ShapePoint[];
+export declare function createPolygonShape(points: ShapePoint[], isSimple?: boolean): ShapeDefinition;
+export declare function roundedCorners(points: ShapePoint[], radius: number, steps?: number): ShapePoint[];
+export declare function segmentSDF(x1: number, y1: number, x2: number, y2: number, halfWidth: number, px: number, py: number): number;
+export declare function getOpenArrowPoints(angle: number, length: number, strokeWidth: number, tipWidth: number): ShapePoint[];

package/types/internals/rendering/types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * TypeScript interfaces for the rendering data structures used by
+ * Buffer2, BufferList, ElementGroup, and MemoryManager.
+ */
+/** Describes a pattern applied to a rendered element (image, text, icon…). */
+export interface PatternInfo {
+    /** Internal pattern identifier */
+    id: string | number | undefined;
+    /** Discriminator for the kind of pattern (see PATTERN_* constants) */
+    type: number;
+    /** Arbitrary attributes bag consumed by the pattern renderer */
+    attributes: Record<string, unknown>;
+}
+/** Full visual description of a single rendered object (node body, edge, etc.). */
+export interface ObjectInfo {
+    /** Identifier of the piece this object belongs to (see PIECE_* constants) */
+    pieceId: number;
+    /** Shape name (e.g. "circle", "square", "diamond"…) */
+    shape: string;
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    rectWidthOrSourceRadiusScaled: number;
+    rectWidthOrSourceRadiusFixed: number;
+    rectHeightOrTargetRadiusScaled: number;
+    rectHeightOrTargetRadiusFixed: number;
+    thicknessOrFontSizeScaled: number;
+    thicknessOrFontSizeFixed: number;
+    strokeWidthScaled: number;
+    strokeWidthFixed: number;
+    offsetScaled: number;
+    offsetFixed: number;
+    /** Pattern info (image, icon, text, pie-chart…) */
+    pattern: PatternInfo;
+    /** Overall opacity [0..1] */
+    opacity: number;
+    /** Fill colour as a CSS string, or null for transparent */
+    fillColor: string | null;
+    /** Stroke colour as a CSS string, or null */
+    strokeColor: string | null;
+    /** Pattern colour as a CSS string, or null */
+    patternColor: string | null;
+    /** Minimum pixel size below which the whole element is hidden */
+    globalMinVisibleSize: number;
+    /** Minimum pixel size below which the stroke is hidden */
+    strokeMinVisibleSize: number;
+    /** Minimum pixel size below which the pattern is hidden */
+    patternMinVisibleSize: number;
+    /** Rotation offset (radians) for badge / pattern placement */
+    offsetAngle: number;
+    /** Scale factor for the pattern texture */
+    patternScale: number;
+    /** When ≥ 0 the element keeps a constant screen-space size (symbolic) */
+    symbolicSize: number;
+    /** Curvature of an edge body (0 = straight) */
+    curvature: number;
+    /** Dash length in world units (0 = solid) */
+    dashLength: number;
+    /** Gap length in world units (0 = solid) */
+    gapLength: number;
+    hasHead: boolean;
+    hasTail: boolean;
+    isBodyTriangle: boolean;
+    isSelfLoop: boolean;
+    isText: boolean;
+    adjustTextAngle: boolean;
+    isBadge: boolean;
+    bentEnable: boolean;
+    bentVertical: boolean;
+    rotateWithEdge: boolean;
+}
+/** Animation timing metadata for a single element. */
+export interface AnimationInfo {
+    /** Duration of the animation in milliseconds */
+    duration: number;
+    /** Start time of the animation (−1 means not started) */
+    beginTime: number;
+    /** Name of the easing function (key into EasingManager) */
+    easing: string;
+}
+/**
+ * Full information for one element in an {@link ElementGroup}:
+ * start state, end state, and the animation that interpolates between them.
+ */
+export interface ElementInfo {
+    /** Whether this element has been populated with valid data */
+    valid: boolean;
+    /** External identifier (node id / edge id) */
+    id: string | number | undefined;
+    /** Visual state at the end of the animation (or current state if static) */
+    end: ObjectInfo;
+    /** Visual state at the start of the animation (only used when animated) */
+    start: ObjectInfo;
+    /** Animation timing that interpolates between `start` and `end` */
+    animation: AnimationInfo;
+}
+/**
+ * Describes a contiguous allocation within a {@link Buffer2}.
+ * Returned by {@link BufferList.allocateBlock} and {@link BufferList.getBlockInfo}.
+ */
+export interface BlockInfo {
+    /** The buffer this block lives in (null before first use) */
+    buffer: import('./Buffer2').Buffer2 | null;
+    /** Offset (in elements) within the buffer */
+    offset: number;
+    /** Number of elements in this block */
+    size: number;
+    /** Encoded address that can be decoded back to buffer / offset / size */
+    address: number;
+}
+/** Constructor options for {@link Buffer2}. */
+export interface BufferOptions {
+    /** Byte size of a single element (ELEMENT_BYTESIZE or ELEMENT_BYTESIZE_ANIMATED) */
+    elementSize: number;
+    /** Byte size of a single side-element */
+    sideElementSize: number;
+    /** Number of side-elements attached to each main element */
+    nbSideElementsPerMainElement: number;
+    /** Unique buffer id (index in BufferList._buffersById) */
+    id: number;
+    /** Depth / layer used for draw-order sorting */
+    depth: number;
+    /** Element type (ELT_GENERIC, ELT_TEXT, ELT_CURVE) */
+    elementType: number;
+    /** Whether the buffer holds animated elements */
+    animated: boolean;
+    /** Stencil mode (STENCIL_IGNORE, STENCIL_DEFINE_MASK, STENCIL_USE_MASK) */
+    stencilUsage: number;
+}
+/** Scale factors for converting byte-packed values back to world-space. */
+export interface ExtractionScaleFactors {
+    bytesToActualCoord: number;
+    bytesToActualScaledSize: number;
+    bytesToActualMinVisibleSize: number;
+    bytesToActualPatternScale: number;
+    bytesToActualSymbolicSize: number;
+    bytesToActualDashLength: number;
+    bytesToActualGapLength: number;
+}
+export type PatternType = number;
+export type PatternDefinition = PatternInfo;
+export type GenericObjectInfo = ObjectInfo;