@statelyai/layout 0.0.5 → 0.1.0

package/README.md

@@ -71,6 +71,10 @@ The adapter accepts ELK JSON and option aliases, translates to
 `@statelyai/graph`, runs native algorithms, and translates the result back.
 Native algorithms never consume ELK JSON directly.
 
+<!-- fixed-port placement and inline center-label guarantees from src/layered/index.ts and src/layered/strategies.ts -->
+
+Fixed port sides constrain routes without collapsing fan-out targets onto each other. Port preferences cannot reintroduce cycles before layering. Inline center labels use reserved inter-rank space; dedicated label layers and route-track compaction retain their placement strategies. Inline self-loop labels reserve clearance on their assigned sides from both their owner and neighboring nodes. Hierarchy decomposition preserves native self-loop routes for ancestor-to-descendant edges. FIRST/FIRST_SEPARATE nodes may have self-loops.
+
 Advanced layered settings use shorter names such as
 `layering.strategy`, `spacing.edgeNode`, and `nodePlacement.strategy`.
 `toElkLayeredOptions` and `fromElkLayeredOptionId` provide the exact one-to-one
@@ -166,3 +170,13 @@ workflow opens or updates a version pull request. Merging that pull request
 publishes the package to npm and creates the GitHub release and tag.
 
 Publishing uses npm Trusted Publishing through `.github/workflows/release.yml`.
+
+## Statechart reading order
+
+<!-- statechart policy API from src/elkjs/statechart.ts -->
+
+The opt-in `layoutStatechart` export from `@statelyai/layout/elkjs` compiles
+initial-state and preferred-path hints into scoped settings, then selects among
+at most three fresh layout attempts. It returns all quality scores, including
+remaining defects. See [statechart policies](docs/statechart-layout.md) for the
+API, supported controls, tradeoffs and reproducible visual comparison.

package/dist/elkjs/index.d.mts

@@ -86,6 +86,49 @@ type LaidOutElkNode<T extends ElkNode> = Omit<T, "children" | "edges"> & Omit<El
   edges?: Array<NonNullable<T["edges"]>[number] & ElkEdge>;
 };
 //#endregion
