@statelyai/layout 0.5.0 → 0.5.1

package/dist/elkjs/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
-require('../layered-SB2mlAqt.cjs');
-const require_elkjs = require('../elkjs-DonMqGjf.cjs');
+require('../layered-QzYtokgN.cjs');
+const require_elkjs = require('../elkjs-Bh_E59N_.cjs');
 
 exports.compileStatechartLayout = require_elkjs.compileStatechartLayout;
 exports.default = require_elkjs.ELK;

package/dist/elkjs/index.mjs

@@ -1,4 +1,4 @@
-import "../layered-CmL7oynw.mjs";
-import { a as scoreStatechartLayout, i as layoutStatechart, n as getElkRoutes, r as compileStatechartLayout, t as ELK } from "../elkjs-DBkalvt1.mjs";
+import "../layered-CUwft7on.mjs";
+import { a as scoreStatechartLayout, i as layoutStatechart, n as getElkRoutes, r as compileStatechartLayout, t as ELK } from "../elkjs-Dk9yOk9U.mjs";
 
 export { compileStatechartLayout, ELK as default, getElkRoutes, layoutStatechart, scoreStatechartLayout };

package/dist/elkjs/main.cjs

@@ -1,4 +1,4 @@
-require('../layered-SB2mlAqt.cjs');
+require('../layered-QzYtokgN.cjs');
 const require_elkjs_worker = require('./worker.cjs');
 const require_worker_client = require('../worker-client-D4oEvhAl.cjs');
 

package/dist/elkjs/main.mjs

@@ -1,4 +1,4 @@
-import "../layered-CmL7oynw.mjs";
+import "../layered-CUwft7on.mjs";
 import { Worker } from "./worker.mjs";
 import { t as WorkerELK } from "../worker-client-BNjwT1AJ.mjs";
 

package/dist/elkjs/worker.cjs

