@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/layout/portfolio-layouts.js

@@ -1,388 +0,0 @@
-"use strict";
-// Wave 7 (Auto-layout) — Card 2: the first-class layout portfolio.
-//
-// Grid, Circular, Radial, Tree and Force, as NAMED layouts in the Card-0 registry
-// with one shared options vocabulary:
-//
-//   engine.layout('radial', { rankSpacing: 120 })
-//   engine.layout('tree',   { direction: 'LR' })
-//   engine.layout('grid',   { columns: 4 })
-//
-// GoJS ships five built-ins plus a dozen extensions; JointJS+ ships
-// directed/tree/stack/grid. An engine with only "dagre" and "force" cannot draw
-// half the diagrams people actually draw.
-//
-// Two things every one of these gets for free, and neither is optional:
-//
-//   • COMPONENT PACKING (component-packing.ts). Each connected component is laid
-//     out alone and the boxes are packed afterwards. It is the difference between
-//     a forest of five org charts and a pile of five org charts.
-//   • DETERMINISM (rng.ts). Node order is canonicalised by id and the only source
-//     of randomness — force's initial jitter — is seeded. Same graph + same seed
-//     ⇒ byte-identical coordinates.
-//
-// NOT to be confused with ./algorithms/GridLayoutAlgorithm and friends. Those
-// implement ILayoutAlgorithm — `calculatePlacement(node, viewport)`, "where does
-// this ONE new node go?" — a single-node placement strategy. Same words, a
-// different question. (The wave-7 audit tripped over exactly this; see the header
-// of layout-registry.ts.)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gridLayout = gridLayout;
-exports.circularLayout = circularLayout;
-exports.radialLayout = radialLayout;
-exports.forceLayout = forceLayout;
-const component_packing_1 = require("./component-packing");
-const rng_1 = require("./rng");
-const force_layout_adapter_1 = require("./force-layout-adapter");
-const tree_layout_1 = require("./tree-layout");
-const DEFAULT_NODE_SPACING = 50;
-const DEFAULT_RANK_SPACING = 70;
-/** A node's footprint on a circle: the diameter it needs, plus breathing room. */
-const slotOf = (node, spacing) => {
-    const { width, height } = (0, component_packing_1.nodeSize)(node);
-    return Math.max(width, height) + spacing;
-};
-const emptyResult = (algorithm) => ({
-    nodePositions: new Map(),
-    bounds: { x: 0, y: 0, width: 0, height: 0 },
-    metadata: { algorithm, executionTime: 0 },
-});
-/** Bounds of a positioned node set (positions are top-left). */
-function boundsOf(nodes, positions) {
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (const node of nodes) {
-        const p = positions.get(node.id);
-        if (!p)
-            continue;
-        const { width, height } = (0, component_packing_1.nodeSize)(node);
-        minX = Math.min(minX, p.x);
-        minY = Math.min(minY, p.y);
-        maxX = Math.max(maxX, p.x + width);
-        maxY = Math.max(maxY, p.y + height);
-    }
-    if (!Number.isFinite(minX))
-        return { x: 0, y: 0, width: 0, height: 0 };
-    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-}
-/**
- * Deterministic adjacency, neighbours in id order.
- *
- * Every traversal in this file starts from the lowest id and takes neighbours in
- * id order, so nothing here can depend on insertion order — the trap Card 0
- * documents (a seeded PRNG does not save you if the graph is CONSUMED in a
- * different order on reload).
- */
-function adjacencyOf(nodes, links) {
-    const ids = new Set(nodes.map((n) => n.id));
-    const adjacency = new Map();
-    for (const id of ids)
-        adjacency.set(id, []);
-    for (const link of (0, rng_1.inStableOrder)(links)) {
-        const s = link.sourceNodeId;
-        const t = link.targetNodeId;
-        if (!s || !t || !ids.has(s) || !ids.has(t) || s === t)
-            continue;
-        adjacency.get(s).push(t);
-        adjacency.get(t).push(s);
-    }
-    for (const list of adjacency.values())
-        list.sort();
-    return adjacency;
-}
-// ---------------------------------------------------------------------------
-// GRID
-// ---------------------------------------------------------------------------
-/**
- * Row-major grid. Ignores links entirely — that is the point: a grid is what you
- * reach for when the edges are NOT the story (a palette of components, a set of
- * unconnected cards).
- *
- * `direction` chooses the FILL ORDER of the same grid, not a different grid:
- * 'TB' fills left-to-right then down, 'LR' fills top-to-bottom then across,
- * 'BT'/'RL' mirror those.
- */
-function gridLayout(nodes, _links, options = {}) {
-    var _a, _b, _c, _d;
-    const ordered = (0, rng_1.inStableOrder)(nodes);
-    if (ordered.length === 0)
-        return emptyResult('grid');
-    const nodeSpacing = (_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : DEFAULT_NODE_SPACING;
-    const rankSpacing = (_b = options.rankSpacing) !== null && _b !== void 0 ? _b : DEFAULT_NODE_SPACING;
-    const columns = Math.max(1, Math.floor((_c = options.columns) !== null && _c !== void 0 ? _c : Math.ceil(Math.sqrt(ordered.length))));
-    const rows = Math.ceil(ordered.length / columns);
-    // Uniform cells, so the grid reads as a grid even when the nodes differ in
-    // size; each node is centred in its cell.
-    const cellWidth = Math.max(...ordered.map((n) => (0, component_packing_1.nodeSize)(n).width));
-    const cellHeight = Math.max(...ordered.map((n) => (0, component_packing_1.nodeSize)(n).height));
-    const direction = (_d = options.direction) !== null && _d !== void 0 ? _d : 'TB';
-    const nodePositions = new Map();
-    ordered.forEach((node, i) => {
-        let row;
-        let column;
-        if (direction === 'LR' || direction === 'RL') {
-            // Column-major fill: down each column, then across.
-            column = Math.floor(i / rows);
-            row = i % rows;
-        }
-        else {
-            column = i % columns;
-            row = Math.floor(i / columns);
-        }
-        if (direction === 'RL')
-            column = columns - 1 - column;
-        if (direction === 'BT')
-            row = rows - 1 - row;
-        const size = (0, component_packing_1.nodeSize)(node);
-        nodePositions.set(node.id, {
-            x: column * (cellWidth + nodeSpacing) + (cellWidth - size.width) / 2,
-            y: row * (cellHeight + rankSpacing) + (cellHeight - size.height) / 2,
-        });
-    });
-    return {
-        nodePositions,
-        bounds: boundsOf(ordered, nodePositions),
-        metadata: { algorithm: 'grid', executionTime: 0, columns, rows },
-    };
-}
-// ---------------------------------------------------------------------------
-// CIRCULAR
-// ---------------------------------------------------------------------------
-/**
- * Every node on one ring.
- *
- * Nodes are ordered by a BFS from the lowest-id node rather than by id, because
- * a circle's readability is entirely about edge crossings and BFS order puts
- * neighbours next to each other. (Ordering by id would be equally deterministic
- * and much uglier — an arbitrary permutation guarantees chords across the whole
- * circle.)
- *
- * The radius is derived from the nodes' own footprints, so a circular layout of
- * 40 nodes does not stack them on top of each other the way a fixed radius does.
- */
-function circularLayout(nodes, links, options = {}) {
-    var _a, _b, _c;
-    const ordered = (0, rng_1.inStableOrder)(nodes);
-    if (ordered.length === 0)
-        return emptyResult('circular');
-    const spacing = (_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : DEFAULT_NODE_SPACING;
-    if (ordered.length === 1) {
-        return {
-            nodePositions: new Map([[ordered[0].id, { x: 0, y: 0 }]]),
-            bounds: Object.assign({ x: 0, y: 0 }, (0, component_packing_1.nodeSize)(ordered[0])),
-            metadata: { algorithm: 'circular', executionTime: 0, radius: 0 },
-        };
-    }
-    // BFS ring order.
-    const adjacency = adjacencyOf(ordered, links);
-    const byId = new Map(ordered.map((n) => [n.id, n]));
-    const seen = new Set();
-    const ring = [];
-    for (const start of ordered) {
-        if (seen.has(start.id))
-            continue;
-        seen.add(start.id);
-        const queue = [start.id];
-        while (queue.length > 0) {
-            const current = queue.shift();
-            ring.push(byId.get(current));
-            for (const next of (_b = adjacency.get(current)) !== null && _b !== void 0 ? _b : []) {
-                if (seen.has(next))
-                    continue;
-                seen.add(next);
-                queue.push(next);
-            }
-        }
-    }
-    // Each node claims arc proportional to its own size, so a big node does not
-    // collide with the small ones beside it.
-    const slots = ring.map((n) => slotOf(n, spacing));
-    const circumference = slots.reduce((a, b) => a + b, 0);
-    const radius = (_c = options.radius) !== null && _c !== void 0 ? _c : Math.max(Math.max(...slots) / 2, circumference / (2 * Math.PI));
-    const nodePositions = new Map();
-    let travelled = 0;
-    ring.forEach((node, i) => {
-        // Start at the top (-π/2) and go clockwise; the centre of the node's own arc.
-        const angle = -Math.PI / 2 + (2 * Math.PI * (travelled + slots[i] / 2)) / circumference;
-        travelled += slots[i];
-        const size = (0, component_packing_1.nodeSize)(node);
-        nodePositions.set(node.id, {
-            x: radius + radius * Math.cos(angle) - size.width / 2,
-            y: radius + radius * Math.sin(angle) - size.height / 2,
-        });
-    });
-    return {
-        nodePositions,
-        bounds: boundsOf(ring, nodePositions),
-        metadata: { algorithm: 'circular', executionTime: 0, radius },
-    };
-}
-// ---------------------------------------------------------------------------
-// RADIAL
-// ---------------------------------------------------------------------------
-/**
- * Concentric rings by BFS depth from a hub.
- *
- * The wedge allocation is what makes it readable: each subtree gets an angular
- * slice PROPORTIONAL TO ITS LEAF COUNT, so a bushy branch is not crammed into the
- * same wedge as a single leaf. That is the classic radial-tree construction, and
- * it is crossing-free for trees.
- *
- * Ring radii are grown to fit — a ring is pushed outward if the nodes on it would
- * not otherwise fit around its circumference, which is the failure mode of every
- * "radius = depth * constant" radial layout at depth 3 and beyond.
- */
-function radialLayout(nodes, links, options = {}) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    const ordered = (0, rng_1.inStableOrder)(nodes);
-    if (ordered.length === 0)
-        return emptyResult('radial');
-    if (ordered.length === 1) {
-        return {
-            nodePositions: new Map([[ordered[0].id, { x: 0, y: 0 }]]),
-            bounds: Object.assign({ x: 0, y: 0 }, (0, component_packing_1.nodeSize)(ordered[0])),
-            metadata: { algorithm: 'radial', executionTime: 0, rings: 0 },
-        };
-    }
-    const nodeSpacing = (_a = options.nodeSpacing) !== null && _a !== void 0 ? _a : DEFAULT_NODE_SPACING;
-    const rankSpacing = (_b = options.rankSpacing) !== null && _b !== void 0 ? _b : DEFAULT_RANK_SPACING;
-    const adjacency = adjacencyOf(ordered, links);
-    const byId = new Map(ordered.map((n) => [n.id, n]));
-    // Centre: the caller's node, else a SOURCE, else the highest-degree hub. Shared
-    // with the tree layout (pickRoot) because getting this wrong is the same bug in
-    // both: a pure highest-degree rule centres an org chart on a middle manager,
-    // because a manager with four reports out-degrees the CEO with two.
-    const inDegree = new Map(ordered.map((n) => [n.id, 0]));
-    const degree = new Map(ordered.map((n) => { var _a, _b; return [n.id, (_b = (_a = adjacency.get(n.id)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0]; }));
-    const ids = new Set(ordered.map((n) => n.id));
-    for (const link of (0, rng_1.inStableOrder)(links)) {
-        const s = link.sourceNodeId;
-        const t = link.targetNodeId;
-        if (!s || !t || !ids.has(s) || !ids.has(t) || s === t)
-            continue;
-        inDegree.set(t, inDegree.get(t) + 1);
-    }
-    const root = (0, tree_layout_1.pickRoot)(ordered, inDegree, degree, options.rootId);
-    // BFS tree.
-    const depth = new Map([[root, 0]]);
-    const children = new Map();
-    for (const n of ordered)
-        children.set(n.id, []);
-    const queue = [root];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        for (const next of (_c = adjacency.get(current)) !== null && _c !== void 0 ? _c : []) {
-            if (depth.has(next))
-                continue;
-            depth.set(next, depth.get(current) + 1);
-            children.get(current).push(next);
-            queue.push(next);
-        }
-    }
-    // A BFS order is a valid topological order of the BFS tree, so walking it
-    // BACKWARDS visits every node after its descendants. That gives leaf counts and
-    // wedge assignment without recursion — a 1,000-deep chain is a plausible graph
-    // and a RangeError is a much worse failure than an ugly picture.
-    const bfsOrder = [...depth.keys()];
-    // Leaf counts drive the wedge widths.
-    const leaves = new Map();
-    for (let i = bfsOrder.length - 1; i >= 0; i--) {
-        const id = bfsOrder[i];
-        const kids = (_d = children.get(id)) !== null && _d !== void 0 ? _d : [];
-        leaves.set(id, kids.length === 0 ? 1 : kids.reduce((sum, kid) => { var _a; return sum + ((_a = leaves.get(kid)) !== null && _a !== void 0 ? _a : 1); }, 0));
-    }
-    // Ring radii: monotone in depth, and wide enough for what sits on them.
-    const perDepth = new Map();
-    for (const node of ordered) {
-        const d = depth.get(node.id);
-        if (d === undefined || d === 0)
-            continue;
-        if (!perDepth.has(d))
-            perDepth.set(d, []);
-        perDepth.get(d).push(node);
-    }
-    const maxDepth = perDepth.size === 0 ? 0 : Math.max(...perDepth.keys());
-    const rootSize = (0, component_packing_1.nodeSize)(byId.get(root));
-    const radii = new Map([[0, 0]]);
-    let previous = Math.max(rootSize.width, rootSize.height) / 2;
-    for (let d = 1; d <= maxDepth; d++) {
-        const onRing = (_e = perDepth.get(d)) !== null && _e !== void 0 ? _e : [];
-        const needed = onRing.reduce((sum, n) => sum + slotOf(n, nodeSpacing), 0) / (2 * Math.PI);
-        const tallest = Math.max(0, ...onRing.map((n) => Math.max((0, component_packing_1.nodeSize)(n).width, (0, component_packing_1.nodeSize)(n).height)));
-        const radius = Math.max(previous + rankSpacing + tallest / 2, needed);
-        radii.set(d, radius);
-        previous = radius + tallest / 2;
-    }
-    // Wedge allocation: a node's children split its slice by leaf count. Pre-order,
-    // on an explicit stack, for the same reason as above.
-    const angles = new Map();
-    const wedges = [
-        { id: root, start: -Math.PI / 2, end: -Math.PI / 2 + 2 * Math.PI },
-    ];
-    while (wedges.length > 0) {
-        const { id, start, end } = wedges.pop();
-        angles.set(id, (start + end) / 2);
-        const kids = (_f = children.get(id)) !== null && _f !== void 0 ? _f : [];
-        if (kids.length === 0)
-            continue;
-        const total = kids.reduce((sum, kid) => { var _a; return sum + ((_a = leaves.get(kid)) !== null && _a !== void 0 ? _a : 1); }, 0);
-        let cursor = start;
-        for (const kid of kids) {
-            const share = (((_g = leaves.get(kid)) !== null && _g !== void 0 ? _g : 1) / total) * (end - start);
-            wedges.push({ id: kid, start: cursor, end: cursor + share });
-            cursor += share;
-        }
-    }
-    const nodePositions = new Map();
-    for (const node of ordered) {
-        const d = depth.get(node.id);
-        // Unreachable nodes cannot happen inside a component (that is what "connected"
-        // means) — but a caller may hand this function a raw graph, so be safe rather
-        // than silently dropping a node.
-        const r = (_h = radii.get(d !== null && d !== void 0 ? d : 0)) !== null && _h !== void 0 ? _h : 0;
-        const angle = (_j = angles.get(node.id)) !== null && _j !== void 0 ? _j : 0;
-        const size = (0, component_packing_1.nodeSize)(node);
-        nodePositions.set(node.id, {
-            x: r * Math.cos(angle) - size.width / 2,
-            y: r * Math.sin(angle) - size.height / 2,
-        });
-    }
-    return {
-        nodePositions,
-        bounds: boundsOf(ordered, nodePositions),
-        metadata: { algorithm: 'radial', executionTime: 0, root, rings: maxDepth },
-    };
-}
-// ---------------------------------------------------------------------------
-// FORCE
-// ---------------------------------------------------------------------------
-/**
- * Force-directed, promoted from a raw adapter passthrough to a first-class named
- * layout.
- *
- * The physics is NOT reimplemented — `ForceLayoutAdapter` already has a
- * Fruchterman-Reingold simulation with a Barnes-Hut quadtree, and Card 0 seeded
- * it. What this adds is what makes it first-class:
- *
- *   • COMPONENT PACKING. Force's own answer to a disconnected graph is to blow
- *     the components apart with repulsion until the picture is mostly whitespace
- *     — gravity only pulls toward a single global centre. Per-component layout
- *     plus packing fixes that properly.
- *   • THE SHARED VOCABULARY. `nodeSpacing`/`rankSpacing` instead of
- *     `repulsion`/`linkDistance`.
- */
-const forceAdapter = new force_layout_adapter_1.ForceLayoutAdapter();
-function forceLayout(nodes, links, options = {}) {
-    const translated = Object.assign({}, options);
-    // Only override the adapter's defaults if the caller actually said something —
-    // otherwise `engine.layout('force')` would silently change behaviour depending
-    // on which spacing default happened to be in scope.
-    if (options.nodeSpacing !== undefined)
-        translated['repulsion'] = options.nodeSpacing;
-    if (options.rankSpacing !== undefined)
-        translated['linkDistance'] = options.rankSpacing;
-    return forceAdapter.apply(nodes, links, translated);
-}
-//# sourceMappingURL=portfolio-layouts.js.map

package/src/libs/engine/src/layout/rng.d.ts

@@ -1,34 +0,0 @@
-/** A seeded, deterministic source of randomness. */
-export interface LayoutRng {
-    /** Uniform in [0, 1). */
-    next(): number;
-    /** Uniform in [min, max). */
-    between(min: number, max: number): number;
-    /** The seed this generator was created with (so a result can report it). */
-    readonly seed: number;
-}
-/**
- * The seed used when a caller asks for a layout without naming one.
- *
- * A FIXED default (not a time-derived one) is the whole point: an author who
- * never thinks about seeds still gets the same picture every time they open
- * their diagram. Randomness is opt-in, by passing a different seed.
- */
-export declare const DEFAULT_LAYOUT_SEED = 24301;
-/** mulberry32 — a small, fast, well-behaved 32-bit PRNG. */
-export declare function createLayoutRng(seed?: number): LayoutRng;
-/**
- * Deterministic order for a set of entities.
- *
- * The second half of reproducibility, and the half that is easy to forget: a
- * seeded PRNG only helps if the graph is CONSUMED in a stable order. Node maps
- * iterate in insertion order, which differs between an authored diagram and the
- * same diagram loaded from JSON — so two "identical" graphs could feed the same
- * seeded generator in different orders and still diverge.
- *
- * Sorting by id makes the input canonical, which is what actually makes the
- * layout idempotent across a save/load round-trip.
- */
-export declare function inStableOrder<T extends {
-    id: string;
-}>(items: readonly T[]): T[];

package/src/libs/engine/src/layout/rng.js

@@ -1,71 +0,0 @@
-"use strict";
-// Wave 7 (Auto-layout) — Card 0: deterministic randomness.
-//
-// Three layout adapters seeded themselves from `Math.random()`:
-//
-//   force-layout-adapter.ts:250   x = (Math.random() - 0.5) * 500
-//   spectral-layout-adapter.ts    (power-iteration start vector)
-//   community-layout-adapter.ts   (label-propagation tie-breaks)
-//
-// So the same graph produced different coordinates on every run. That is not a
-// stylistic complaint: it makes layout untestable (no golden output), it makes a
-// saved diagram unreproducible (reopen it, the picture moves), and it makes the
-// mental-map card (#6) impossible to even define — you cannot minimise movement
-// against a baseline that itself moves.
-//
-// Card 0's contract is: SAME GRAPH + SAME SEED => BYTE-IDENTICAL COORDINATES.
-// This module is how. It is a plain seeded PRNG (mulberry32: 32-bit state, one
-// multiply-xor-shift round — fast, well-distributed enough for layout jitter, and
-// famously short so its behaviour is auditable at a glance).
-//
-// It deliberately does NOT try to be cryptographically anything. Layout wants
-// *reproducible* noise, not *unpredictable* noise.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_LAYOUT_SEED = void 0;
-exports.createLayoutRng = createLayoutRng;
-exports.inStableOrder = inStableOrder;
-/**
- * The seed used when a caller asks for a layout without naming one.
- *
- * A FIXED default (not a time-derived one) is the whole point: an author who
- * never thinks about seeds still gets the same picture every time they open
- * their diagram. Randomness is opt-in, by passing a different seed.
- */
-exports.DEFAULT_LAYOUT_SEED = 0x5eed;
-/** mulberry32 — a small, fast, well-behaved 32-bit PRNG. */
-function createLayoutRng(seed = exports.DEFAULT_LAYOUT_SEED) {
-    // Normalise: NaN/Infinity/negative/fractional seeds must not silently produce
-    // a degenerate generator (a NaN state makes every draw NaN, which lands every
-    // node at the same place and looks like "layout didn't run").
-    let state = Number.isFinite(seed) ? Math.floor(Math.abs(seed)) >>> 0 : exports.DEFAULT_LAYOUT_SEED;
-    if (state === 0)
-        state = exports.DEFAULT_LAYOUT_SEED;
-    const next = () => {
-        state = (state + 0x6d2b79f5) >>> 0;
-        let t = state;
-        t = Math.imul(t ^ (t >>> 15), t | 1);
-        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
-        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
-    };
-    return {
-        seed,
-        next,
-        between: (min, max) => min + next() * (max - min),
-    };
-}
-/**
- * Deterministic order for a set of entities.
- *
- * The second half of reproducibility, and the half that is easy to forget: a
- * seeded PRNG only helps if the graph is CONSUMED in a stable order. Node maps
- * iterate in insertion order, which differs between an authored diagram and the
- * same diagram loaded from JSON — so two "identical" graphs could feed the same
- * seeded generator in different orders and still diverge.
- *
- * Sorting by id makes the input canonical, which is what actually makes the
- * layout idempotent across a save/load round-trip.
- */
-function inStableOrder(items) {
-    return [...items].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
-}
-//# sourceMappingURL=rng.js.map

package/src/libs/engine/src/layout/spectral-layout-adapter.d.ts

@@ -1,72 +0,0 @@
-/**
- * Spectral Layout Adapter
- *
- * Uses graph spectral theory (eigenvalues/eigenvectors) for optimal node placement.
- * Minimizes edge crossings and preserves graph symmetry mathematically.
- *
- * Best for:
- * - Circuit diagrams
- * - Network topology
- * - Symmetric graphs
- * - Mathematical optimization
- *
- * Algorithm: Graph Laplacian spectral decomposition
- *
- * @module layout/spectral-layout-adapter
- */
-import { NodeModel } from '../models/NodeModel';
-import { LinkModel } from '../models/LinkModel';
-import { LayoutAdapter, LayoutOptions, LayoutResult } from './layout-adapter.interface';
-/**
- * Spectral layout options
- */
-export interface SpectralLayoutOptions extends LayoutOptions {
-    /** Use normalized Laplacian (default: true) */
-    normalized?: boolean;
-    /** Number of dimensions to compute (default: 2) */
-    dimensions?: number;
-    /** Scale factor for positions (default: 500) */
-    scale?: number;
-    /** Center the layout (default: true) */
-    center?: boolean;
-    /** Power iteration convergence threshold (default: 1e-6) */
-    convergenceThreshold?: number;
-    /** Maximum power iterations (default: 1000) */
-    maxIterations?: number;
-}
-/**
- * Spectral Layout Adapter
- *
- * Uses eigendecomposition of graph Laplacian for optimal layout.
- */
-export declare class SpectralLayoutAdapter implements LayoutAdapter {
-    readonly name = "spectral";
-    /**
-     * Card 0: the run's seeded generator. Established once per apply() so every
-     * helper below draws from the SAME reproducible stream — the seed alone is not
-     * enough if each helper mints its own generator.
-     */
-    private rng;
-    /**
-     * Apply spectral layout
-     */
-    apply(nodes: NodeModel[], links: LinkModel[], options?: Partial<SpectralLayoutOptions>): Promise<LayoutResult>;
-    /**
-     * Compute eigenvector using power iteration
-     */
-    private computeEigenvector;
-    /**
-     * Calculate bounding box
-     */
-    private calculateBounds;
-    /**
-     * Apply incremental layout (Phase 1 compatibility)
-     */
-    applyIncremental(nodes: NodeModel[], links: LinkModel[], incrementalOptions: any, layoutOptions?: Partial<SpectralLayoutOptions>): Promise<LayoutResult & {
-        incremental: any;
-    }>;
-    /**
-     * Validate options
-     */
-    validateOptions(options: Partial<SpectralLayoutOptions>): boolean;
-}