@grafloria/element 0.3.18 → 0.3.20

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

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

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