@@ -1,5 +1,5 @@
-require('../layered-SB2mlAqt.cjs');
-const require_elkjs = require('../elkjs-DonMqGjf.cjs');
+require('../layered-QzYtokgN.cjs');
+const require_elkjs = require('../elkjs-Bh_E59N_.cjs');
 
 //#region src/elkjs/worker.ts
 /*******************************************************************************

package/dist/elkjs/worker.mjs

@@ -1,5 +1,5 @@
-import "../layered-CmL7oynw.mjs";
-import { t as ELK } from "../elkjs-DBkalvt1.mjs";
+import "../layered-CUwft7on.mjs";
+import { t as ELK } from "../elkjs-Dk9yOk9U.mjs";
 
 //#region src/elkjs/worker.ts
 /*******************************************************************************

package/dist/{elkjs-DonMqGjf.cjs → elkjs-Bh_E59N_.cjs}

@@ -1,6 +1,6 @@
 const require_routing = require('./routing-Phxu1R0x.cjs');
-const require_layered = require('./layered-SB2mlAqt.cjs');
-const require_layout_engine = require('./layout-engine-CAyJ-I-u.cjs');
+const require_layered = require('./layered-QzYtokgN.cjs');
+const require_layout_engine = require('./layout-engine-CQ5FcBPC.cjs');
 let _statelyai_graph = require("@statelyai/graph");
 
 //#region src/layered/hierarchy-sweepiness.ts

package/dist/{elkjs-DBkalvt1.mjs → elkjs-Dk9yOk9U.mjs}

@@ -1,6 +1,6 @@
 import { E as pathFromPoints, N as freeze, _ as pathFromSplinePoints } from "./routing-D-LfMXOF.mjs";
-import { $ as attachExternalPortDummy, R as createLayerSweepSession, S as CROSSING_MODEL, Z as minimizeHierarchyCrossings, b as elkjs0111ResultPolicy, c as elkLayeredOptionDefinitions, et as createExternalPortDummy, h as separateOpposingTracks, nt as createOrthogonalHypersegments, t as createLayeredScopePipeline, tt as externalPortDummyOf, v as isPerpendicularPortRestored, y as hierarchicalPortSides } from "./layered-CmL7oynw.mjs";
-import { n as executeElkjs0111Layout } from "./layout-engine-BXoIpYL4.mjs";
+import { $ as attachExternalPortDummy, R as createLayerSweepSession, S as CROSSING_MODEL, Z as minimizeHierarchyCrossings, b as elkjs0111ResultPolicy, c as elkLayeredOptionDefinitions, et as createExternalPortDummy, h as separateOpposingTracks, nt as createOrthogonalHypersegments, t as createLayeredScopePipeline, tt as externalPortDummyOf, v as isPerpendicularPortRestored, y as hierarchicalPortSides } from "./layered-CUwft7on.mjs";
+import { n as executeElkjs0111Layout } from "./layout-engine-DvDkMQM3.mjs";
 import { createGraph } from "@statelyai/graph";
 
 //#region src/layered/hierarchy-sweepiness.ts

package/dist/index.cjs

@@ -1,6 +1,6 @@
 const require_routing = require('./routing-Phxu1R0x.cjs');
-const require_layered = require('./layered-SB2mlAqt.cjs');
-const require_layout_engine = require('./layout-engine-CAyJ-I-u.cjs');
+const require_layered = require('./layered-QzYtokgN.cjs');
+const require_layout_engine = require('./layout-engine-CQ5FcBPC.cjs');
 let _statelyai_graph = require("@statelyai/graph");
 
 //#region src/layout.ts

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { C as getPathLength, D as roundCorners, E as pathFromPoints, O as segmentCrossesRect, P as routingPolicies, R as LayoutError, S as getPathBounds, T as getTangentAtLength, _ as pathFromSplinePoints, a as fanRouting, b as routeToPolylines, c as orthogonalRouting, d as routingStrategies, f as selfLoopRouting, g as getLayoutRoutes, h as trimBezierPathStart, i as curvedRouting, k as toSvgPath, l as parallelRouting, m as applyRoutePatches, n as bundleRouting, o as octilinearRouting, p as straightRouting, r as busRouting, s as organicRouting, t as bezierRouting, u as polylineRouting, v as routeToGraphPatch, w as getPointAtLength, x as flattenPath, y as routeToPoints, z as UnsupportedLayoutError } from "./routing-D-LfMXOF.mjs";
-import { A as breakCyclesByStronglyConnectedConnectivity, B as minimizeCrossingsInteractively, C as assignLayersByBreadthFirstModelOrder, D as assignLayersInteractively, E as assignLayersByLongestPathToSink, F as breakCyclesWithDepthFirstSearch, G as placeNodesInteractively, H as minimizeCrossingsWithMedian, I as breakCyclesWithModelOrderBreadthFirstSearch, J as routeEdgesWithPolylines, L as breakCyclesWithModelOrderDepthFirstSearch, M as breakCyclesGreedily, N as breakCyclesGreedilyByModelOrder, O as assignLayersWithCoffmanGraham, P as breakCyclesInteractively, Q as assignLayersWithNetworkSimplex, T as assignLayersByLongestPath, U as minimizeCrossingsWithModelOrder, V as minimizeCrossingsWithBarycenter, W as placeNodesInLayers, Y as routeEdgesWithSplines, _ as statechartHints, a as fromElkLayeredOptionId, c as elkLayeredOptionDefinitions, f as assignLayersWithStretchWidth, g as hint, i as layeredAlgorithm, j as breakCyclesByStronglyConnectedNodeType, k as breakCyclesByModelOrder, m as c, o as toElkLayeredOptions, p as assignLayersWithMinWidth, q as routeEdgesOrthogonally, r as getLayeredLayout, s as elkLayeredEnumValues, w as assignLayersByDepthFirstModelOrder } from "./layered-CmL7oynw.mjs";
-import { a as getSporeCompactionLayout, c as sporeOverlapRemovalAlgorithm, d as getRectanglePackingLayout, f as rectanglePackingAlgorithm, g as getFixedLayout, h as fixedAlgorithm, i as getBuiltInLayoutAlgorithm, l as getRandomLayout, m as getBoxLayout, o as getSporeOverlapRemovalLayout, p as boxAlgorithm, r as executeLayoutAlgorithm, s as sporeCompactionAlgorithm, t as builtInLayoutAlgorithms, u as randomAlgorithm } from "./layout-engine-BXoIpYL4.mjs";
+import { A as breakCyclesByStronglyConnectedConnectivity, B as minimizeCrossingsInteractively, C as assignLayersByBreadthFirstModelOrder, D as assignLayersInteractively, E as assignLayersByLongestPathToSink, F as breakCyclesWithDepthFirstSearch, G as placeNodesInteractively, H as minimizeCrossingsWithMedian, I as breakCyclesWithModelOrderBreadthFirstSearch, J as routeEdgesWithPolylines, L as breakCyclesWithModelOrderDepthFirstSearch, M as breakCyclesGreedily, N as breakCyclesGreedilyByModelOrder, O as assignLayersWithCoffmanGraham, P as breakCyclesInteractively, Q as assignLayersWithNetworkSimplex, T as assignLayersByLongestPath, U as minimizeCrossingsWithModelOrder, V as minimizeCrossingsWithBarycenter, W as placeNodesInLayers, Y as routeEdgesWithSplines, _ as statechartHints, a as fromElkLayeredOptionId, c as elkLayeredOptionDefinitions, f as assignLayersWithStretchWidth, g as hint, i as layeredAlgorithm, j as breakCyclesByStronglyConnectedNodeType, k as breakCyclesByModelOrder, m as c, o as toElkLayeredOptions, p as assignLayersWithMinWidth, q as routeEdgesOrthogonally, r as getLayeredLayout, s as elkLayeredEnumValues, w as assignLayersByDepthFirstModelOrder } from "./layered-CUwft7on.mjs";
+import { a as getSporeCompactionLayout, c as sporeOverlapRemovalAlgorithm, d as getRectanglePackingLayout, f as rectanglePackingAlgorithm, g as getFixedLayout, h as fixedAlgorithm, i as getBuiltInLayoutAlgorithm, l as getRandomLayout, m as getBoxLayout, o as getSporeOverlapRemovalLayout, p as boxAlgorithm, r as executeLayoutAlgorithm, s as sporeCompactionAlgorithm, t as builtInLayoutAlgorithms, u as randomAlgorithm } from "./layout-engine-DvDkMQM3.mjs";
 import { getGraphIssues } from "@statelyai/graph";
 
 //#region src/layout.ts

package/dist/layered/index.cjs

@@ -1,4 +1,4 @@
-const require_layered = require('../layered-SB2mlAqt.cjs');
+const require_layered = require('../layered-QzYtokgN.cjs');
 
 exports.assignLayersByBreadthFirstModelOrder = require_layered.assignLayersByBreadthFirstModelOrder;
 exports.assignLayersByDepthFirstModelOrder = require_layered.assignLayersByDepthFirstModelOrder;

package/dist/layered/index.mjs

@@ -1,3 +1,3 @@
-import { A as breakCyclesByStronglyConnectedConnectivity, B as minimizeCrossingsInteractively, C as assignLayersByBreadthFirstModelOrder, D as assignLayersInteractively, E as assignLayersByLongestPathToSink, F as breakCyclesWithDepthFirstSearch, G as placeNodesInteractively, H as minimizeCrossingsWithMedian, I as breakCyclesWithModelOrderBreadthFirstSearch, J as routeEdgesWithPolylines, L as breakCyclesWithModelOrderDepthFirstSearch, M as breakCyclesGreedily, N as breakCyclesGreedilyByModelOrder, O as assignLayersWithCoffmanGraham, P as breakCyclesInteractively, Q as assignLayersWithNetworkSimplex, T as assignLayersByLongestPath, U as minimizeCrossingsWithModelOrder, V as minimizeCrossingsWithBarycenter, W as placeNodesInLayers, Y as routeEdgesWithSplines, a as fromElkLayeredOptionId, c as elkLayeredOptionDefinitions, d as placeNodesWithBrandesKoepf, f as assignLayersWithStretchWidth, i as layeredAlgorithm, j as breakCyclesByStronglyConnectedNodeType, k as breakCyclesByModelOrder, l as placeNodesWithNetworkSimplex, n as elkjs0111LayeredAlgorithm, o as toElkLayeredOptions, p as assignLayersWithMinWidth, q as routeEdgesOrthogonally, r as getLayeredLayout, s as elkLayeredEnumValues, t as createLayeredScopePipeline, u as placeNodesWithLinearSegments, w as assignLayersByDepthFirstModelOrder } from "../layered-CmL7oynw.mjs";
+import { A as breakCyclesByStronglyConnectedConnectivity, B as minimizeCrossingsInteractively, C as assignLayersByBreadthFirstModelOrder, D as assignLayersInteractively, E as assignLayersByLongestPathToSink, F as breakCyclesWithDepthFirstSearch, G as placeNodesInteractively, H as minimizeCrossingsWithMedian, I as breakCyclesWithModelOrderBreadthFirstSearch, J as routeEdgesWithPolylines, L as breakCyclesWithModelOrderDepthFirstSearch, M as breakCyclesGreedily, N as breakCyclesGreedilyByModelOrder, O as assignLayersWithCoffmanGraham, P as breakCyclesInteractively, Q as assignLayersWithNetworkSimplex, T as assignLayersByLongestPath, U as minimizeCrossingsWithModelOrder, V as minimizeCrossingsWithBarycenter, W as placeNodesInLayers, Y as routeEdgesWithSplines, a as fromElkLayeredOptionId, c as elkLayeredOptionDefinitions, d as placeNodesWithBrandesKoepf, f as assignLayersWithStretchWidth, i as layeredAlgorithm, j as breakCyclesByStronglyConnectedNodeType, k as breakCyclesByModelOrder, l as placeNodesWithNetworkSimplex, n as elkjs0111LayeredAlgorithm, o as toElkLayeredOptions, p as assignLayersWithMinWidth, q as routeEdgesOrthogonally, r as getLayeredLayout, s as elkLayeredEnumValues, t as createLayeredScopePipeline, u as placeNodesWithLinearSegments, w as assignLayersByDepthFirstModelOrder } from "../layered-CUwft7on.mjs";
 
 export { assignLayersByBreadthFirstModelOrder, assignLayersByDepthFirstModelOrder, assignLayersByLongestPath, assignLayersByLongestPathToSink, assignLayersInteractively, assignLayersWithCoffmanGraham, assignLayersWithMinWidth, assignLayersWithNetworkSimplex, assignLayersWithStretchWidth, breakCyclesByModelOrder, breakCyclesByStronglyConnectedConnectivity, breakCyclesByStronglyConnectedNodeType, breakCyclesGreedily, breakCyclesGreedilyByModelOrder, breakCyclesInteractively, breakCyclesWithDepthFirstSearch, breakCyclesWithModelOrderBreadthFirstSearch, breakCyclesWithModelOrderDepthFirstSearch, createLayeredScopePipeline, elkLayeredEnumValues, elkLayeredOptionDefinitions, elkjs0111LayeredAlgorithm, fromElkLayeredOptionId, getLayeredLayout, layeredAlgorithm, minimizeCrossingsInteractively, minimizeCrossingsWithBarycenter, minimizeCrossingsWithMedian, minimizeCrossingsWithModelOrder, placeNodesInLayers, placeNodesInteractively, placeNodesWithBrandesKoepf, placeNodesWithLinearSegments, placeNodesWithNetworkSimplex, routeEdgesOrthogonally, routeEdgesWithPolylines, routeEdgesWithSplines, toElkLayeredOptions };

package/dist/{layered-CmL7oynw.mjs → layered-CUwft7on.mjs}

@@ -1608,8 +1608,174 @@ function findNode(nodes, id) {
 	return position !== void 0 && nodes[position]?.id === id ? nodes[position] : nodes.find((node) => node.id === id);
 }
 
+//#endregion
+//#region src/layered/self-loop-ports.ts
+const hiddenBySettings = /* @__PURE__ */ new WeakMap();
+/** Sizes of the ports SelfLoopPreProcessor hid from a loop, if any. */
+function hiddenLoopPorts(settings, edgeId) {
+	return hiddenBySettings.get(settings)?.get(edgeId);
+}
+/**
+* ELK's SelfLoopPreProcessor removes ports that carry only self loops from
+* nodes whose port order is not fixed, and SelfLoopPortRestorer later puts
+* them on the loop's side. The layered phases then see implicit loop ports;
+* {@link restoreSelfLoopPorts} places the hidden ports at the loop ends.
+*/
+function hideSelfLoopPorts(graph, options) {
+	const uses = /* @__PURE__ */ new Map();
+	const nonLoop = /* @__PURE__ */ new Set();
+	for (const edge of graph.edges) for (const [node, port] of [[edge.sourceId, edge.sourcePort], [edge.targetId, edge.targetPort]]) {
+		if (port === void 0) continue;
+		const key = `${node}\0${port}`;
+		uses.set(key, (uses.get(key) ?? 0) + 1);
+		if (edge.sourceId !== edge.targetId) nonLoop.add(key);
+	}
+	const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+	const hidden = /* @__PURE__ */ new Map();
+	const edges = /* @__PURE__ */ new Map();
+	const hiddenPorts = /* @__PURE__ */ new Set();
+	for (const edge of graph.edges) {
+		if (edge.sourceId !== edge.targetId || edge.sourcePort === void 0 || edge.targetPort === void 0 || edge.sourcePort === edge.targetPort) continue;
+		const node = nodeById.get(edge.sourceId);
+		const constraints = node && options.nodeSettings?.(node)?.portConstraints;
+		if (!node || constraints !== void 0 && constraints !== "FREE" && constraints !== "UNDEFINED") continue;
+		const ports = [edge.sourcePort, edge.targetPort].map((name) => node.ports?.find((port) => port.name === name));
+		if (ports.some((port) => !port || uses.get(`${node.id}\0${port.name}`) !== 1 || nonLoop.has(`${node.id}\0${port.name}`))) continue;
+		const size$1 = (port) => ({
+			width: port.width ?? 0,
+			height: port.height ?? 0
+		});
+		hidden.set(edge.id, {
+			source: size$1(ports[0]),
+			target: size$1(ports[1])
+		});
+		edges.set(edge.id, edge);
+		for (const port of ports) hiddenPorts.add(`${node.id}\0${port.name}`);
+	}
+	if (hidden.size === 0) return void 0;
+	const settings = { ...options.settings };
+	hiddenBySettings.set(settings, hidden);
+	return {
+		graph: {
+			...graph,
+			nodes: graph.nodes.map((node) => node.ports?.some((port) => hiddenPorts.has(`${node.id}\0${port.name}`)) ? {
+				...node,
+				ports: node.ports.filter((port) => !hiddenPorts.has(`${node.id}\0${port.name}`))
+			} : node),
+			edges: graph.edges.map((edge) => hidden.has(edge.id) ? {
+				...edge,
+				sourcePort: void 0,
+				targetPort: void 0
+			} : edge)
+		},
+		options: {
+			...options,
+			settings
+		},
+		edges
+	};
+}
+/** Put hidden loop ports back, anchored on the side their loop leaves from. */
+function restoreSelfLoopPorts(graph, result, edges) {
+	const anchors = /* @__PURE__ */ new Map();
+	for (const edge of result.edges) {
+		const original = edges.get(edge.id);
+		const points = edge.points;
+		if (!original || !points?.length) continue;
+		anchors.set(`${edge.sourceId}\0${original.sourcePort}`, points[0]);
+		anchors.set(`${edge.targetId}\0${original.targetPort}`, points.at(-1));
+	}
+	const originalById = new Map(graph.nodes.map((node) => [node.id, node]));
+	return {
+		...result,
+		nodes: result.nodes.map((node) => {
+			const original = originalById.get(node.id)?.ports;
+			if (!original?.some((port) => anchors.has(`${node.id}\0${port.name}`))) return node;
+			const placed = new Map(node.ports?.map((port) => [port.name, port]));
+			return {
+				...node,
+				ports: original.map((port) => {
+					const anchor = anchors.get(`${node.id}\0${port.name}`);
+					const width = port.width ?? 0, height = port.height ?? 0;
+					if (!anchor) return placed.get(port.name) ?? {
+						...port,
+						width,
+						height,
+						x: 0,
+						y: 0
+					};
+					const x = anchor.x - node.x, y = anchor.y - node.y;
+					return {
+						...port,
+						width,
+						height,
+						x: x <= 0 ? x : x >= node.width ? x - width : x - width / 2,
+						y: x <= 0 || x >= node.width ? y - height / 2 : y <= 0 ? y : y - height
+					};
+				})
+			};
+		}),
+		edges: result.edges.map((edge) => {
+			const original = edges.get(edge.id);
+			return original ? {
+				...edge,
+				sourcePort: original.sourcePort,
+				targetPort: original.targetPort
+			} : edge;
+		})
+	};
+}
+
 //#endregion
 //#region src/layered/loop-envelopes.ts