+//#region src/elkjs/statechart.d.ts
+interface StatechartScope {
+  /** Direct child of this container; never inferred from state names. */
+  initialNodeId?: ElkId;
+  /** Connected direct-child path. Explicit paths resolve branching ambiguity. */
+  preferredPath?: readonly ElkId[];
+  direction?: "UP" | "DOWN" | "LEFT" | "RIGHT";
+}
+interface StatechartLayoutOptions {
+  scopes: Readonly<Record<string, StatechartScope>>;
+  /** Total engine calls, including baseline; integer from 1 to 3. Default 3. */
+  maxAttempts?: number;
+}
+interface StatechartLayoutScore {
+  invalid: number;
+  overlaps: number;
+  pathOrder: number;
+  crossings: number;
+  bends: number;
+  routeLength: number;
+}
+interface StatechartLayoutPlan {
+  graph: ElkNode;
+  paths: Record<string, ElkId[]>;
+  commonExits: Record<string, ElkId[]>;
+}
+/** Compile semantic hints into settings implemented by this package's ELK adapter. */
+declare function compileStatechartLayout(input: ElkNode, scopes: StatechartLayoutOptions["scopes"]): StatechartLayoutPlan;
+/** Diagnostic objective, not a proof of geometric validity. Coordinates are container-relative. */
+declare function scoreStatechartLayout(graph: ElkNode, paths?: StatechartLayoutPlan["paths"]): StatechartLayoutScore;
+/** Each attempt starts from original input. No post-layout geometry edits. */
+declare function layoutStatechart<T extends ElkNode>(input: T, options: StatechartLayoutOptions): Promise<{
+  attempts: {
+    kind: "baseline" | "policy" | "spacing";
+    score: StatechartLayoutScore;
+  }[];
+  paths: Record<string, ElkId[]>;
+  commonExits: Record<string, ElkId[]>;
+  graph: LaidOutElkNode<T>;
+  score: StatechartLayoutScore;
+  attempt: number;
+}>;
+//#endregion
 //#region src/elkjs/index.d.ts
 declare class ELK {
   #private;
@@ -97,4 +140,4 @@ declare class ELK {
   layout<T extends ElkNode>(graph: T, arguments_?: ElkLayoutArguments): Promise<LaidOutElkNode<T>>;
 }
 //#endregion
-export { type ElkCommonDescription, type ElkConstructorArguments, type ElkEdge, type ElkEdgeSection, type ElkGraphElement, type ElkId, type ElkLabel, type ElkLayoutAlgorithmDescription, type ElkLayoutArguments, type ElkLayoutCategoryDescription, type ElkLayoutOptionDescription, type ElkLogging, type ElkNode, type ElkPoint, type ElkPort, type ElkShape, type LaidOutElkNode, ELK as default };
+export { type ElkCommonDescription, type ElkConstructorArguments, type ElkEdge, type ElkEdgeSection, type ElkGraphElement, type ElkId, type ElkLabel, type ElkLayoutAlgorithmDescription, type ElkLayoutArguments, type ElkLayoutCategoryDescription, type ElkLayoutOptionDescription, type ElkLogging, type ElkNode, type ElkPoint, type ElkPort, type ElkShape, type LaidOutElkNode, type StatechartLayoutOptions, type StatechartLayoutPlan, type StatechartLayoutScore, type StatechartScope, compileStatechartLayout, ELK as default, layoutStatechart, scoreStatechartLayout };

package/dist/elkjs/index.mjs

@@ -1,7 +1,266 @@
-import { o as elkLayeredOptionDefinitions, t as getLayeredLayout } from "../layered-BYhTymAk.mjs";
-import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-B504wOFR.mjs";
+import { o as elkLayeredOptionDefinitions, t as getLayeredLayout } from "../layered-CZs9YWVx.mjs";
+import { a as getRandomLayout, f as getFixedLayout, n as getSporeOverlapRemovalLayout, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "../spore-9N0W9dZn.mjs";
 import { createGraph } from "@statelyai/graph";
 
+//#region src/elkjs/statechart.ts
+function option(node, suffix) {
+	const settings = {
+		...node.properties,
+		...node.layoutOptions
+	};
+	return settings[suffix] ?? settings[`elk.${suffix}`] ?? settings[`org.eclipse.elk.${suffix}`];
+}
+const endpoint$1 = (edge, source) => source ? edge.sources?.[0] ?? edge.source : edge.targets?.[0] ?? edge.target;
+/** Compile semantic hints into settings implemented by this package's ELK adapter. */
+function compileStatechartLayout(input, scopes) {
+	const graph = structuredClone(input);
+	const paths = Object.create(null);
+	const commonExits = Object.create(null);
+	const containers = /* @__PURE__ */ new Map();
+	const edges = [];
+	const collect = (node) => {
+		if (node.id === void 0 || containers.has(String(node.id))) throw new Error("Statechart nodes require unique IDs");
+		containers.set(String(node.id), node);
+		edges.push(...node.edges ?? []);
+		node.children?.forEach(collect);
+	};
+	collect(graph);
+	for (const [id, scope] of Object.entries(scopes)) {
+		const container = containers.get(id);
+		if (!container) throw new Error(`Unknown statechart container: ${id}`);
+		const children = container.children ?? [];
+		const ids = new Set(children.map((node) => node.id));
+		const owner = /* @__PURE__ */ new Map();
+		const own = (node, childId) => {
+			owner.set(node.id, childId);
+			node.ports?.forEach((port) => owner.set(port.id, childId));
+			node.children?.forEach((descendant) => own(descendant, childId));
+		};
+		children.forEach((child) => own(child, child.id));
+		const localEdges = edges.filter((edge) => owner.has(endpoint$1(edge, true)) && owner.has(endpoint$1(edge, false)));
+		const successors = new Map(children.map((node) => [node.id, /* @__PURE__ */ new Set()]));
+		const predecessors = new Map(children.map((node) => [node.id, /* @__PURE__ */ new Set()]));
+		for (const edge of localEdges) {
+			const source = owner.get(endpoint$1(edge, true));
+			const target = owner.get(endpoint$1(edge, false));
+			if (source === target) continue;
+			successors.get(source).add(target);
+			predecessors.get(target).add(source);
+		}
+		const exits = children.filter((node) => successors.get(node.id).size === 0 && predecessors.get(node.id).size >= 2).map((node) => node.id);
+		commonExits[id] = exits;
+		const path = [...scope.preferredPath ?? (scope.initialNodeId === void 0 ? [] : [scope.initialNodeId])];
+		if (new Set(path).size !== path.length || path.some((nodeId) => !ids.has(nodeId))) throw new Error(`Path must contain distinct direct children of ${id}`);
+		if (scope.initialNodeId !== void 0 && (!ids.has(scope.initialNodeId) || path[0] !== scope.initialNodeId)) throw new Error(`Path must start at initial child of ${id}`);
+		if (scope.preferredPath) {
+			for (let i = 1; i < path.length; i++) if (!successors.get(path[i - 1])?.has(path[i])) throw new Error(`Disconnected preferred path in ${id}`);
+		} else while (path.length) {
+			const next = [...successors.get(path.at(-1))].filter((nodeId) => !path.includes(nodeId) && !exits.includes(nodeId));
+			if (next.length !== 1) break;
+			path.push(next[0]);
+		}
+		paths[id] = path;
+		container.children = [
+			...path,
+			...children.map((node) => node.id).filter((nodeId) => !path.includes(nodeId) && !exits.includes(nodeId)),
+			...exits.filter((nodeId) => !path.includes(nodeId))
+		].map((nodeId) => children.find((node) => node.id === nodeId));
+		container.layoutOptions = {
+			...path.length > 1 && option(container, "layered.cycleBreaking.strategy") === void 0 ? { "elk.layered.cycleBreaking.strategy": "MODEL_ORDER" } : {},
+			...path.length > 1 && option(container, "layered.feedbackEdges") === void 0 ? { "elk.layered.feedbackEdges": true } : {},
+			...container.layoutOptions,
+			...scope.direction ? { direction: scope.direction } : {}
+		};
+	}
+	return {
+		graph,
+		paths,
+		commonExits
+	};
+}
+const intersects = (a, b) => a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+const cross = (a, b, c) => (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+/** Diagnostic objective, not a proof of geometric validity. Coordinates are container-relative. */
+function scoreStatechartLayout(graph, paths = {}) {
+	const score = {
+		invalid: 0,
+		overlaps: 0,
+		pathOrder: 0,
+		crossings: 0,
+		bends: 0,
+		routeLength: 0
+	};
+	const segments = [];
+	const boxes = [];
+	const rect = (shape, x, y) => {
+		if ([
+			shape.x,
+			shape.y,
+			shape.width,
+			shape.height
+		].some((value) => value === void 0 || !Number.isFinite(value)) || (shape.width ?? 0) < 0 || (shape.height ?? 0) < 0) score.invalid++;
+		return {
+			x: x + (shape.x ?? 0),
+			y: y + (shape.y ?? 0),
+			width: shape.width ?? 0,
+			height: shape.height ?? 0
+		};
+	};
+	const visit = (node, x, y, ancestors) => {
+		const direction = String(option(node, "direction") ?? "RIGHT").toUpperCase();
+		const horizontal = direction === "RIGHT" || direction === "LEFT";
+		const sign = direction === "LEFT" || direction === "UP" ? -1 : 1;
+		const path = paths[String(node.id)] ?? [];
+		for (let i = 1; i < path.length; i++) {
+			const a = node.children?.find((child) => child.id === path[i - 1]);
+			const b = node.children?.find((child) => child.id === path[i]);
+			if (!a || !b || sign * (horizontal ? b.x - a.x : b.y - a.y) <= 0) score.pathOrder++;
+		}
+		for (const child of node.children ?? []) {
+			if (String(option(child, "noLayout")).toLowerCase() === "true") continue;
+			const box = rect(child, x, y);
+			if ((child.x ?? 0) < 0 || (child.y ?? 0) < 0 || (child.x ?? 0) + (child.width ?? 0) > (node.width ?? Infinity) + .001 || (child.y ?? 0) + (child.height ?? 0) > (node.height ?? Infinity) + .001) score.invalid++;
+			boxes.push({
+				rect: box,
+				ancestors,
+				node: child
+			});
+			visit(child, box.x, box.y, [...ancestors, child]);
+		}
+		for (const edge of node.edges ?? []) {
+			if (String(option(edge, "noLayout")).toLowerCase() === "true") continue;
+			if (!edge.sections?.length) score.invalid++;
+			for (const label of edge.labels ?? []) {
+				if (String(option(label, "noLayout")).toLowerCase() === "true") continue;
+				boxes.push({
+					rect: rect(label, x, y),
+					ancestors
+				});
+			}
+			for (const section of edge.sections ?? []) {
+				const points = [
+					section.startPoint,
+					...section.bendPoints ?? [],
+					section.endPoint
+				];
+				score.bends += section.bendPoints?.length ?? 0;
+				for (const point of points) if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) score.invalid++;
+				for (let i = 1; i < points.length; i++) {
+					const a = {
+						x: x + points[i - 1].x,
+						y: y + points[i - 1].y
+					};
+					const b = {
+						x: x + points[i].x,
+						y: y + points[i].y
+					};
+					score.routeLength += Math.hypot(b.x - a.x, b.y - a.y);
+					segments.push({
+						a,
+						b,
+						edge
+					});
+				}
+			}
+		}
+	};
+	visit(graph, 0, 0, [graph]);
+	for (let i = 0; i < boxes.length; i++) for (let j = i + 1; j < boxes.length; j++) {
+		const a = boxes[i], b = boxes[j];
+		if (a.node && b.ancestors.includes(a.node) || b.node && a.ancestors.includes(b.node)) continue;
+		if (intersects(a.rect, b.rect)) score.overlaps++;
+	}
+	for (let i = 0; i < segments.length; i++) for (let j = i + 1; j < segments.length; j++) {
+		const a = segments[i], b = segments[j];
+		if (a.edge === b.edge) continue;
+		if (cross(a.a, a.b, b.a) * cross(a.a, a.b, b.b) < 0 && cross(b.a, b.b, a.a) * cross(b.a, b.b, a.b) < 0) score.crossings++;
+	}
+	if (!Number.isFinite(score.routeLength)) score.routeLength = Number.MAX_VALUE;
+	return score;
+}
+const objectives = [
+	"invalid",
+	"overlaps",
+	"pathOrder",
+	"crossings",
+	"bends",
+	"routeLength"
+];
+function better(a, b) {
+	for (const key of objectives) if (a[key] !== b[key]) return a[key] < b[key];
+	return false;
+}
+/** Each attempt starts from original input. No post-layout geometry edits. */
+async function layoutStatechart(input, options) {
+	const maxAttempts = options.maxAttempts ?? 3;
+	if (!Number.isInteger(maxAttempts) || maxAttempts < 1 || maxAttempts > 3) throw new RangeError("maxAttempts must be an integer from 1 to 3");
+	const plan = compileStatechartLayout(input, options.scopes);
+	const attempts = [];
+	let selected;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		const candidate = structuredClone(attempt === 0 ? input : plan.graph);
+		const configure = (node) => {
+			const scope = Object.hasOwn(options.scopes, String(node.id)) ? options.scopes[String(node.id)] : void 0;
+			if (scope?.direction) node.layoutOptions = {
+				...node.layoutOptions,
+				direction: scope.direction
+			};
+			if (attempt === 2 && scope) node.layoutOptions = {
+				...node.layoutOptions,
+				"spacing.nodeNode": Math.max(40, Number(option(node, "spacing.nodeNode") ?? 20) * 1.5),
+				"layered.spacing.nodeNodeBetweenLayers": Math.max(60, Number(option(node, "layered.spacing.nodeNodeBetweenLayers") ?? 20) * 1.5)
+			};
+			if (attempt === 2 && scope) {
+				const groups = /* @__PURE__ */ new Map();
+				for (const edge of node.edges ?? []) {
+					if (!edge.labels?.length) continue;
+					const key = JSON.stringify([endpoint$1(edge, true), endpoint$1(edge, false)]);
+					const group = groups.get(key) ?? [];
+					group.push(edge);
+					groups.set(key, group);
+				}
+				for (const group of groups.values()) for (let i = 1; i < Math.min(group.length, 3); i++) {
+					const edge = group[i];
+					if (option(edge, "edgeLabels.placement") === void 0 && edge.labels.every((label) => option(label, "edgeLabels.placement") === void 0)) {
+						const placement = i === 1 ? "HEAD" : "TAIL";
+						edge.layoutOptions = {
+							...edge.layoutOptions,
+							"elk.edgeLabels.placement": placement
+						};
+						edge.labels = edge.labels.map((label) => ({
+							...label,
+							layoutOptions: {
+								...label.layoutOptions,
+								"elk.edgeLabels.placement": placement
+							}
+						}));
+					}
+				}
+			}
+			node.children?.forEach(configure);
+		};
+		configure(candidate);
+		const graph = await new ELK().layout(candidate);
+		const score = scoreStatechartLayout(graph, plan.paths);
+		attempts.push({
+			kind: attempt === 0 ? "baseline" : attempt === 1 ? "policy" : "spacing",
+			score
+		});
+		if (!selected || better(score, selected.score)) selected = {
+			graph,
+			score,
+			attempt
+		};
+	}
+	return {
+		...selected,
+		attempts,
+		paths: plan.paths,
+		commonExits: plan.commonExits
+	};
+}
+
+//#endregion
 //#region src/elkjs/index.ts
 function isLayoutEdgeLabel(label) {
 	return getBooleanOption(label.layoutOptions ?? {}, "noLayout") !== true && (Boolean(label.text) || label.width !== void 0 || label.height !== void 0);
@@ -344,6 +603,7 @@ var ELK = class {
 		const graph_ = toGraph(graph, layoutOptions);
 		const layerConstraintByNodeId = new Map((graph.children ?? []).map((node) => [String(node.id), String(getOption(node.layoutOptions ?? {}, "layered.layering.layerConstraint") ?? getOption(node.layoutOptions ?? {}, "layerConstraint") ?? "NONE")]));
 		if (algorithm === "layered" && graph_.edges.some((edge) => {
+			if (edge.sourceId === edge.targetId) return false;
 			const sourceConstraint = layerConstraintByNodeId.get(edge.sourceId);
 			const targetConstraint = layerConstraintByNodeId.get(edge.targetId);
 			return (sourceConstraint === "FIRST" || sourceConstraint === "FIRST_SEPARATE") && (targetConstraint === "FIRST" || targetConstraint === "FIRST_SEPARATE");
@@ -408,7 +668,7 @@ var ELK = class {
 		if (hierarchyRestorations.length > 0) {
 			const direction = getDirection(layoutOptions);
 			const horizontal = direction === "right" || direction === "left";
-			const cross = (point) => horizontal ? point.y : point.x;
+			const cross$1 = (point) => horizontal ? point.y : point.x;
 			const nodeSpacing = getNumberOption(layoutOptions, "spacing.nodeNode") ?? 20;
 			const shiftsByOutsideId = /* @__PURE__ */ new Map();
 			for (const restoration of hierarchyRestorations) {
@@ -418,7 +678,7 @@ var ELK = class {
 				const originalTargetId = String(restoration.targets?.[0] ?? restoration.target);
 				const sourceInside = !laidOut.nodes.some((node) => node.id === originalSourceId);
 				const outsideId = sourceInside ? originalTargetId : originalSourceId;
-				const delta = sourceInside ? cross(route[0]) - cross(route.at(-1)) : cross(route.at(-1)) - cross(route[0]);
+				const delta = sourceInside ? cross$1(route[0]) - cross$1(route.at(-1)) : cross$1(route.at(-1)) - cross$1(route[0]);
 				const candidates = shiftsByOutsideId.get(outsideId) ?? [];
 				candidates.push(delta);
 				shiftsByOutsideId.set(outsideId, candidates);
@@ -468,11 +728,13 @@ var ELK = class {
 			}
 			const edgeNodeSpacing = getNumberOption(layoutOptions, "spacing.edgeNodeBetweenLayers") ?? 10;
 			for (const restoration of hierarchyRestorations) {
-				const route = laidOut.edges.find((edge) => edge.id === String(restoration.edge.id))?.points;
+				const nativeEdge = laidOut.edges.find((edge) => edge.id === String(restoration.edge.id));
+				const route = nativeEdge?.points;
 				if (!route || route.length < 2) continue;
 				const start = route[0];
 				const end = route.at(-1);
-				if (Math.abs(cross(start) - cross(end)) < 1e-9) {
+				if (nativeEdge.sourceId === nativeEdge.targetId) continue;
+				if (Math.abs(cross$1(start) - cross$1(end)) < 1e-9) {
 					route.splice(1, route.length - 2);
 					continue;
 				}
@@ -1220,4 +1482,4 @@ function placePortLabels(node, globalOptions) {
 }
 
 //#endregion
-export { ELK as default };
+export { compileStatechartLayout, ELK as default, layoutStatechart, scoreStatechartLayout };

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { A as minimizeCrossingsWithBarycenter, B as LayoutError, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, V as UnsupportedLayoutError, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "./layered-BYhTymAk.mjs";
-import { a as getRandomLayout, c as rectanglePackingAlgorithm, d as fixedAlgorithm, f as getFixedLayout, i as sporeOverlapRemovalAlgorithm, l as boxAlgorithm, n as getSporeOverlapRemovalLayout, o as randomAlgorithm, r as sporeCompactionAlgorithm, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "./spore-B504wOFR.mjs";
+import { A as minimizeCrossingsWithBarycenter, B as LayoutError, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, V as UnsupportedLayoutError, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "./layered-CZs9YWVx.mjs";
+import { a as getRandomLayout, c as rectanglePackingAlgorithm, d as fixedAlgorithm, f as getFixedLayout, i as sporeOverlapRemovalAlgorithm, l as boxAlgorithm, n as getSporeOverlapRemovalLayout, o as randomAlgorithm, r as sporeCompactionAlgorithm, s as getRectanglePackingLayout, t as getSporeCompactionLayout, u as getBoxLayout } from "./spore-9N0W9dZn.mjs";
 import { getGraphIssues } from "@statelyai/graph";
 
 //#region src/layout.ts

package/dist/layered/index.mjs

@@ -1,3 +1,3 @@
-import { A as minimizeCrossingsWithBarycenter, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, c as placeNodesWithLinearSegments, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, l as placeNodesWithBrandesKoepf, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, s as placeNodesWithNetworkSimplex, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "../layered-BYhTymAk.mjs";
+import { A as minimizeCrossingsWithBarycenter, C as breakCyclesGreedilyByModelOrder, D as breakCyclesWithModelOrderDepthFirstSearch, E as breakCyclesWithModelOrderBreadthFirstSearch, I as routeEdgesOrthogonally, L as routeEdgesWithPolylines, M as minimizeCrossingsWithModelOrder, N as placeNodesInLayers, P as placeNodesInteractively, R as routeEdgesWithSplines, S as breakCyclesGreedily, T as breakCyclesWithDepthFirstSearch, _ as assignLayersInteractively, a as elkLayeredEnumValues, b as breakCyclesByStronglyConnectedConnectivity, c as placeNodesWithLinearSegments, d as assignLayersWithMinWidth, f as assignLayersWithNetworkSimplex, g as assignLayersByLongestPathToSink, h as assignLayersByLongestPath, i as toElkLayeredOptions, j as minimizeCrossingsWithMedian, k as minimizeCrossingsInteractively, l as placeNodesWithBrandesKoepf, m as assignLayersByDepthFirstModelOrder, n as layeredAlgorithm, o as elkLayeredOptionDefinitions, p as assignLayersByBreadthFirstModelOrder, r as fromElkLayeredOptionId, s as placeNodesWithNetworkSimplex, t as getLayeredLayout, u as assignLayersWithStretchWidth, v as assignLayersWithCoffmanGraham, w as breakCyclesInteractively, x as breakCyclesByStronglyConnectedNodeType, y as breakCyclesByModelOrder } from "../layered-CZs9YWVx.mjs";
 
 export { assignLayersByBreadthFirstModelOrder, assignLayersByDepthFirstModelOrder, assignLayersByLongestPath, assignLayersByLongestPathToSink, assignLayersInteractively, assignLayersWithCoffmanGraham, assignLayersWithMinWidth, assignLayersWithNetworkSimplex, assignLayersWithStretchWidth, breakCyclesByModelOrder, breakCyclesByStronglyConnectedConnectivity, breakCyclesByStronglyConnectedNodeType, breakCyclesGreedily, breakCyclesGreedilyByModelOrder, breakCyclesInteractively, breakCyclesWithDepthFirstSearch, breakCyclesWithModelOrderBreadthFirstSearch, breakCyclesWithModelOrderDepthFirstSearch, elkLayeredEnumValues, elkLayeredOptionDefinitions, fromElkLayeredOptionId, getLayeredLayout, layeredAlgorithm, minimizeCrossingsInteractively, minimizeCrossingsWithBarycenter, minimizeCrossingsWithMedian, minimizeCrossingsWithModelOrder, placeNodesInLayers, placeNodesInteractively, placeNodesWithBrandesKoepf, placeNodesWithLinearSegments, placeNodesWithNetworkSimplex, routeEdgesOrthogonally, routeEdgesWithPolylines, routeEdgesWithSplines, toElkLayeredOptions };