@statelyai/layout 0.4.1 → 0.4.2

package/dist/{layered-5RxQhryb.cjs → layered-BJu8A21s.cjs}

@@ -311,6 +311,12 @@ const restoreInitialModelOrder = (input, graph) => {
 //#endregion
 //#region src/layered/port-distributor.ts
 /** Stateful clockwise port distribution across successive layer sweeps. */
+const sideRank = {
+	NORTH: 0,
+	EAST: 1,
+	SOUTH: 2,
+	WEST: 3
+};
 var CanonicalPortDistributor = class {
 	state;
 	topologyGraph;
@@ -359,25 +365,33 @@ var CanonicalPortDistributor = class {
 	calculatePortRanks(graph, layer, input, nodeRelative) {
 		this.prepareTopology(graph);
 		let consumed = 0;
+		const ends = input ? this.incoming : this.outgoing;
+		const ranked = (port) => ends.get(port.id).length > 0;
 		for (const node of layer) {
-			const ports = node.ports.filter((port) => (input ? this.incoming : this.outgoing).get(port.id).length > 0);
-			const increment = nodeRelative ? 1 / (ports.length + 1) : 1;
+			let count = 0, northCount = 0;
+			for (const port of node.ports) if (ranked(port)) {
+				count++;
+				if (port.side === "NORTH") northCount++;
+			}
+			const increment = nodeRelative ? 1 / (count + 1) : 1;
 			if (input) {
-				let north = consumed + ports.filter((port) => port.side === "NORTH").length * increment;
-				let rest = nodeRelative ? consumed + 1 - increment : consumed + ports.length;
-				for (const port of ports) {
+				let north = consumed + northCount * increment;
+				let rest = nodeRelative ? consumed + 1 - increment : consumed + count;
+				for (const port of node.ports) {
+					if (!ranked(port)) continue;
 					this.state.ranks[port.id] = port.side === "NORTH" ? north : rest;
 					if (port.side === "NORTH") north -= increment;
 					else rest -= increment;
 				}
 			} else {
 				let position = consumed + increment;
-				for (const port of ports) {
+				for (const port of node.ports) {
+					if (!ranked(port)) continue;
 					this.state.ranks[port.id] = position;
 					position += increment;
 				}
 			}
-			consumed += nodeRelative ? 1 : ports.length;
+			consumed += nodeRelative ? 1 : count;
 		}
 	}
 	distribute(graph, index, forward, options) {
@@ -386,7 +400,7 @@ var CanonicalPortDistributor = class {
 		const degree = (port) => incoming.get(port).length + outgoing.get(port).length;
 		const ranks = (layer, input) => this.calculatePortRanks(graph, layer, input, options.nodeRelative);
 		const distributeNode = (node, side$1) => {
-			if (options.fixedOrder.has(node.id)) return;
+			if (options.fixedOrder.has(node.id) || !node.ports.length) return;
 			const layerIndex = node.ports.length ? layerByPort.get(node.ports[0].id) : index;
 			const size$1 = graph.layers[layerIndex].length;
 			for (const face of [
@@ -396,7 +410,8 @@ var CanonicalPortDistributor = class {
 			]) {
 				let minimum = 0, maximum = 0;
 				const inLayer = [];
-				for (const port of node.ports.filter((port$1) => port$1.side === face)) {
+				for (const port of node.ports) {
+					if (port.side !== face) continue;
 					let sum = 0;
 					const cross = port.side === "NORTH" || port.side === "SOUTH";
 					if (cross) {
@@ -414,7 +429,8 @@ var CanonicalPortDistributor = class {
 						else if (output && !input) sum += position + 1;
 						else if (input && output) sum += port.side === "NORTH" ? 0 : large / 2;
 					} else {
-						if ([...outgoing.get(port.id), ...incoming.get(port.id)].some((peer) => layerByPort.get(peer) === layerIndex)) {
+						const sameLayer = (peer) => layerByPort.get(peer) === layerIndex;
+						if (outgoing.get(port.id).some(sameLayer) || incoming.get(port.id).some(sameLayer)) {
 							inLayer.push(port);
 							continue;
 						}
@@ -435,12 +451,7 @@ var CanonicalPortDistributor = class {
 					this.state.barycenters[port.id] = port.side === "EAST" ? above ? minimum - value : maximum + (size$1 + 1 - value) : above ? maximum + value : minimum - (size$1 + 1 - value);
 				}
 			}
-			const sideRank = {
-				NORTH: 0,
-				EAST: 1,
-				SOUTH: 2,
-				WEST: 3
-			};
+			if (node.ports.length < 2) return;
 			node.ports.sort((a, b) => {
 				const side$2 = sideRank[a.side] - sideRank[b.side];
 				if (side$2) return side$2;
@@ -600,7 +611,7 @@ var IndexTree = class {
 };
 /** Score a canonical candidate without changing its node or port orders. */
 function countAllCrossings(graph, boundaryMode = "hyperedges") {
-	const nodes = new Map(graph.layers.flat().map((node) => [node.id, node]));
+	let nodes;
 	const layerByPort = /* @__PURE__ */ new Map();
 	const incoming = /* @__PURE__ */ new Map(), outgoing = /* @__PURE__ */ new Map();
 	for (const [layer, members] of graph.layers.entries()) for (const node of members) for (const port of node.ports) {
@@ -612,7 +623,6 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		outgoing.get(edge.source).push(edge.target);
 		incoming.get(edge.target).push(edge.source);
 	}
-	const connected = (id) => [...incoming.get(id), ...outgoing.get(id)];
 	const degree = (id) => incoming.get(id).length + outgoing.get(id).length;
 	const face = (layer, side, topDown = true) => (topDown ? layer : [...layer].reverse()).flatMap((node) => {
 		const ports = node.ports.filter((port) => port.side === side);
@@ -625,7 +635,9 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		for (const [position, port] of ports.entries()) {
 			tree.remove(position);
 			const pending = [];
-			for (const peer of connected(port.id)) {
+			const before = incoming.get(port.id), after = outgoing.get(port.id);
+			for (let index = 0; index < before.length + after.length; index++) {
+				const peer = index < before.length ? before[index] : after[index - before.length];
 				if (inLayerOnly && layerByPort.get(peer) !== layerByPort.get(port.id)) {
 					crossings$1 += tree.size;
 					continue;
@@ -669,7 +681,7 @@ function countAllCrossings(graph, boundaryMode = "hyperedges") {
 		for (const [position, port] of ports.entries()) {
 			tree.remove(position);
 			const node = ownerByPort.get(port.id);
-			const targets = node.type === "NORMAL" ? nodes.get(port.dummy).ports.map((peer) => ({
+			const targets = node.type === "NORMAL" ? (nodes ??= new Map(graph.layers.flat().map((node$1) => [node$1.id, node$1]))).get(port.dummy).ports.map((peer) => ({
 				id: peer.id,
 				degree: degree(peer.id)
 			})) : node.type === "LONG_EDGE" ? node.ports.filter((peer) => peer.id !== port.id).slice(0, 1).map((peer) => ({
@@ -1102,7 +1114,7 @@ function buildCrossingGraph(plan, layers, incoming, outgoing) {
 			for (const member of ports.get(operation.northSouthDummy)?.values() ?? []) member.port.origin = operation.id;
 		}
 	}
-	const sideRank = {
+	const sideRank$1 = {
 		NORTH: 0,
 		EAST: 1,
 		SOUTH: 2,
@@ -1115,7 +1127,7 @@ function buildCrossingGraph(plan, layers, incoming, outgoing) {
 				id,
 				type: kind?.type ?? kindOf(id, plan.units),
 				unit: kind ? kind.unit : plan.units?.units.get(id),
-				ports: [...ports.get(id)?.values() ?? []].sort((a, b) => sideRank[a.port.side] - sideRank[b.port.side] || a.rank - b.rank).map((member) => member.port)
+				ports: [...ports.get(id)?.values() ?? []].sort((a, b) => sideRank$1[a.port.side] - sideRank$1[b.port.side] || a.rank - b.rank).map((member) => member.port)
 			};
 		})),
 		edges: plan.edges.map((edge) => ({
@@ -1135,7 +1147,8 @@ function splitMixedCrossingPorts(graph, reversed) {
 	const directions = /* @__PURE__ */ new Map();
 	graph.edges.forEach((edge, index) => {
 		const bit = reversed[index] ? 2 : 1;
-		for (const port of [edge.source, edge.target]) directions.set(port, (directions.get(port) ?? 0) | bit);
+		directions.set(edge.source, (directions.get(edge.source) ?? 0) | bit);
+		directions.set(edge.target, (directions.get(edge.target) ?? 0) | bit);
 	});
 	const mixed = /* @__PURE__ */ new Set();
 	for (const layer of graph.layers) for (const node of layer) for (const port of node.ports) if (directions.get(port.id) === 3 && (port.side === "EAST" || port.side === "WEST")) mixed.add(port.id);
@@ -1575,20 +1588,46 @@ function selfLoopTracks(loops) {
 	}));
 }
 
+//#endregion
+//#region src/layered/node-lookup.ts
+const indexByNodes = /* @__PURE__ */ new WeakMap();
+function indexNodes(nodes) {
+	const positions = /* @__PURE__ */ new Map();
+	for (const [index, node] of nodes.entries()) if (!positions.has(node.id)) positions.set(node.id, index);
+	indexByNodes.set(nodes, {
+		length: nodes.length,
+		positions
+	});
+	return positions;
+}
+/** Same as `nodes.find((node) => node.id === id)`, indexed per list. */
+function findNode(nodes, id) {
+	const cached = indexByNodes.get(nodes);
+	let position = (cached && cached.length === nodes.length ? cached.positions : indexNodes(nodes)).get(id);
+	if (position !== void 0 && nodes[position]?.id !== id) position = indexNodes(nodes).get(id);
+	return position !== void 0 && nodes[position]?.id === id ? nodes[position] : nodes.find((node) => node.id === id);
+}
+
 //#endregion
 //#region src/layered/loop-envelopes.ts
 /** 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;
-	const node = input.graph.nodes.find((candidate) => candidate.id === edge.sourceId);
+	const node = findNode(input.graph.nodes, edge.sourceId);
 	const constraints = node && input.nodeSettings?.(node)?.portConstraints;
 	return constraints === void 0 || constraints === "FREE" || constraints === "UNDEFINED";
 }
 function loopEnvelopes(input) {
 	const envelopes = /* @__PURE__ */ new Map();
 	if ((input.settings.edgeRouting ?? "ORTHOGONAL") !== "ORTHOGONAL") return envelopes;
+	const loopsByNodeId = /* @__PURE__ */ new Map();
+	for (const edge of input.graph.edges) if (edge.sourceId === edge.targetId) {
+		const loops = loopsByNodeId.get(edge.sourceId);
+		if (loops) loops.push(edge);
+		else loopsByNodeId.set(edge.sourceId, [edge]);
+	}
 	for (const node of input.graph.nodes) {
-		const allLoops = input.graph.edges.filter((edge) => edge.sourceId === node.id && edge.targetId === node.id);
+		const allLoops = loopsByNodeId.get(node.id)?.slice() ?? [];
 		const constraints = input.nodeSettings?.(node)?.portConstraints;
 		if (allLoops.length && constraints && constraints !== "FREE" && constraints !== "UNDEFINED" && allLoops.every((edge) => edge.sourcePort !== void 0 && edge.targetPort !== void 0 && input.edgeSettings?.(edge)?.["edgeLabels.inline"] !== true && ((edge.width ?? 0) === 0 && (edge.height ?? 0) === 0 || (input.edgeSettings?.(edge)?.["edgeLabels.placement"] ?? "CENTER") === "CENTER"))) {
 			const size$1 = input.sizes.get(node.id) ?? {
@@ -1701,7 +1740,7 @@ function preparedLoopEnvelopes(input) {
 //#region src/layered/port-edge-order.ts
 /** ELK traverses connected edges through the node's port list, preserving each port's edge order. */
 function connectedEdgesInPortOrder(input, nodeId) {
-	const node = input.graph.nodes.find((candidate) => candidate.id === nodeId);
+	const node = findNode(input.graph.nodes, nodeId);
 	const portRank = new Map(node?.ports?.map((port, index) => [port.name, index]));
 	const explicitCount = portRank.size;
 	return input.graph.edges.map((edge, index) => ({
@@ -2590,8 +2629,8 @@ function nodeNodeSpacing(input, firstId, secondId) {
 	const secondBreakingPoint = secondId.startsWith("__layout_breaking:");
 	const firstLabel = firstId.startsWith("__layout_dummy:label:");
 	const secondLabel = secondId.startsWith("__layout_dummy:label:");
-	const firstNode = input.graph.nodes.find((node) => node.id === firstId);
-	const secondNode = input.graph.nodes.find((node) => node.id === secondId);
+	const firstNode = findNode(input.graph.nodes, firstId);
+	const secondNode = findNode(input.graph.nodes, secondId);
 	const firstExternal = firstNode !== void 0 && externalPortDummyOf(firstNode) !== void 0;
 	const secondExternal = secondNode !== void 0 && externalPortDummyOf(secondNode) !== void 0;
 	const firstDummy = firstId.startsWith("__layout_dummy:") || firstBreakingPoint || firstExternal;
@@ -2599,7 +2638,7 @@ function nodeNodeSpacing(input, firstId, secondId) {
 	const spacingName = firstExternal && secondExternal ? "spacing.portPort" : firstExternal && secondLabel || secondExternal && firstLabel ? "spacing.labelPortVertical" : firstLabel && secondLabel ? "spacing.edgeEdge" : firstLabel && !secondDummy || secondLabel && !firstDummy ? "spacing.node" : firstLabel && secondDummy || secondLabel && firstDummy ? "spacing.edgeNode" : firstDummy && secondDummy && firstBreakingPoint === secondBreakingPoint ? "spacing.edgeEdge" : firstDummy || secondDummy ? "spacing.edgeNode" : "spacing.node";
 	let spacing = spacingName === "spacing.portPort" ? Number(input.settings["spacing.portPort"] ?? 10) : spacingName === "spacing.labelPortVertical" ? Number(input.settings["spacing.labelPortVertical"] ?? 1) : spacingName === "spacing.edgeEdge" ? Number(input.settings["spacing.edgeEdge"] ?? 10) : spacingName === "spacing.edgeNode" ? Number(input.settings["spacing.edgeNode"] ?? 10) : input.spacing.node;
 	for (const id of [firstId, secondId]) {
-		const node = input.graph.nodes.find((candidate) => candidate.id === id);
+		const node = findNode(input.graph.nodes, id);
 		if (!node) continue;
 		const individual = input.nodeSettings?.(node)?.["spacing.individual"];
 		if (individual && typeof individual === "object") {
@@ -3410,16 +3449,35 @@ function sidePorts(node, side) {
 	const ports = node.ports.filter((port) => port.side === side);
 	return side === "WEST" || side === "SOUTH" ? ports.reverse() : ports;
 }
+function greedySwitchTopology(graph) {
+	const topology = {
+		incoming: /* @__PURE__ */ new Map(),
+		outgoing: /* @__PURE__ */ new Map(),
+		layerByPort: /* @__PURE__ */ new Map(),
+		ownerByPort: /* @__PURE__ */ new Map()
+	};
+	for (const [layer, nodes] of graph.layers.entries()) for (const node of nodes) for (const port of node.ports) {
+		topology.layerByPort.set(port.id, layer);
+		topology.ownerByPort.set(port.id, node);
+		topology.incoming.set(port.id, []);
+		topology.outgoing.set(port.id, []);
+	}
+	for (const edge of graph.edges) {
+		topology.outgoing.get(edge.source)?.push(edge.target);
+		topology.incoming.get(edge.target)?.push(edge.source);
+	}
+	return topology;
+}
 /**
 * Decides greedy switches in one free layer from local two-node crossing
 * counts, exactly as ELK does; these estimates can differ from a global recount.
 */
 var GreedySwitchDecider = class {
 	#free;
-	#incoming = /* @__PURE__ */ new Map();
-	#outgoing = /* @__PURE__ */ new Map();
-	#layerByPort = /* @__PURE__ */ new Map();
-	#ownerByPort = /* @__PURE__ */ new Map();
+	#incoming;
+	#outgoing;
+	#layerByPort;
+	#ownerByPort;
 	#neighbourPositions = /* @__PURE__ */ new Map();
 	#adjacencies = /* @__PURE__ */ new Map();
 	#matrix = /* @__PURE__ */ new Map();
@@ -3427,19 +3485,13 @@ var GreedySwitchDecider = class {
 	#cardinality = /* @__PURE__ */ new Map();
 	#inLayerSize = /* @__PURE__ */ new Map();
 	#oneSided;
-	constructor(graph, freeLayerIndex, oneSided) {
+	constructor(graph, freeLayerIndex, oneSided, topology = greedySwitchTopology(graph)) {
 		this.#free = graph.layers[freeLayerIndex] ?? [];
 		this.#oneSided = oneSided;
-		for (const [layer, nodes] of graph.layers.entries()) for (const node of nodes) for (const port of node.ports) {
-			this.#layerByPort.set(port.id, layer);
-			this.#ownerByPort.set(port.id, node);
-			this.#incoming.set(port.id, []);
-			this.#outgoing.set(port.id, []);
-		}
-		for (const edge of graph.edges) {
-			this.#outgoing.get(edge.source)?.push(edge.target);
-			this.#incoming.get(edge.target)?.push(edge.source);
-		}
+		this.#incoming = topology.incoming;
+		this.#outgoing = topology.outgoing;
+		this.#layerByPort = topology.layerByPort;
+		this.#ownerByPort = topology.ownerByPort;
 		for (const [layerIndex, side] of [[freeLayerIndex - 1, "EAST"], [freeLayerIndex + 1, "WEST"]]) {
 			let position = 0;
 			for (const node of graph.layers[layerIndex] ?? []) for (const port of sidePorts(node, side)) this.#neighbourPositions.set(port.id, position++);
@@ -4311,6 +4363,7 @@ function applyGreedySwitch(input, orientation, order) {
 		if (oneSidedBoundary !== void 0) return countBoundary(oneSidedBoundary);
 		return (layerIndex > 0 ? countBoundary(layerIndex - 1) : 0) + (layerIndex + 1 < layers.length ? countBoundary(layerIndex) : 0);
 	};
+	let greedyTopology;
 	const sweep = (forward$1) => {
 		let changed = false;
 		const indices = forward$1 ? Array.from({ length: layers.length }, (_, index) => index) : Array.from({ length: layers.length }, (_, index) => layers.length - index - 1);
@@ -4320,7 +4373,7 @@ function applyGreedySwitch(input, orientation, order) {
 			if (greedyGraph) {
 				const units = getCrossingUnits(input);
 				greedyGraph.layers = layers.map((ids) => ids.map((id) => greedyNodes.get(id)));
-				const decider = new GreedySwitchDecider(greedyGraph, layerIndex, type === "ONE_SIDED" ? forward$1 ? "WEST" : "EAST" : void 0);
+				const decider = new GreedySwitchDecider(greedyGraph, layerIndex, type === "ONE_SIDED" ? forward$1 ? "WEST" : "EAST" : void 0, greedyTopology ??= greedySwitchTopology(greedyGraph));
 				do {
 					improved$1 = false;
 					for (let index = 0; index + 1 < layer.length; index++) {
@@ -4913,7 +4966,9 @@ function sortLayerByAdjacentPosition(layer, ranksByNodeId, statistic, random, pr
 	if (units && !forcedCompare) layer.splice(0, layer.length, ...resolveCrossingConstraints(layer, adjacentPosition, units));
 }
 function clonePortOrders(orders) {
-	return new Map([...orders ?? []].map(([id, edges]) => [id, [...edges]]));
+	const clone = /* @__PURE__ */ new Map();
+	if (orders) for (const [id, edges] of orders) clone.set(id, edges.slice());
+	return clone;
 }
 function minimizeCrossingsWithLayerSweep(statistic, sweeps = 7) {
 	return (input, orientation, assignment) => createLayerSweepSession(input, orientation, assignment, statistic, sweeps).minimize();
@@ -5006,14 +5061,16 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 	const buildCrossingGraph$1 = createCrossingGraphBuilder(input);
 	const crossingModel = input.settings[CROSSING_MODEL] ?? {};
 	const mixedPorts = crossingModel.mixedPorts !== false, probe = crossingModel.probe;
+	const physicalSlot = /* @__PURE__ */ new Map();
 	const countCrossings = (candidateLayers) => {
 		if (exactPortSweep) {
 			const graph = buildCrossingGraph$1(orientation, candidateLayers, inputPortOrder, outputPortOrder);
 			for (const layer of graph.layers) for (const node of layer) {
 				const physical = node.ports.length > 1 ? canonicalNodes.get(node.id)?.ports : void 0;
 				if (physical?.length !== node.ports.length) continue;
-				const slot = new Map(physical.map((port, index) => [port.id, index]));
-				if (node.ports.every((port) => slot.has(port.id))) node.ports.sort((a, b) => slot.get(a.id) - slot.get(b.id));
+				physicalSlot.clear();
+				for (const [index, port] of physical.entries()) physicalSlot.set(port.id, index);
+				if (node.ports.every((port) => physicalSlot.has(port.id))) node.ports.sort((a, b) => physicalSlot.get(a.id) - physicalSlot.get(b.id));
 			}
 			const split = mixedPorts ? splitMixedCrossingPorts(graph, canonicalReversed) : graph;
 			const score = countAllCrossings(split, crossingModel.separateSharedTracks ? "separated" : "hyperedges");
@@ -5115,6 +5172,17 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 		}
 		for (const id of freeLayer) {
 			const order = (forward ? inputPortOrder : outputPortOrder).get(id) ?? [];
+			const visit = (edgeId) => {
+				const [source, target] = getOrientedEndpoints(edgeById.get(edgeId), orientation);
+				const neighbor = forward ? source : target;
+				const rank$1 = edgeRanks.get(edgeId);
+				if (assignment.layerByNodeId.get(neighbor) === assignment.layerByNodeId.get(id)) visits.get(id).push(neighbor);
+				else if (rank$1 !== void 0) visits.get(id).push(rank$1);
+			};
+			if (order.length < 2) {
+				for (const edgeId of order) visit(edgeId);
+				continue;
+			}
 			const groups = /* @__PURE__ */ new Map();
 			for (const edgeId of order) {
 				const edge = edgeById.get(edgeId);
@@ -5123,17 +5191,11 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 				if (group) group.push(edgeId);
 				else groups.set(key, [edgeId]);
 			}
+			const listed = units?.edgeListRanks?.[forward ? "incoming" : "outgoing"].get(id);
+			const rank = (edgeId) => listed?.get(listedEdgeId(edgeId));
 			for (const group of groups.values()) {
-				const listed = units?.edgeListRanks?.[forward ? "incoming" : "outgoing"].get(id);
-				const rank = (edgeId) => listed?.get(listedEdgeId(edgeId));
-				group.sort((a, b) => (rank(a) !== void 0 && rank(b) !== void 0 ? rank(a) - rank(b) : 0) || edgeModelOrder.get(a) - edgeModelOrder.get(b));
-				for (const edgeId of group) {
-					const [source, target] = getOrientedEndpoints(edgeById.get(edgeId), orientation);
-					const neighbor = forward ? source : target;
-					const rank$1 = edgeRanks.get(edgeId);
-					if (assignment.layerByNodeId.get(neighbor) === assignment.layerByNodeId.get(id)) visits.get(id).push(neighbor);
-					else if (rank$1 !== void 0) visits.get(id).push(rank$1);
-				}
+				if (group.length > 1) group.sort((a, b) => (rank(a) !== void 0 && rank(b) !== void 0 ? rank(a) - rank(b) : 0) || edgeModelOrder.get(a) - edgeModelOrder.get(b));
+				for (const edgeId of group) visit(edgeId);
 			}
 		}
 		return {
@@ -5181,6 +5243,7 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 			hierarchical: hierarchicalNodes
 		});
 		for (const index of touched) for (const node of canonicalGraph.layers[index]) {
+			if (node.ports.length < 2 || (outputPortOrder.get(node.id)?.length ?? 0) < 2 && (inputPortOrder.get(node.id)?.length ?? 0) < 2) continue;
 			const ordinal = new Map(node.ports.map((port, index$1) => [port.id, index$1]));
 			for (const [orders, source] of [[outputPortOrder, true], [inputPortOrder, false]]) orders.get(node.id)?.sort((left, right) => ordinal.get(canonicalEndpoints.get(left)[source ? "source" : "target"]) - ordinal.get(canonicalEndpoints.get(right)[source ? "source" : "target"]));
 		}
@@ -5398,12 +5461,16 @@ function createLayerSweepSession(input, orientation, assignment, statistic = "me
 		shuffleFirstLayer,
 		sweep,
 		countCrossings: () => countCrossings(working),
-		snapshot: () => ({
-			physicalPortOrderByNodeId: new Map([...canonicalNodes].map(([id, node]) => [id, node.ports.map((port) => port.id)])),
-			layers: working.map((layer) => [...layer]),
-			inputPortOrderByNodeId: clonePortOrders(inputPortOrder),
-			outputPortOrderByNodeId: clonePortOrders(outputPortOrder)
-		}),
+		snapshot: () => {
+			const physicalPortOrderByNodeId = /* @__PURE__ */ new Map();
+			for (const [id, node] of canonicalNodes) physicalPortOrderByNodeId.set(id, node.ports.map((port) => port.id));
+			return {
+				physicalPortOrderByNodeId,
+				layers: working.map((layer) => [...layer]),
+				inputPortOrderByNodeId: clonePortOrders(inputPortOrder),
+				outputPortOrderByNodeId: clonePortOrders(outputPortOrder)
+			};
+		},
 		restore,
 		finish,
 		currentLayers: () => working,
@@ -5813,7 +5880,7 @@ function sumWithSpacing(ids, input, axis) {
 	}, 0);
 }
 function nodeFlowOffset(input, id, layerFlowSize, nodeFlowSize, layerByNodeId, margins) {
-	const node = input.graph.nodes.find((candidate) => candidate.id === id);
+	const node = findNode(input.graph.nodes, id);
 	const alignment = node ? input.nodeSettings?.(node)?.alignment ?? input.settings.alignment : input.settings.alignment;
 	let ratio;
 	if (alignment === "LEFT" || alignment === "TOP") ratio = 0;
@@ -6062,7 +6129,56 @@ function simplifyRoute$1(points) {
 function implicitEdgeEndpoints(input, placement, orientation) {
 	const horizontal$1 = input.direction === "left" || input.direction === "right";
 	const nodeById = new Map(input.graph.nodes.map((node) => [node.id, node]));
-	const groups = /* @__PURE__ */ new Map();
+	const nodeSettingsByNode = /* @__PURE__ */ new Map();
+	const nodeSettingsOf = (node) => {
+		if (!nodeSettingsByNode.has(node)) nodeSettingsByNode.set(node, input.nodeSettings?.(node));
+		return nodeSettingsByNode.get(node);
+	};
+	const portSettingsByNode = /* @__PURE__ */ new Map();
+	const portSettingsOf = (port, node) => {
+		let byPort = portSettingsByNode.get(node);
+		if (!byPort) portSettingsByNode.set(node, byPort = /* @__PURE__ */ new Map());
+		if (!byPort.has(port)) byPort.set(port, input.portSettings?.(port, node));
+		return byPort.get(port);
+	};
+	const groups = [];
+	const groupsBySide = /* @__PURE__ */ new Map();
+	const modelOrderPromotion = input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT";
+	const directionReversed = input.direction === "left" || input.direction === "up";
+	const endpointSide = (nodeId, portName) => {
+		const node = nodeById.get(nodeId);
+		const port = node?.ports?.find((candidate) => candidate.name === portName);
+		const constraints = node ? nodeSettingsOf(node)?.portConstraints : void 0;
+		if (!node || !port || constraints !== "FIXED_SIDE" && constraints !== "FIXED_ORDER" && constraints !== "FIXED_RATIO" && constraints !== "FIXED_POS") return;
+		const configured = portSettingsOf(port, node)?.["port.side"];
+		return configured === "WEST" || configured === "NORTH" ? "before" : configured === "EAST" || configured === "SOUTH" ? "after" : void 0;
+	};
+	const fixedImplicitSide = (nodeId, portName, source) => {
+		const node = nodeById.get(nodeId);
+		const constraints = node && nodeSettingsOf(node)?.portConstraints;
+		if (portName !== void 0 || ![
+			"FIXED_SIDE",
+			"FIXED_ORDER",
+			"FIXED_RATIO",
+			"FIXED_POS"
+		].includes(String(constraints))) return void 0;
+		return source !== directionReversed ? "after" : "before";
+	};
+	const addEntry = (nodeId, side, entry) => {
+		let byNode = groupsBySide.get(side);
+		if (!byNode) groupsBySide.set(side, byNode = /* @__PURE__ */ new Map());
+		const group = byNode.get(nodeId);
+		if (group) group.entries.push(entry);
+		else {
+			const created = {
+				nodeId,
+				side,
+				entries: [entry]
+			};
+			byNode.set(nodeId, created);
+			groups.push(created);
+		}
+	};
 	for (const edge of input.graph.edges) {
 		if (hasMovableLoopPorts(input, edge)) continue;
 		const sourceRect = placement.rectByNodeId.get(edge.sourceId);
@@ -6070,47 +6186,20 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		if (!sourceRect || !targetRect) continue;
 		const sourceFlow = horizontal$1 ? sourceRect.x : sourceRect.y;
 		const targetFlow = horizontal$1 ? targetRect.x : targetRect.y;
-		const modelOrderPromotion = input.settings["layering.nodePromotion.strategy"] === "MODEL_ORDER_LEFT_TO_RIGHT";
 		const sourceBoundary = externalPortDummyOf(nodeById.get(edge.sourceId) ?? {});
 		const targetBoundary = externalPortDummyOf(nodeById.get(edge.targetId) ?? {});
 		const forward = modelOrderPromotion || (sourceFlow === targetFlow && (sourceBoundary || targetBoundary) ? sourceBoundary ? sourceBoundary.port.side === "EAST" || sourceBoundary.port.side === "SOUTH" : targetBoundary.port.side === "WEST" || targetBoundary.port.side === "NORTH" : sourceFlow <= targetFlow);
 		const feedback = input.settings.feedbackEdges === true && orientation?.reversedEdgeIds.has(edge.id) === true;
-		const directionReversed = input.direction === "left" || input.direction === "up";
-		const endpointSide = (nodeId, portName) => {
-			const node = nodeById.get(nodeId);
-			const port = node?.ports?.find((candidate) => candidate.name === portName);
-			const constraints = node ? input.nodeSettings?.(node)?.portConstraints : void 0;
-			if (!node || !port || constraints !== "FIXED_SIDE" && constraints !== "FIXED_ORDER" && constraints !== "FIXED_RATIO" && constraints !== "FIXED_POS") return;
-			const configured = input.portSettings?.(port, node)?.["port.side"];
-			return configured === "WEST" || configured === "NORTH" ? "before" : configured === "EAST" || configured === "SOUTH" ? "after" : void 0;
-		};
-		const fixedImplicitSide = (nodeId, portName, source) => {
-			const node = nodeById.get(nodeId);
-			const constraints = node && input.nodeSettings?.(node)?.portConstraints;
-			if (portName !== void 0 || ![
-				"FIXED_SIDE",
-				"FIXED_ORDER",
-				"FIXED_RATIO",
-				"FIXED_POS"
-			].includes(String(constraints))) return void 0;
-			return source !== directionReversed ? "after" : "before";
-		};
 		const sourceSide = endpointSide(edge.sourceId, edge.sourcePort) ?? fixedImplicitSide(edge.sourceId, edge.sourcePort, true) ?? (feedback ? directionReversed ? "before" : "after" : forward ? "after" : "before");
 		const targetSide = endpointSide(edge.targetId, edge.targetPort) ?? fixedImplicitSide(edge.targetId, edge.targetPort, false) ?? (feedback ? directionReversed ? "after" : "before" : forward ? "before" : "after");
-		const sourceKey = `${edge.sourceId}:${sourceSide}`;
-		const targetKey = `${edge.targetId}:${targetSide}`;
-		const sourceGroup = groups.get(sourceKey) ?? [];
-		sourceGroup.push({
+		addEntry(edge.sourceId, sourceSide, {
 			edge,
 			endpoint: "source"
 		});
-		groups.set(sourceKey, sourceGroup);
-		const targetGroup = groups.get(targetKey) ?? [];
-		targetGroup.push({
+		addEntry(edge.targetId, targetSide, {
 			edge,
 			endpoint: "target"
 		});
-		groups.set(targetKey, targetGroup);
 	}
 	const result = /* @__PURE__ */ new Map();
 	const edgeModelOrder = new Map(input.graph.edges.map((edge, index) => [edge.id, index]));
@@ -6131,22 +6220,19 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 		if (!counts) {
 			counts = /* @__PURE__ */ new Map();
 			for (const port of node.ports ?? []) {
-				const portSide = input.portSettings?.(port, node)?.["port.side"];
+				const portSide = portSettingsOf(port, node)?.["port.side"];
 				counts.set(portSide, (counts.get(portSide) ?? 0) + 1);
 			}
 			portSideCounts.set(node, counts);
 		}
 		return counts.get(side) ?? 0;
 	};
-	for (const [key, entries] of groups) {
-		const split = key.lastIndexOf(":");
-		const nodeId = key.slice(0, split);
-		const side = key.slice(split + 1);
+	for (const { nodeId, side, entries } of groups) {
 		const rect = placement.rectByNodeId.get(nodeId);
 		if (!rect) continue;
 		const mergeEdges = input.settings.mergeEdges === true;
 		const node = nodeById.get(nodeId);
-		const nodeSettings = node ? input.nodeSettings?.(node) : void 0;
+		const nodeSettings = node ? nodeSettingsOf(node) : void 0;
 		const hypernode = nodeSettings?.hypernode;
 		const unzipping = (input.settings["layerUnzipping.strategy"] ?? "NONE") === "ALTERNATING";
 		const crossingStrategy = input.settings["crossingMinimization.strategy"] ?? "LAYER_SWEEP";
@@ -6238,9 +6324,9 @@ function implicitEdgeEndpoints(input, placement, orientation) {
 			};
 			const portName = endpoint === "source" ? edge.sourcePort : edge.targetPort;
 			const explicitPort = node?.ports?.find((port) => port.name === portName);
-			const physicalSide = node && explicitPort ? input.portSettings?.(explicitPort, node)?.["port.side"] : void 0;
+			const physicalSide = node && explicitPort ? portSettingsOf(explicitPort, node)?.["port.side"] : void 0;
 			const singleFixedSidePort = constraints === "FIXED_SIDE" && physicalSide !== void 0 && node?.ports !== void 0 && portSideCount(node, physicalSide) === 1;
-			const authoredAnchor = node && explicitPort ? input.portSettings?.(explicitPort, node)?.["port.anchor"] : void 0;
+			const authoredAnchor = node && explicitPort ? portSettingsOf(explicitPort, node)?.["port.anchor"] : void 0;
 			if (portName !== void 0 && node && (constraints === "FIXED_POS" || constraints === "FIXED_RATIO" || constraints === "FIXED_ORDER" || singleFixedSidePort || authoredAnchor !== void 0)) point = getPortPoint(node, portName, rect, point, input.direction, input, placedPorts);
 			const pair = result.get(edge.id) ?? {
 				source: point,
@@ -6451,6 +6537,14 @@ function routeEdges(style) {
 			flowLayerByNodeId.set(interval.id, flowLayers.length - 1);
 		}
 		const bodyFlowLayers = flowLayers.map((bounds) => ({ ...bounds }));
+		const placedIdsByFlowLayer = () => {
+			const ids = flowLayers.map(() => []);
+			for (const id of placement.rectByNodeId.keys()) {
+				const layer = flowLayerByNodeId.get(id);
+				if (layer !== void 0) ids[layer].push(id);
+			}
+			return ids;
+		};
 		const labelFlowLayers = new Set([...flowLayerByNodeId].filter(([id]) => id.startsWith("__layout_dummy:label:")).map(([, layer]) => layer));
 		for (const [id, rect] of placement.rectByNodeId) {
 			const node = nodeById.get(id);
@@ -6527,10 +6621,11 @@ function routeEdges(style) {
 			labelExtraByGap[gap] = Math.max(labelExtraByGap[gap] ?? 0, extra);
 		}
 		let labelShift = 0;
+		const labelShiftIds = placedIdsByFlowLayer();
 		for (const [layerNo, bounds] of flowLayers.entries()) {
 			if (labelShift !== 0) {
-				for (const [id, rect] of placement.rectByNodeId) {
-					if (flowLayerByNodeId.get(id) !== layerNo) continue;
+				for (const id of labelShiftIds[layerNo]) {
+					const rect = placement.rectByNodeId.get(id);
 					mutableRects.set(id, horizontal$1 ? {
 						...rect,
 						x: rect.x + labelShift
@@ -6878,18 +6973,21 @@ function routeEdges(style) {
 			const leadingSlots = slotsByGap[0] ?? 0;
 			const leadingWidth = leadingSlots > 0 ? edgeNodeSpacing + (leadingSlots - 1) * edgeEdgeSpacing : 0;
 			let nextStart = (flowLayers[0]?.start ?? 0) + leadingWidth;
+			const flowLayerIds = flowLayers.map(() => []);
+			for (const [id, layer] of flowLayerByNodeId) flowLayerIds[layer].push(id);
 			const externalFlowLayers = new Set(flowLayers.flatMap((_, layer) => {
-				const ids = [...flowLayerByNodeId].filter(([, index]) => index === layer);
-				return ids.length && ids.every(([id]) => {
+				const ids = flowLayerIds[layer];
+				return ids.length && ids.every((id) => {
 					const node = nodeById.get(id);
 					const side = node && externalPortDummyOf(node)?.side;
 					return horizontal$1 ? side === "WEST" || side === "EAST" : side === "NORTH" || side === "SOUTH";
 				}) ? [layer] : [];
 			}));
+			const shiftedIds = placedIdsByFlowLayer();
 			for (const [layerNo, bounds] of flowLayers.entries()) {
 				const shift = nextStart - bounds.start;
-				for (const [id, rect] of placement.rectByNodeId) {
-					if (flowLayerByNodeId.get(id) !== layerNo) continue;
+				for (const id of shiftedIds[layerNo]) {
+					const rect = placement.rectByNodeId.get(id);
 					mutableRects.set(id, horizontal$1 ? {
 						...rect,
 						x: rect.x + shift
@@ -7103,10 +7201,11 @@ function routeEdges(style) {
 				});
 			}
 			let nextStart = flowLayers[0]?.start ?? 0;
+			const shiftedIds = placedIdsByFlowLayer();
 			for (const [layerNo, bounds] of flowLayers.entries()) {
 				const shift = nextStart - bounds.start;
-				for (const [id, rect] of placement.rectByNodeId) {
-					if (flowLayerByNodeId.get(id) !== layerNo) continue;
+				for (const id of shiftedIds[layerNo]) {
+					const rect = placement.rectByNodeId.get(id);
 					mutableRects.set(id, horizontal$1 ? {
 						...rect,
 						x: rect.x + shift
@@ -7979,7 +8078,7 @@ function normalizePlacementForPortExtents(input, placement, order, orientation)
 		let trailingBoundary = Number.NEGATIVE_INFINITY;
 		let leadingBoundary = Number.POSITIVE_INFINITY;
 		for (const [ids, trailing] of [[layer, true], [nextLayer, false]]) for (const id of ids) {
-			const node = input.graph.nodes.find((candidate) => candidate.id === id);
+			const node = findNode(input.graph.nodes, id);
 			const rect = placement.rectByNodeId.get(id);
 			if (!node || !rect) continue;
 			const bodyStart = horizontal$1 ? rect.x : rect.y;
@@ -14799,10 +14898,16 @@ function buildNeighbors(input, order) {
 			return (horizontal$1 ? port?.height : port?.width) ?? 0;
 		});
 	};
+	const loopsByNodeId = /* @__PURE__ */ new Map();
+	for (const edge of input.graph.edges) if (edge.sourceId === edge.targetId) {
+		const loops = loopsByNodeId.get(edge.sourceId);
+		if (loops) loops.push(edge);
+		else loopsByNodeId.set(edge.sourceId, [edge]);
+	}
 	const loopTerminals = (id, side) => {
 		const node = nodeById.get(id);
 		if (!node) return 0;
-		return input.graph.edges.filter((edge) => edge.sourceId === id && edge.targetId === id).flatMap((edge) => [edge.sourcePort, edge.targetPort]).filter((name) => {
+		return (loopsByNodeId.get(id) ?? []).flatMap((edge) => [edge.sourcePort, edge.targetPort]).filter((name) => {
 			const port = node.ports?.find((candidate) => candidate.name === name);
 			return port !== void 0 && input.portSettings?.(port, node)?.["port.side"] === side.toUpperCase() && usesSharedSideSlot(input, node, name);
 		}).length;
@@ -14913,8 +15018,8 @@ function alignBlocks(input, order, bal, neighbors, markedEdges) {
 			const adjacent = (bal.hdir === "LEFT" ? neighbors.right : neighbors.left).get(id) ?? [];
 			const low = Math.floor((adjacent.length + 1) / 2) - 1;
 			const high = Math.ceil((adjacent.length + 1) / 2) - 1;
-			const indices = bal.vdir === "UP" ? Array.from({ length: Math.max(0, high - low + 1) }, (_, i) => high - i) : Array.from({ length: Math.max(0, high - low + 1) }, (_, i) => low + i);
-			for (const median of indices) {
+			for (let i = 0; i < high - low + 1; i++) {
+				const median = bal.vdir === "UP" ? high - i : low + i;
 				if (bal.align.get(id) !== id) break;
 				const neighbor = adjacent[median];
 				if (neighbor === void 0) continue;
@@ -18743,11 +18848,14 @@ function* createLayeredScopePipeline(graph, options, context) {
 		settings: options.settings ?? {},
 		...options.nodeSettings === void 0 ? {} : { nodeSettings: options.nodeSettings },
 		...options.edgeSettings === void 0 ? {} : { edgeSettings: options.edgeSettings },
-		portSettings: (port, node) => ({
-			...options.portSettings?.(port, node),
-			...parallelPortIndexByKey.has(`${node.id}\0${port.name}`) ? { "port.index": parallelPortIndexByKey.get(`${node.id}\0${port.name}`) } : {},
-			...switchedSideByPort.has(`${node.id}\0${port.name}`) ? { "port.side": switchedSideByPort.get(`${node.id}\0${port.name}`) } : {}
-		})
+		portSettings: (port, node) => {
+			const key = `${node.id}\0${port.name}`;
+			return {
+				...options.portSettings?.(port, node),
+				...parallelPortIndexByKey.has(key) ? { "port.index": parallelPortIndexByKey.get(key) } : {},
+				...switchedSideByPort.has(key) ? { "port.side": switchedSideByPort.get(key) } : {}
+			};
+		}
 	};
 	const measure = (id, run) => {
 		context?.throwIfAborted();
@@ -18893,8 +19001,10 @@ function* createLayeredScopePipeline(graph, options, context) {
 	const northEdges = /* @__PURE__ */ new Set(), southEdges = /* @__PURE__ */ new Set();
 	const upper = direction === "right" || direction === "left" ? "NORTH" : "WEST";
 	const lower = direction === "right" || direction === "left" ? "SOUTH" : "EAST";
+	const endpointNodes = /* @__PURE__ */ new Map();
+	for (const node of expanded.input.graph.nodes) if (!endpointNodes.has(node.id)) endpointNodes.set(node.id, node);
 	for (const edge of expanded.input.graph.edges) for (const [id, name] of [[edge.sourceId, edge.sourcePort], [edge.targetId, edge.targetPort]]) {
-		const node = expanded.input.graph.nodes.find((n) => n.id === id), port = node?.ports?.find((p) => p.name === name);
+		const node = endpointNodes.get(id), port = node?.ports?.find((p) => p.name === name);
 		const side = node && port ? expanded.input.portSettings?.(port, node)?.["port.side"] : void 0;
 		if (side === upper) northEdges.add(id);
 		if (side === lower) southEdges.add(id);