+const crossSide = (side) => side === "NORTH" || side === "SOUTH";
+/**
+* Extents of a movable loop's hidden ports in the canonical rightward frame:
+* along its side, and protruding from it.
+*/
+function loopPortExtents(input, edge, side) {
+	const ports = hiddenLoopPorts(input.settings, edge.id);
+	const horizontal$1 = input.direction === "right" || input.direction === "left";
+	const along = crossSide(side) === horizontal$1 ? "width" : "height";
+	const normal = along === "width" ? "height" : "width";
+	return {
+		along: ports ? ports.source[along] + ports.target[along] : 0,
+		normal: ports ? Math.max(ports.source[normal], ports.target[normal]) : 0
+	};
+}
+/** A movable loop's label extent away from its side, in the canonical frame. */
+function movableLoopLabelExtent(input, edge, side) {
+	const horizontal$1 = input.direction === "right" || input.direction === "left";
+	const size$1 = (crossSide(side) === horizontal$1 ? edge.height : edge.width) ?? 0;
+	return size$1 > 0 ? size$1 + Number(input.settings["spacing.edgeLabel"] ?? 2) : 0;
+}
+/**
+* ELK's OrthogonalSelfLoopRouter routing slot of a movable loop, measured
+* from its node side in the canonical frame: past the protruding ports and
+* the self-loop spacing, then one edge spacing plus any label per inner slot.
+*/
+function movableLoopTrack(input, sideLoops, edge, side, ordering) {
+	const ordered = ordering === "REVERSE_STACKED" ? [...sideLoops].reverse() : sideLoops;
+	const inner = ordering === "SEQUENCED" ? [] : ordered.slice(0, ordered.indexOf(edge));
+	const edgeSpacing = Number(input.settings["spacing.edgeEdge"] ?? 10);
+	return Math.max(0, ...sideLoops.map((loop) => loopPortExtents(input, loop, side).normal)) + Number(input.settings["spacing.nodeSelfLoop"] ?? 10) + inner.reduce((sum, loop) => sum + edgeSpacing + (crossSide(side) ? movableLoopLabelExtent(input, loop, side) : 0), 0);
+}
+/**
+* Canonical position of a movable loop port along its side, given its
+* DISTRIBUTED ratio among the side's implicit ports (ELK's port placement
+* with equal gaps between hidden ports of their own size).
+*/
+function movableLoopPortOffset(input, sideLoops, side, length, ratio) {
+	const count = sideLoops.length * 2;
+	const extents = sideLoops.map((loop) => loopPortExtents(input, loop, side));
+	const total = extents.reduce((sum, extent$2) => sum + extent$2.along, 0);
+	const size$1 = total / count;
+	const index = Math.round(ratio * (count + 1)) - 1;
+	return {
+		along: (length - total) / (count + 1) * (index + 1) + size$1 * index + size$1 / 2,
+		normal: Math.max(0, ...extents.map((extent$2) => extent$2.normal))
+	};
+}
 /** Unconstrained implicit loop ports are restored on loop faces after the sweep. */
 function hasMovableLoopPorts(input, edge) {
 	if (edge.sourceId !== edge.targetId || edge.sourcePort !== void 0 || edge.targetPort !== void 0) return false;
@@ -1647,7 +1813,7 @@ function loopEnvelopes(input) {
 			};
 			const horizontal$1 = input.direction === "right" || input.direction === "left";
 			const reverse = input.direction === "left" || input.direction === "up";
-			const spacing$1 = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
+			const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
 			let supported = true;
 			const tracks = selfLoopTracks(allLoops);
 			for (const edge of allLoops) {
@@ -1666,7 +1832,7 @@ function loopEnvelopes(input) {
 				}, input.direction, input), getPortPoint(node, edge.targetPort, rect, {
 					x: 0,
 					y: 0
-				}, input.direction, input), sourceSide, targetSide, spacing$1 * (tracks.get(edge.id) + 1), input.direction);
+				}, input.direction, input), sourceSide, targetSide, spacing * (tracks.get(edge.id) + 1), input.direction);
 				if (labeled) {
 					const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
 					const { width = 0, height = 0 } = edge;
@@ -1691,11 +1857,10 @@ function loopEnvelopes(input) {
 			}
 		}
 		const loops = allLoops.filter((edge) => hasMovableLoopPorts(input, edge));
