@grafloria/element 0.3.18 → 0.3.20

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

@@ -0,0 +1,388 @@
+"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

@@ -0,0 +1,34 @@
+/** 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

@@ -0,0 +1,71 @@
+"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

@@ -0,0 +1,72 @@
+/**
+ * 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;
+}