@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/layout/layout-host.js

@@ -1,523 +0,0 @@
-"use strict";
-// Wave 7 (Auto-layout) — Card 3: the worker seam for layout.
-//
-// Direct descendant of routing/global/solver-host.ts (wave 5, card 7), which
-// solved the identical shape and shipped. Same three ideas, and they are the
-// reason this file is short:
-//
-//   • the algorithm stays PURE and SYNCHRONOUS, so the same code runs on both
-//     sides of the boundary and cannot drift;
-//   • `serveLayout(port)` IS the worker body — a message loop, nothing more;
-//   • the inline fallback LOOPS THROUGH THE SAME MESSAGE LOOP, so the protocol
-//     is exercised even in-process. There is one code path, not two, and a test
-//     proves the two produce byte-identical coordinates.
-//
-// And, as there: this host does NOT construct the Worker. Doing so would bake
-// one bundler's URL scheme into the engine — which is precisely the mistake the
-// old `LayoutWorkerPool` made (`new Worker('/assets/workers/layout.worker.js')`,
-// a path that no build in this repo has ever produced). The caller builds the
-// worker however its toolchain likes and hands the port in.
-//
-// WHAT THIS CARD ADDS OVER THE ROUTING PRECEDENT
-// -----------------------------------------------
-// Streaming progress, mid-run cancellation, time budgets, and partial results.
-//
-// The load-bearing one is PARTIAL RESULTS. A force layout cancelled after 200 of
-// 300 iterations has a perfectly usable picture. Throwing it away — which is what
-// the old `LayoutWorkerPool.cancelRequest()` did, by *rejecting* the promise — is
-// the difference between a tool that feels alive and one that feels broken.
-//
-// THE TRAP THAT MAKES NAIVE WORKER CANCELLATION A LIE
-// ---------------------------------------------------
-// A worker is single-threaded. While it runs a synchronous 300-iteration loop it
-// is NOT reading its message queue, so the `cancel` you posted sits there
-// undelivered until the loop it was meant to interrupt has finished. Setting a
-// flag from `onmessage` cannot possibly work; the old worker script even admitted
-// it in a comment ("we set the flag and hope the algorithm checks it").
-//
-// The fix is to make the run YIELD TO THE EVENT LOOP periodically, so pending
-// messages actually get delivered. Hence `sliceMs`: we compute for a slice, then
-// surrender the thread long enough for the queue to drain, then check the flag.
-// Cancellation latency is one slice, not one layout. (The alternative — a
-// SharedArrayBuffer the loop polls — needs cross-origin isolation headers, so it
-// is not a default we can rely on.)
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LayoutHost = void 0;
-exports.serveLayout = serveLayout;
-const tslib_1 = require("tslib");
-const component_packing_1 = require("./component-packing");
-const steppable_layout_1 = require("./steppable-layout");
-const layout_graph_1 = require("./layout-graph");
-const layout_registry_1 = require("./layout-registry");
-const layout_quality_metrics_1 = require("./layout-quality-metrics");
-// ---------------------------------------------------------------------------
-// The worker body.
-// ---------------------------------------------------------------------------
-/** How long to compute between surrenders of the thread. See the trap, above. */
-const DEFAULT_SLICE_MS = 12;
-/** Progress messages: at most one per ~frame… */
-const PROGRESS_EMIT_MIN_MS = 16;
-/** …unless the run advanced ≥10% since the last one (keeps FAST runs streamy). */
-const PROGRESS_EMIT_MIN_DELTA = 0.1;
-/**
- * Surrender the thread just long enough for queued messages to be delivered.
- *
- * MessageChannel rather than `setTimeout(0)`: nested timeouts get clamped to 4ms
- * by every browser, and paying 4ms per slice would cost more than the layout.
- */
-function yieldToEventLoop() {
-    return new Promise((resolve) => {
-        if (typeof MessageChannel !== 'undefined') {
-            const channel = new MessageChannel();
-            channel.port1.onmessage = () => {
-                channel.port1.close();
-                resolve();
-            };
-            channel.port2.postMessage(0);
-        }
-        else {
-            setTimeout(resolve, 0);
-        }
-    });
-}
-/**
- * The worker's own resolver: build an adapter the first time it is named, and
- * never build one that is not.
- *
- * LAZY ON PURPOSE. Eagerly constructing the built-ins means constructing ELK,
- * and elkjs's constructor spawns its own nested Worker — which inside a Worker
- * throws `_Worker is not a constructor` and kills the layout worker on the very
- * line that starts it. See createBuiltInLayoutFactories().
- *
- * (ELK therefore remains a main-thread algorithm in practice — no great loss:
- * elkjs already offloads itself to a worker of its own, so it never blocked the
- * main thread the way dagre and force do.)
- */
-function defaultResolver() {
-    const factories = (0, layout_registry_1.createBuiltInLayoutFactories)();
-    const built = new Map();
-    return (name) => {
-        const existing = built.get(name);
-        if (existing)
-            return existing;
-        const make = factories.get(name);
-        if (!make)
-            return undefined;
-        // MERGE (Cards 2 + 3): every algorithm the host runs is wrapped in COMPONENT
-        // PACKING before it is handed anything.
-        //
-        // Card 2 made packing a property of every registered layout by wrapping
-        // `apply(diagram)`. Card 3 then routed the flat path through this host, which
-        // ships `(nodes, links)` and runs the RAW adapter — stepping neatly around the
-        // wrapper. A disconnected graph promptly went back to laying its components on
-        // top of each other, which is precisely the bug Card 2 exists to kill (and its
-        // forest tests caught it the moment the two branches met).
-        //
-        // Wrapping here rather than at the call site means the INLINE and the WORKER
-        // paths pack identically — the same one-protocol discipline the rest of this
-        // file is built on. Packing is a provable no-op for a connected graph, so this
-        // costs nothing when there is nothing to pack.
-        const raw = make();
-        // Object.create, NOT a spread. Spreading a class instance copies only its OWN
-        // properties, so `step()`/`snapshot()` — which live on the prototype — vanish,
-        // `isSteppable()` goes false, and force silently drops off the steppable path
-        // onto the opaque one: no progress, no cancellation, no partial result. (That
-        // is exactly what happened when these two branches first met, and Card 3's own
-        // tests caught it.) Delegating through the prototype keeps the algorithm whole
-        // and overrides only `apply`.
-        const adapter = Object.create(raw);
-        adapter.apply = (nodes, links, options) => (0, component_packing_1.layoutWithComponentPacking)(raw.name, (n, l, o) => raw.apply(n, l, o), nodes, links, (options !== null && options !== void 0 ? options : {}));
-        built.set(name, adapter);
-        return adapter;
-    };
-}
-/**
- * Serve layout requests on a port. This IS the worker's message loop — call it
- * inside the worker script with `self`, or in a test with a fake port, or (see
- * `LayoutHost`) on the inline side of a loopback pair.
- */
-function serveLayout(port, deps = {}) {
-    var _a, _b;
-    const resolve = (_a = deps.resolve) !== null && _a !== void 0 ? _a : defaultResolver();
-    const now = (_b = deps.now) !== null && _b !== void 0 ? _b : (() => Date.now());
-    // Cancels are recorded by seq, NOT applied to "the current run". A cancel can
-    // legitimately arrive before its run does (the host sends one up-front when it
-    // is handed an already-aborted signal), and message order is preserved across
-    // a real port — so remembering it is both correct and simpler than racing.
-    const cancelled = new Set();
-    port.onmessage = (event) => {
-        const request = event.data;
-        if (request.kind === 'cancel') {
-            cancelled.add(request.target);
-            return;
-        }
-        void run(request);
-    };
-    function run(request) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { seq } = request;
-            try {
-                // Resolution can THROW, not merely return undefined: an adapter is
-                // constructed here, and construction can fail for reasons peculiar to the
-                // thread we are on (ELK's does, inside a Worker). A bare rethrow would
-                // surface as "_Worker is not a constructor" with no clue which layout or
-                // why — so name it.
-                let adapter;
-                try {
-                    adapter = resolve(request.algorithm);
-                }
-                catch (constructionError) {
-                    const detail = constructionError instanceof Error
-                        ? constructionError.message
-                        : String(constructionError);
-                    port.postMessage({
-                        seq,
-                        kind: 'error',
-                        message: `Layout '${request.algorithm}' could not be constructed in this context: ${detail}`,
-                    });
-                    return;
-                }
-                if (!adapter) {
-                    port.postMessage({
-                        seq,
-                        kind: 'error',
-                        message: `Unknown layout '${request.algorithm}'`,
-                    });
-                    return;
-                }
-                const { nodes, links } = (0, layout_graph_1.reviveGraph)(request.graph);
-                const sliceMs = (_a = request.sliceMs) !== null && _a !== void 0 ? _a : DEFAULT_SLICE_MS;
-                const startedAt = now();
-                const emit = (progress, phase, iteration, totalIterations) => {
-                    port.postMessage({
-                        seq,
-                        kind: 'progress',
-                        progress,
-                        phase,
-                        iteration,
-                        totalIterations,
-                    });
-                };
-                const finish = (result, partial, reason, iteration, totalIterations) => {
-                    cancelled.delete(seq);
-                    port.postMessage({
-                        seq,
-                        kind: 'result',
-                        algorithm: request.algorithm,
-                        positions: [...result.nodePositions],
-                        bounds: result.bounds,
-                        partial,
-                        reason,
-                        iteration,
-                        totalIterations,
-                        metadata: result.metadata,
-                        quality: result.quality,
-                        portAware: result.portAware,
-                        subgraph: result.subgraph,
-                        edgeBundling: result.edgeBundling,
-                    });
-                };
-                // -- The interruptible path -------------------------------------------
-                //
-                // TWO CARDS MEET HERE, AND ONE HAS TO YIELD. A steppable algorithm is driven
-                // through step()/snapshot(), which BYPASSES apply() — and apply() is where
-                // Card 2's component packing lives. So a disconnected graph run on the
-                // steppable path comes back with its components laid on top of each other:
-                // exactly the bug packing exists to kill.
-                //
-                // A forest therefore takes the packed path even when the algorithm could have
-                // been interrupted. The trade is stated rather than hidden: you lose mid-run
-                // cancellation on a DISCONNECTED force layout (it still runs off the main
-                // thread, and can still be cancelled before it starts), and you keep a picture
-                // that is actually readable. A connected graph — the overwhelmingly common
-                // case, and the one where a long force run actually hurts — is unaffected.
-                const componentCount = (0, component_packing_1.findConnectedComponents)(nodes, links).length;
-                if ((0, steppable_layout_1.isSteppable)(adapter) && componentCount <= 1) {
-                    const layoutRun = adapter.createRun(nodes, links, request.options);
-                    const total = layoutRun.totalIterations;
-                    emit(0, 'start', 0, total);
-                    let stop;
-                    let sliceStart = now();
-                    // Progress EMISSION is throttled independently of the YIELD cadence.
-                    // Found live: coupling them meant sliceMs:0 (maximal preemptibility)
-                    // posted one progress message PER ITERATION — ~4000 for a long force
-                    // run — flooding the caller's event loop so badly that a setTimeout
-                    // abort on the main thread fired only after the run had already
-                    // finished: signal cancellation raced, machine-speed dependent. The
-                    // yield IS the cancellation contract and stays per-slice; a progress
-                    // message is only worth sending every ~frame or every 10% of the run.
-                    let lastEmitAt = now();
-                    let lastEmitProgress = 0;
-                    for (;;) {
-                        if (cancelled.has(seq)) {
-                            stop = 'cancelled';
-                            break;
-                        }
-                        if (request.stopAfterIteration !== undefined &&
-                            layoutRun.iteration >= request.stopAfterIteration) {
-                            stop = 'iteration-cap';
-                            break;
-                        }
-                        if (request.timeBudgetMs !== undefined &&
-                            now() - startedAt >= request.timeBudgetMs) {
-                            stop = 'timeout';
-                            break;
-                        }
-                        if (!layoutRun.step())
-                            break; // converged, or hit the iteration cap
-                        // Slice boundary: surrender the thread so a `cancel` can actually be
-                        // delivered — and stream a progress event only when it is DUE
-                        // (≥ PROGRESS_EMIT_MIN_MS since the last one, or ≥ 10% more of the
-                        // run done), never per-slice.
-                        if (now() - sliceStart >= sliceMs) {
-                            const progressNow = total > 0 ? Math.min(layoutRun.iteration / total, 1) : 1;
-                            if (now() - lastEmitAt >= PROGRESS_EMIT_MIN_MS ||
-                                progressNow - lastEmitProgress >= PROGRESS_EMIT_MIN_DELTA) {
-                                emit(progressNow, 'iterating', layoutRun.iteration, total);
-                                lastEmitAt = now();
-                                lastEmitProgress = progressNow;
-                            }
-                            yield yieldToEventLoop();
-                            sliceStart = now();
-                        }
-                    }
-                    // A final progress event, always: consumers watch the stream reach its
-                    // true end value (a completed run must reach exactly 1 — the off-thread
-                    // demo asserts it), and the throttle above may have held the last one.
-                    emit(total > 0 ? Math.min(layoutRun.iteration / total, 1) : 1, 'iterating', layoutRun.iteration, total);
-                    // snapshot() is valid after ANY number of steps — including zero. This
-                    // is the whole point: a cancelled run hands back what it has.
-                    const result = layoutRun.snapshot();
-                    // ------------------------------------------------------------------
-                    // wave10/gallery — BUG FIX. Separate the boxes the simulation left on
-                    // top of each other.
-                    //
-                    // This branch bypasses `adapter.apply()` on purpose — it has to, because
-                    // `apply()` is one opaque call and this path exists to step, report and
-                    // cancel. But `apply()` is where the overlap pass lived, so bypassing it
-                    // silently bypassed that too.
-                    //
-                    // FORCE IS THE ONLY STEPPABLE BUILT-IN. So the single algorithm that
-                    // actually needs overlap removal — force lays out dimensionless POINTS —
-                    // was the single algorithm that never received it, and
-                    // `engine.layout('force')` returned intersecting node boxes. Every unit
-                    // test stayed green: they all reach force through `apply()`.
-                    //
-                    // Applied to the PARTIAL result too, deliberately. A cancelled force run
-                    // is meant to leave "a real, coherent picture" behind (see
-                    // commitLayoutPositions) — a pile of stacked boxes is not one.
-                    // ------------------------------------------------------------------
-                    (0, component_packing_1.separateOverlappingNodes)(nodes, result.nodePositions, request.options);
-                    result.bounds = boundsOfPositions(nodes, result.nodePositions);
-                    // `calculateQuality` must mean the same thing on both paths. The steppable
-                    // adapters compute it in `apply()`, which we bypass here, so compute it
-                    // the same way — against the positions we actually ended on, partial or
-                    // not. (Assessing a best-so-far layout is if anything more useful: it is
-                    // how a caller decides whether the partial answer is worth keeping.)
-                    if (request.options.calculateQuality) {
-                        for (const node of nodes) {
-                            const position = result.nodePositions.get(node.id);
-                            if (position)
-                                node.setPosition(position.x, position.y);
-                        }
-                        result.quality = layout_quality_metrics_1.LayoutQualityMetrics.assess(nodes, links, {
-                            includeSuggestions: true,
-                            canvasDimensions: request.options.canvasDimensions,
-                        });
-                    }
-                    emit(stop ? Math.min(layoutRun.iteration / (total || 1), 1) : 1, stop !== null && stop !== void 0 ? stop : 'done', layoutRun.iteration, total);
-                    finish(result, stop !== undefined, stop, layoutRun.iteration, total);
-                    return;
-                }
-                // -- The opaque path (dagre, ELK, spectral, community) ------------------
-                //
-                // One shot into third-party code; there is no honest way to interrupt it
-                // mid-call. It still runs OFF THE MAIN THREAD, which is the actual win —
-                // a 500ms dagre pass no longer freezes input. What we cannot do is stop it
-                // half-way, so we check for cancellation at the only boundaries that exist.
-                emit(0, 'start', 0, 1);
-                if (cancelled.has(seq)) {
-                    // Never started: the best-so-far is the graph exactly as it came in.
-                    finish(unchanged(request.graph), true, 'cancelled', 0, 1);
-                    return;
-                }
-                const result = yield adapter.apply(nodes, links, request.options);
-                emit(1, 'done', 1, 1);
-                finish(result, false, undefined, 1, 1);
-            }
-            catch (error) {
-                cancelled.delete(seq);
-                port.postMessage({
-                    seq,
-                    kind: 'error',
-                    message: error instanceof Error ? error.message : String(error),
-                });
-            }
-        });
-    }
-}
-/**
- * The bounding box of `positions`, using each node's real size.
- *
- * Needed because the overlap pass MOVES boxes: a `bounds` computed by the
- * algorithm before separation is stale the moment anything is pushed apart, and a
- * caller that fits the camera to it would clip the diagram it just laid out.
- */
-function boundsOfPositions(nodes, positions) {
-    var _a, _b, _c, _d;
-    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;
-        minX = Math.min(minX, p.x);
-        minY = Math.min(minY, p.y);
-        maxX = Math.max(maxX, p.x + ((_b = (_a = node.size) === null || _a === void 0 ? void 0 : _a.width) !== null && _b !== void 0 ? _b : 0));
-        maxY = Math.max(maxY, p.y + ((_d = (_c = node.size) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0));
-    }
-    if (!Number.isFinite(minX))
-        return { x: 0, y: 0, width: 0, height: 0 };
-    return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-}
-/** The identity layout: every node exactly where it already was. */
-function unchanged(graph) {
-    const nodePositions = new Map();
-    for (const node of graph.nodes) {
-        nodePositions.set(node.id, { x: node.position.x, y: node.position.y });
-    }
-    const xs = graph.nodes.map((n) => n.position.x);
-    const ys = graph.nodes.map((n) => n.position.y);
-    const rights = graph.nodes.map((n) => n.position.x + n.size.width);
-    const bottoms = graph.nodes.map((n) => n.position.y + n.size.height);
-    const x = xs.length ? Math.min(...xs) : 0;
-    const y = ys.length ? Math.min(...ys) : 0;
-    return {
-        nodePositions,
-        bounds: {
-            x,
-            y,
-            width: rights.length ? Math.max(...rights) - x : 0,
-            height: bottoms.length ? Math.max(...bottoms) - y : 0,
-        },
-        metadata: { algorithm: 'unchanged', executionTime: 0 },
-    };
-}
-/**
- * The caller-side host.
- *
- * Pass a real Worker (or anything satisfying `LayoutPort`) to run off-thread;
- * pass nothing to run inline on the same thread. Identical behaviour, no protocol
- * drift, because BOTH paths speak through `serveLayout`.
- */
-class LayoutHost {
-    constructor(port, deps = {}) {
-        this.seq = 0;
-        this.pending = new Map();
-        if (port) {
-            this.port = port;
-        }
-        else {
-            // Inline fallback: a loopback "port" pair served by the same loop the
-            // worker would run. The protocol is exercised even in-process, which is
-            // what stops the two paths from drifting — and is what makes the
-            // worker-vs-inline determinism test meaningful rather than tautological.
-            const hostSide = { postMessage: () => void 0, onmessage: null };
-            const workerSide = {
-                onmessage: null,
-                postMessage: (msg) => { var _a; return (_a = hostSide.onmessage) === null || _a === void 0 ? void 0 : _a.call(hostSide, { data: msg }); },
-            };
-            serveLayout(workerSide, deps);
-            hostSide.postMessage = (msg) => { var _a; return (_a = workerSide.onmessage) === null || _a === void 0 ? void 0 : _a.call(workerSide, { data: msg }); };
-            this.port = hostSide;
-        }
-        this.port.onmessage = (event) => {
-            var _a;
-            const message = event.data;
-            const entry = this.pending.get(message.seq);
-            if (!entry)
-                return;
-            if (message.kind === 'progress') {
-                (_a = entry.onProgress) === null || _a === void 0 ? void 0 : _a.call(entry, {
-                    progress: message.progress,
-                    phase: message.phase,
-                    iteration: message.iteration,
-                    totalIterations: message.totalIterations,
-                });
-                return;
-            }
-            this.pending.delete(message.seq);
-            if (message.kind === 'error') {
-                entry.reject(new Error(message.message));
-                return;
-            }
-            entry.resolve({
-                algorithm: message.algorithm,
-                nodePositions: new Map(message.positions),
-                bounds: message.bounds,
-                partial: message.partial,
-                reason: message.reason,
-                iteration: message.iteration,
-                totalIterations: message.totalIterations,
-                metadata: message.metadata,
-                quality: message.quality,
-                portAware: message.portAware,
-                subgraph: message.subgraph,
-                edgeBundling: message.edgeBundling,
-            });
-        };
-    }
-    run(algorithm, graph, options = {}, runOptions = {}) {
-        const seq = ++this.seq;
-        const { signal, onProgress, timeBudgetMs, sliceMs, stopAfterIteration } = runOptions;
-        return new Promise((resolve, reject) => {
-            this.pending.set(seq, { resolve, reject, onProgress });
-            // An already-aborted signal cancels the run BEFORE it is posted. Message
-            // order is preserved across a real port, so the server sees the cancel
-            // first and the run returns a zero-iteration partial rather than burning
-            // a slice of work that nobody wants.
-            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
-                this.port.postMessage({ seq: 0, kind: 'cancel', target: seq });
-            }
-            signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
-                if (this.pending.has(seq)) {
-                    this.port.postMessage({ seq: 0, kind: 'cancel', target: seq });
-                }
-            });
-            this.port.postMessage({
-                seq,
-                kind: 'run',
-                algorithm,
-                graph,
-                options: stripNonClonable(options),
-                timeBudgetMs,
-                sliceMs,
-                stopAfterIteration,
-            });
-        });
-    }
-}
-exports.LayoutHost = LayoutHost;
-/**
- * Drop anything that structured clone would choke on.
- *
- * Callers hand `engine.layout()` one options bag, and it is entirely reasonable
- * for that bag to carry a callback. Posting one to a real Worker throws
- * DataCloneError — a crash that only appears once someone actually enables the
- * worker, i.e. exactly the bug that ships. Strip at the seam instead.
- */
-function stripNonClonable(options) {
-    const out = {};
-    for (const [key, value] of Object.entries(options)) {
-        if (typeof value === 'function')
-            continue;
-        if (typeof AbortSignal !== 'undefined' && value instanceof AbortSignal)
-            continue;
-        out[key] = value;
-    }
-    return out;
-}
-//# sourceMappingURL=layout-host.js.map