-		if (loops.length === 0 || loops.some((edge) => input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true)) continue;
+		if (loops.length === 0) continue;
 		const settings = input.nodeSettings?.(node);
 		const distribution = settings?.["edgeRouting.selfLoopDistribution"] ?? "NORTH";
 		const ordering = settings?.["edgeRouting.selfLoopOrdering"] ?? "STACKED";
-		const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
 		const envelope = {
 			before: 0,
 			after: 0,
@@ -1708,12 +1873,16 @@ function loopEnvelopes(input) {
 			"flowAfter",
 			"flowBefore"
 		] : distribution === "NORTH_SOUTH" ? ["before", "after"] : ["before"];
+		const canonicalSides = {
+			before: "NORTH",
+			after: "SOUTH",
+			flowAfter: "EAST",
+			flowBefore: "WEST"
+		};
 		for (const side of sides$1) {
 			const selected = loops.filter((_, index) => sides$1[index % sides$1.length] === side);
-			const horizontal$1 = input.direction === "right" || input.direction === "left";
-			const crossSize$3 = side === "before" || side === "after" ? horizontal$1 ? "height" : "width" : horizontal$1 ? "width" : "height";
-			const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
-			envelope[side] = spacing * (ordering === "SEQUENCED" ? Math.min(1, selected.length) : selected.length) + selected.reduce((sum, edge) => sum + ((edge[crossSize$3] ?? 0) > 0 ? (edge[crossSize$3] ?? 0) + labelSpacing : 0), 0);
+			const canonical = canonicalSides[side];
+			envelope[side] = Math.max(0, ...selected.map((edge) => movableLoopTrack(input, selected, edge, canonical, ordering) + movableLoopLabelExtent(input, edge, canonical)));
 		}
 		envelopes.set(node.id, envelope);
 	}
@@ -2881,7 +3050,7 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 		if (point.x >= rect.x + rect.width - 1e-9) return "EAST";
 		return point.y <= rect.y ? "NORTH" : "SOUTH";
 	};
-	const crossSide = (side) => side === "NORTH" || side === "SOUTH";
+	const crossSide$1 = (side) => side === "NORTH" || side === "SOUTH";
 	const segments = [];
 	for (const [edgeId, points] of canonicalRoutes) {
 		const edge = edgeById.get(edgeId);
@@ -2891,8 +3060,8 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 			const first = points[index];
 			const second = points[index + 1];
 			if (Math.abs(first.x - second.x) > 1e-9 || Math.abs(first.y - second.y) < 1e-9) continue;
-			if (index === 0 && !crossSide(endpointSide(edge.sourceId, edge.sourcePort, first))) continue;
-			if (index === points.length - 2 && !crossSide(endpointSide(edge.targetId, edge.targetPort, second))) continue;
+			if (index === 0 && !crossSide$1(endpointSide(edge.sourceId, edge.sourcePort, first))) continue;
+			if (index === points.length - 2 && !crossSide$1(endpointSide(edge.targetId, edge.targetPort, second))) continue;
 			const owner = index === 0 ? nodes.get(edge.sourceId) : index === points.length - 2 ? nodes.get(edge.targetId) : void 0;
 			const ownerSide = owner ? endpointSide(index === 0 ? edge.sourceId : edge.targetId, index === 0 ? edge.sourcePort : edge.targetPort, index === 0 ? first : second) : void 0;
 			const bend = index === 0 ? second : first;
@@ -3055,7 +3224,7 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 		const points = canonicalRoutes.get(edge.id);
 		const sourceSide = endpointSide(edge.sourceId, edge.sourcePort, points?.[0]);
 		const targetSide = endpointSide(edge.targetId, edge.targetPort, points?.at(-1));
-		if (crossSide(sourceSide) && crossSide(targetSide)) continue;
+		if (crossSide$1(sourceSide) && crossSide$1(targetSide)) continue;
 		const reversed = orientation?.reversedEdgeIds.has(edge.id) ?? source.x > target.x;
 		const from = reversed ? target : source, to = reversed ? source : target;
 		constraints.push({
@@ -3149,8 +3318,8 @@ function compactJoinedGeometryUnchecked(input, placement, routes, orientation) {
 			const start = pointToCanonical(originals[0]);
 			const next = pointToCanonical(originals[1]);
 			const previous = pointToCanonical(originals.at(-2));
-			if (!crossSide(endpointSide(edge.sourceId, edge.sourcePort, start)) && Math.abs(start.x - next.x) < 1e-9) points[1].x = points[0].x;
-			if (!crossSide(endpointSide(edge.targetId, edge.targetPort, end)) && Math.abs(end.x - previous.x) < 1e-9) points[points.length - 2].x = points.at(-1).x;
+			if (!crossSide$1(endpointSide(edge.sourceId, edge.sourcePort, start)) && Math.abs(start.x - next.x) < 1e-9) points[1].x = points[0].x;
+			if (!crossSide$1(endpointSide(edge.targetId, edge.targetPort, end)) && Math.abs(end.x - previous.x) < 1e-9) points[points.length - 2].x = points.at(-1).x;
 		}
 	}
 	const extent$2 = Math.max(...items.map((item) => item.x + item.width), ...[...canonicalRoutes.values()].flatMap((points) => points.map((point) => point.x)));
@@ -6427,13 +6596,13 @@ function routeEdges(style) {
 				"WEST"
 			][index % 4] : distribution === "NORTH_SOUTH" && index % 2 === 1 ? "SOUTH" : "NORTH";
 		};
-		const loopDistance = (loops, edge, side, ordering, canonical = false) => {
-			const axis = (side === "NORTH" || side === "SOUTH") === (!canonical || horizontal$1) ? "height" : "width";
+		const loopDistance = (loops, edge, side, ordering) => {
+			const axis = side === "NORTH" || side === "SOUTH" ? "height" : "width";
 			const ordered = ordering === "REVERSE_STACKED" ? [...loops].reverse() : loops;
 			const index = ordered.indexOf(edge);
 			const spacing = Number(input.settings["spacing.nodeSelfLoop"] ?? 10);
 			const labelSpacing = Number(input.settings["spacing.edgeLabel"] ?? 2);
-			const size$1 = (candidate) => canonical || input.edgeSettings?.(candidate)?.["edgeLabels.inline"] === true ? candidate[axis] ?? 0 : 0;
+			const size$1 = (candidate) => input.edgeSettings?.(candidate)?.["edgeLabels.inline"] === true ? candidate[axis] ?? 0 : 0;
 			return spacing * (ordering === "SEQUENCED" ? 1 : index + 1) + ordered.slice(0, index).reduce((extent$2, candidate) => extent$2 + (size$1(candidate) > 0 ? size$1(candidate) + labelSpacing : 0), 0) + (size$1(edge) > 0 && input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true ? size$1(edge) / 2 + labelSpacing : 0);
 		};
 		const hasFixedLoopPorts = (node) => {
@@ -6488,7 +6657,7 @@ function routeEdges(style) {
 			for (const [id, loops] of selfLoopsByNodeId) {
 				const rect = mutableRects.get(id);
 				const node = nodeById.get(id);
-				if (!rect || !node) continue;
+				if (!rect || !node || hasPlacementLoopEnvelope(placement, id)) continue;
 				const settings = input.nodeSettings?.(node);
 				const distribution = settings?.["edgeRouting.selfLoopDistribution"] ?? "NORTH";
 				const ordering = settings?.["edgeRouting.selfLoopOrdering"] ?? "STACKED";
@@ -7603,7 +7772,7 @@ function routeEdges(style) {
 						outsideFeedbackEdgeIds.add(edge.id);
 						continue;
 					}
-					const movable = hasMovableLoopPorts(input, edge) && hasPlacementLoopEnvelope(placement, source.id) && input.edgeSettings?.(edge)?.["edgeLabels.inline"] !== true;
+					const movable = hasMovableLoopPorts(input, edge) && hasPlacementLoopEnvelope(placement, source.id);
 					const loopRect = movable ? {
 						x: 0,
 						y: 0,
@@ -7643,7 +7812,32 @@ function routeEdges(style) {
 							startRatio = (countOnSide + nestingIndex + 1) / denominator;
 							endRatio = (countOnSide - nestingIndex) / denominator;
 						}
-						const distance = loopDistance(loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side), edge, side, ordering, movable);
+						const sideLoops = loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side);
+						if (movable) {
+							const track$1 = movableLoopTrack(input, sideLoops, edge, side, ordering);
+							const sign = side === "NORTH" ? -1 : 1;
+							const base = side === "NORTH" ? 0 : loopRect.height;
+							const [first, last] = [startRatio, endRatio].map((ratio) => movableLoopPortOffset(input, sideLoops, side, loopRect.width, ratio));
+							return [
+								{
+									x: first.along,
+									y: base + sign * first.normal
+								},
+								{
+									x: first.along,
+									y: base + sign * track$1
+								},
+								{
+									x: last.along,
+									y: base + sign * track$1
+								},
+								{
+									x: last.along,
+									y: base + sign * last.normal
+								}
+							];
+						}
+						const distance = loopDistance(sideLoops, edge, side, ordering);
 						const y = side === "NORTH" ? loopRect.y - distance : loopRect.y + loopRect.height + distance;
 						const start$2 = {
 							x: loopRect.x + loopRect.width * startRatio,
@@ -7673,7 +7867,32 @@ function routeEdges(style) {
 						const secondRatio = sequenced ? 1 / denominator : 2 / denominator;
 						const startRatio = side === "EAST" ? firstRatio : secondRatio;
 						const endRatio = side === "EAST" ? secondRatio : firstRatio;
-						const distance = movable || input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true ? loopDistance(loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side), edge, side, ordering, movable) : spacing * (indexOnSide + 1);
+						const sideLoops = loops.filter((candidate, i) => loopSide(distribution, i, candidate) === side);
+						if (movable) {
+							const track$1 = movableLoopTrack(input, sideLoops, edge, side, ordering);
+							const sign = side === "WEST" ? -1 : 1;
+							const base = side === "WEST" ? 0 : loopRect.width;
+							const [first, last] = [startRatio, endRatio].map((ratio) => movableLoopPortOffset(input, sideLoops, side, loopRect.height, ratio));
+							return [
+								{
+									x: base + sign * first.normal,
+									y: first.along
+								},
+								{
+									x: base + sign * track$1,
+									y: first.along
+								},
+								{
+									x: base + sign * track$1,
+									y: last.along
+								},
+								{
+									x: base + sign * last.normal,
+									y: last.along
+								}
+							];
+						}
+						const distance = input.edgeSettings?.(edge)?.["edgeLabels.inline"] === true ? loopDistance(sideLoops, edge, side, ordering) : spacing * (indexOnSide + 1);
 						const x = side === "EAST" ? loopRect.x + loopRect.width + distance : loopRect.x - distance;
 						const start$2 = {
 							x: side === "EAST" ? loopRect.x + loopRect.width : loopRect.x,
@@ -18936,6 +19155,8 @@ function* createLayeredScopePipeline(graph, options, context, fallbacks = {
 		const separated$1 = runSeparatedComponents(graph, options, context);
 		if (separated$1) return separated$1;
 	}
+	const hiddenLoopPorts$1 = hideSelfLoopPorts(graph, options);
+	if (hiddenLoopPorts$1) return restoreSelfLoopPorts(graph, yield* createLayeredScopePipeline(hiddenLoopPorts$1.graph, hiddenLoopPorts$1.options, context, fallbacks), hiddenLoopPorts$1.edges);
 	const direction = options.direction ?? graph.direction ?? "right";
 	const padding = typeof options.padding === "number" ? {
 		top: options.padding,
@@ -20017,7 +20238,7 @@ function* createLayeredScopePipeline(graph, options, context, fallbacks = {
 			y: (points[1].y + points[2].y - height) / 2
 		} : void 0;
 		const movableExteriorLoopLabelPosition = (() => {
-			if (edgeRouting !== "ORTHOGONAL" || labelPlacement !== "CENTER" || inlineLabel || !hasMovableLoopPorts(input, edge) || !sourceRect || points.length !== 4) return void 0;
+			if (edgeRouting !== "ORTHOGONAL" || labelPlacement !== "CENTER" || !hasMovableLoopPorts(input, edge) || !sourceRect || points.length !== 4) return void 0;
 			const first = points[1], last = points[2];
 			if (first.y === last.y) {
 				const low = first.y < sourceRect.y;