package/src/libs/engine/src/layout/layout-presets.d.ts

@@ -1,91 +0,0 @@
-/**
- * Layout Presets Library
- *
- * Pre-configured layout settings for common diagram scenarios.
- * Includes both layout options and constraint configurations.
- */
-import { DagreLayoutOptions } from './dagre-layout-adapter';
-import { ELKLayoutOptions } from './elk-layout-adapter';
-import { LayoutConstraints } from './layout-constraints.interface';
-import { IncrementalLayoutOptions } from './incremental-layout.interface';
-/**
- * Layout preset configuration
- */
-export interface LayoutPreset {
-    /** Unique identifier for the preset */
-    id: string;
-    /** Human-readable name */
-    name: string;
-    /** Description of when to use this preset */
-    description: string;
-    /** Which adapter to use */
-    adapter: 'dagre' | 'elk';
-    /** Layout options for the adapter */
-    options: Partial<DagreLayoutOptions> | Partial<ELKLayoutOptions>;
-    /** Optional pre-configured constraints */
-    constraints?: LayoutConstraints;
-    /** Optional incremental layout settings */
-    incrementalOptions?: Partial<IncrementalLayoutOptions>;
-    /** Tags for categorization */
-    tags?: string[];
-}
-/**
- * Category of layout presets
- */
-export interface LayoutPresetCategory {
-    /** Category name */
-    name: string;
-    /** Category description */
-    description: string;
-    /** Presets in this category */
-    presets: LayoutPreset[];
-}
-/**
- * Predefined layout presets for common scenarios
- */
-export declare class LayoutPresets {
-    /**
-     * Organizational/Hierarchical Layouts
-     */
-    static readonly HIERARCHICAL: LayoutPresetCategory;
-    /**
-     * Process/Flow Layouts
-     */
-    static readonly FLOW: LayoutPresetCategory;
-    /**
-     * Network/Graph Layouts
-     */
-    static readonly NETWORK: LayoutPresetCategory;
-    /**
-     * Architecture/System Layouts
-     */
-    static readonly ARCHITECTURE: LayoutPresetCategory;
-    /**
-     * Interactive/Dashboard Layouts
-     */
-    static readonly INTERACTIVE: LayoutPresetCategory;
-    /**
-     * Get all preset categories
-     */
-    static getAllCategories(): LayoutPresetCategory[];
-    /**
-     * Get all presets across all categories
-     */
-    static getAllPresets(): LayoutPreset[];
-    /**
-     * Find preset by ID
-     */
-    static findPreset(id: string): LayoutPreset | undefined;
-    /**
-     * Find presets by tag
-     */
-    static findPresetsByTag(tag: string): LayoutPreset[];
-    /**
-     * Find presets by adapter type
-     */
-    static findPresetsByAdapter(adapter: 'dagre' | 'elk'): LayoutPreset[];
-    /**
-     * Search presets by name or description
-     */
-    static searchPresets(query: string): LayoutPreset[];
-}