@statelyai/layout 0.4.1 → 0.4.3

package/dist/{layout-engine-CLFySz3R.cjs → layout-engine-BFP1TZbF.cjs}

@@ -1,4 +1,4 @@
-const require_layered = require('./layered-5RxQhryb.cjs');
+const require_layered = require('./layered-BJu8A21s.cjs');
 let _statelyai_graph_layout = require("@statelyai/graph/layout");
 
 //#region src/fixed.ts

package/dist/{layout-engine-GpBIX6ng.mjs → layout-engine-DnlmGxHL.mjs}

@@ -1,4 +1,4 @@
-import { K as placePorts, X as JavaRandom, i as layeredAlgorithm, n as elkjs0111LayeredAlgorithm, x as setElkjs0111ResultPolicy, z as getPolylineMidpoint } from "./layered-DSesbctm.mjs";
+import { K as placePorts, X as JavaRandom, i as layeredAlgorithm, n as elkjs0111LayeredAlgorithm, x as setElkjs0111ResultPolicy, z as getPolylineMidpoint } from "./layered-BsAdm_u8.mjs";
 import { getNodeSize } from "@statelyai/graph/layout";
 
 //#region src/fixed.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statelyai/layout",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Extensible, graph-native layout algorithms for @statelyai/graph",
   "license": "EPL-2.0 OR GPL-3.0-or-later",
   "repository": {

package/src/elkjs/index.ts

@@ -96,6 +96,31 @@ interface PreparedElkScope {
   finish(orders?: ReadonlyMap<PreparedElkScope, LayerOrder>): Promise<ElkNode>;
 }
 
+const LAYOUT_UNITS_PER_PX = 64;
+
+/**
+ * Measured sizes carry float noise (a browser rect divided by zoom), and a
+ * layered layout is full of exact ties that noise decides. Snap sizes to the
+ * browser's 1/64px layout unit so the same graph always lays out the same way;
+ * sizes already on that grid are unchanged.
+ */
+function snapSizes(node: ElkNode): void {
+  const snap = (shape: { width?: number; height?: number }) => {
+    if (typeof shape.width === "number")
+      shape.width = Math.round(shape.width * LAYOUT_UNITS_PER_PX) / LAYOUT_UNITS_PER_PX;
+    if (typeof shape.height === "number")
+      shape.height = Math.round(shape.height * LAYOUT_UNITS_PER_PX) / LAYOUT_UNITS_PER_PX;
+  };
+  snap(node);
+  for (const label of node.labels ?? []) snap(label);
+  for (const port of node.ports ?? []) {
+    snap(port);
+    for (const label of port.labels ?? []) snap(label);
+  }
+  for (const edge of node.edges ?? []) for (const label of edge.labels ?? []) snap(label);
+  for (const child of node.children ?? []) snapSizes(child);
+}
+
 export default class ELK {
   readonly #options: ElkConstructorArguments;
   readonly #algorithmIds: ReadonlySet<string>;
@@ -171,6 +196,7 @@ export default class ELK {
     graph: T,
     arguments_: ElkLayoutArguments = {},
   ): Promise<LaidOutElkNode<T>> {
+    snapSizes(graph);
     const options = { ...this.#options.defaultLayoutOptions, ...arguments_.layoutOptions };
     const seeds = crossingVariants(options, graph);
     const probe = mayShareTracks(graph, options)
@@ -1096,6 +1122,14 @@ export default class ELK {
       getOption(layoutOptions, "padding"),
       algorithm === "layered" ? 12 : 0,
     );
+    // Element options are replaced, never mutated, while a scope lays out; parse each once.
+    const parsedSettings = new WeakMap<object, ElkLayeredOptionValueByName>();
+    const elementSettings = (elementOptions: Readonly<Record<string, unknown>> | undefined) => {
+      const key = elementOptions ?? noElementOptions;
+      let settings = parsedSettings.get(key);
+      if (!settings) parsedSettings.set(key, (settings = getElementLayeredSettings(key)));
+      return settings;
+    };
     const options: LayeredLayoutOptions = {
       direction: getDirection(layoutOptions),
       spacing: {
@@ -1132,13 +1166,13 @@ export default class ELK {
       },
       nodeSettings: (node) => {
         const child = findById(graph.children, node.id)?.item;
-        return getElementLayeredSettings(child?.layoutOptions ?? {});
+        return elementSettings(child?.layoutOptions);
       },
       edgeSettings: (edge) => {
         const elkEdge = findById(graph.edges, edge.id)?.item;
         return {
-          ...getElementLayeredSettings(elkEdge?.layoutOptions ?? {}),
-          ...getElementLayeredSettings(elkEdge?.labels?.[0]?.layoutOptions ?? {}),
+          ...elementSettings(elkEdge?.layoutOptions),
+          ...elementSettings(elkEdge?.labels?.[0]?.layoutOptions),
           // ELK appends hierarchy segments to port edge lists in creation order.
           "edge.hierarchyRank": elkEdge && hierarchySegmentRank.get(elkEdge),
         };
@@ -1148,7 +1182,7 @@ export default class ELK {
         const found = findById(child?.ports, port.name);
         const elkPort = found?.item;
         return {
-          ...getElementLayeredSettings(elkPort?.layoutOptions ?? {}),
+          ...elementSettings(elkPort?.layoutOptions),
           // ELK imports ports in authored order and sorts sides after dummy insertion.
           "port.authoredIndex": found?.position,
           "port.labelWidth": Math.max(
@@ -1746,8 +1780,16 @@ function applyNodeMicroLayout(
   }
 }
 
+// Accepted spellings per option suffix, built once.
+const exactKeysBySuffix = new Map<string, readonly string[]>();
+
 function getOption(options: Readonly<Record<string, unknown>>, suffix: string): unknown {
-  const exactKeys = [suffix, `elk.${suffix}`, `org.eclipse.elk.${suffix}`];
+  let exactKeys = exactKeysBySuffix.get(suffix);
+  if (!exactKeys)
+    exactKeysBySuffix.set(
+      suffix,
+      (exactKeys = [suffix, `elk.${suffix}`, `org.eclipse.elk.${suffix}`]),
+    );
   for (const key of exactKeys) {
     if (options[key] !== undefined) return options[key];
   }
@@ -1832,6 +1874,8 @@ function findById<T extends { id?: ElkId }>(items: readonly T[] | undefined, id:
   return position === undefined ? undefined : { item: items[position]!, position };
 }
 
+const noElementOptions: Readonly<Record<string, unknown>> = {};
+
 function getElementLayeredSettings(
   options: Readonly<Record<string, unknown>>,
 ): ElkLayeredOptionValueByName {

package/src/layered/bk-node-placement.ts

@@ -328,11 +328,17 @@ function buildNeighbors(input: LayeredPhaseInput, order: LayerOrder) {
   };
   // Routing gives fixed-side self-loop terminals on shared-slot ports a slot
   // among the side's other edges (after them here), so anchors reserve it.
+  const loopsByNodeId = new Map<string, GraphEdge[]>();
+  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: string, side: string): number => {
     const node = nodeById.get(id);
     if (!node) return 0;
-    return input.graph.edges
-      .filter((edge) => edge.sourceId === id && edge.targetId === id)
+    return (loopsByNodeId.get(id) ?? [])
       .flatMap((edge) => [edge.sourcePort, edge.targetPort])
       .filter((name) => {
         const port = node.ports?.find((candidate) => candidate.name === name);
@@ -515,11 +521,8 @@ function alignBlocks(
       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 === undefined) continue;

package/src/layered/crossing-counter.ts

@@ -66,7 +66,8 @@ export function countAllCrossings(
   /** "separated" counts hyperedges like ELK unless they would share a track (see scoreOrthogonalHypersegments). */
   boundaryMode: "hyperedges" | "separated" | "edges" = "hyperedges",
 ): CrossingScore {
-  const nodes = new Map(graph.layers.flat().map((node) => [node.id, node]));
+  // Only north/south counting resolves nodes by id.
+  let nodes: Map<string, CrossingNode> | undefined;
   const layerByPort = new Map<string, number>();
   const incoming = new Map<string, string[]>(),
     outgoing = new Map<string, string[]>();
@@ -81,7 +82,6 @@ export function countAllCrossings(
     outgoing.get(edge.source)!.push(edge.target);
     incoming.get(edge.target)!.push(edge.source);
   }
-  const connected = (id: string) => [...incoming.get(id)!, ...outgoing.get(id)!];
   const degree = (id: string) => incoming.get(id)!.length + outgoing.get(id)!.length;
   const face = (layer: readonly CrossingNode[], side: "EAST" | "WEST", topDown = true) =>
     (topDown ? layer : [...layer].reverse()).flatMap((node) => {
@@ -95,7 +95,11 @@ export function countAllCrossings(
     for (const [position, port] of ports.entries()) {
       tree.remove(position);
       const pending: number[] = [];
-      for (const peer of connected(port.id)) {
+      // Incoming then outgoing peers, without concatenating them.
+      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 += tree.size;
           continue;
@@ -144,7 +148,9 @@ export function countAllCrossings(
       const node = ownerByPort.get(port.id)!;
       const targets =
         node.type === "NORMAL"
-          ? nodes.get(port.dummy!)!.ports.map((peer) => ({ id: peer.id, degree: degree(peer.id) }))
+          ? (nodes ??= new Map(graph.layers.flat().map((node) => [node.id, node])))
+              .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)

package/src/layered/crossing-graph.ts

@@ -353,8 +353,8 @@ export function splitMixedCrossingPorts(
   const directions = new Map<string, number>();
   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 = new Set<string>();
   for (const layer of graph.layers)

package/src/layered/greedy-switch-decider.ts

@@ -15,6 +15,36 @@ function sidePorts(node: CrossingNode, side: Side): CrossingPort[] {
   return side === "WEST" || side === "SOUTH" ? ports.reverse() : ports;
 }
 
+/** Port connectivity and layers; switches within layers leave it unchanged. */
+export interface GreedySwitchTopology {
+  incoming: Map<string, string[]>;
+  outgoing: Map<string, string[]>;
+  layerByPort: Map<string, number>;
+  ownerByPort: Map<string, CrossingNode>;
+}
+
+export function greedySwitchTopology(graph: CrossingGraph): GreedySwitchTopology {
+  const topology: GreedySwitchTopology = {
+    incoming: new Map(),
+    outgoing: new Map(),
+    layerByPort: new Map(),
+    ownerByPort: 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;
+}
+
 interface Adjacency {
   position: number;
   cardinality: number;
@@ -27,10 +57,10 @@ interface Adjacency {
  */
 export class GreedySwitchDecider {
   readonly #free: readonly CrossingNode[];
-  readonly #incoming = new Map<string, string[]>();
-  readonly #outgoing = new Map<string, string[]>();
-  readonly #layerByPort = new Map<string, number>();
-  readonly #ownerByPort = new Map<string, CrossingNode>();
+  readonly #incoming: ReadonlyMap<string, readonly string[]>;
+  readonly #outgoing: ReadonlyMap<string, readonly string[]>;
+  readonly #layerByPort: ReadonlyMap<string, number>;
+  readonly #ownerByPort: ReadonlyMap<string, CrossingNode>;
   readonly #neighbourPositions = new Map<string, number>();
   readonly #adjacencies = new Map<string, { sides: Map<Side, Adjacency[]> }>();
   readonly #matrix = new Map<string, [number, number]>();
@@ -39,21 +69,18 @@ export class GreedySwitchDecider {
   readonly #inLayerSize = new Map<Side, number>();
   readonly #oneSided?: "WEST" | "EAST";
 
-  constructor(graph: CrossingGraph, freeLayerIndex: number, oneSided?: "WEST" | "EAST") {
+  constructor(
+    graph: CrossingGraph,
+    freeLayerIndex: number,
+    oneSided?: "WEST" | "EAST",
+    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"],

package/src/layered/index.ts

@@ -1436,15 +1436,16 @@ export function* createLayeredScopePipeline<N, E, G, P>(
     settings: options.settings ?? {},
     ...(options.nodeSettings === undefined ? {} : { nodeSettings: options.nodeSettings }),
     ...(options.edgeSettings === undefined ? {} : { 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 = <T>(id: string, run: () => T): T => {
     context?.throwIfAborted();
@@ -1697,12 +1698,16 @@ export function* createLayeredScopePipeline<N, E, G, P>(
     southEdges = new Set<string>();
   const upper = direction === "right" || direction === "left" ? "NORTH" : "WEST";
   const lower = direction === "right" || direction === "left" ? "SOUTH" : "EAST";
+  // First node per id, as `find` returns.
+  const endpointNodes = new Map<string, GraphNode>();
+  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),
+      const node = endpointNodes.get(id!),
         port = node?.ports?.find((p) => p.name === name);
       const side =
         node && port ? expanded.input.portSettings?.(port, node)?.["port.side"] : undefined;

package/src/layered/loop-envelopes.ts

@@ -7,6 +7,7 @@ import {
   routeFixedSelfLoop,
   selfLoopTracks,
 } from "./fixed-self-loop";
+import { findNode } from "./node-lookup";
 
 export interface LoopEnvelope {
   before: number;
@@ -23,7 +24,7 @@ export function hasMovableLoopPorts(input: LayeredPhaseInput, edge: GraphEdge):
     edge.targetPort !== undefined
   )
     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 === undefined || constraints === "FREE" || constraints === "UNDEFINED";
 }
@@ -31,10 +32,15 @@ export function hasMovableLoopPorts(input: LayeredPhaseInput, edge: GraphEdge):
 export function loopEnvelopes(input: LayeredPhaseInput): ReadonlyMap<string, LoopEnvelope> {
   const envelopes = new Map<string, LoopEnvelope>();
   if ((input.settings.edgeRouting ?? "ORTHOGONAL") !== "ORTHOGONAL") return envelopes;
+  const loopsByNodeId = new Map<string, GraphEdge[]>();
+  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 &&

package/src/layered/node-lookup.ts

@@ -0,0 +1,29 @@
+import type { GraphNode } from "@statelyai/graph";
+
+// First position of each id per node list, rebuilt when the list's length
+// changes. Layout code only appends to node lists, never replaces entries in
+// place; positions are still checked on use and a miss scans like `find`.
+const indexByNodes = new WeakMap<
+  readonly GraphNode[],
+  { length: number; positions: Map<string, number> }
+>();
+
+function indexNodes(nodes: readonly GraphNode[]): Map<string, number> {
+  const positions = new Map<string, number>();
+  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. */
+export function findNode(nodes: readonly GraphNode[], id: string): GraphNode | undefined {
+  const cached = indexByNodes.get(nodes);
+  let position = (
+    cached && cached.length === nodes.length ? cached.positions : indexNodes(nodes)
+  ).get(id);
+  if (position !== undefined && nodes[position]?.id !== id) position = indexNodes(nodes).get(id);
+  return position !== undefined && nodes[position]?.id === id
+    ? nodes[position]
+    : nodes.find((node) => node.id === id);
+}

package/src/layered/port-distributor.ts

@@ -18,6 +18,8 @@ export interface PortDistributionOptions {
 }
 
 /** Stateful clockwise port distribution across successive layer sweeps. */
+const sideRank = { NORTH: 0, EAST: 1, SOUTH: 2, WEST: 3 };
+
 export class CanonicalPortDistributor {
   readonly state: PortDistributionState;
   private topologyGraph?: CrossingGraph;
@@ -73,27 +75,36 @@ export class CanonicalPortDistributor {
   ): void {
     this.prepareTopology(graph);
     let consumed = 0;
+    // Only ports with edges toward the free layer take ranks.
+    const ends = input ? this.incoming : this.outgoing;
+    const ranked = (port: CrossingPort) => 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;
     }
   }
 
@@ -109,14 +120,15 @@ export class CanonicalPortDistributor {
     const ranks = (layer: CrossingNode[], input: boolean) =>
       this.calculatePortRanks(graph, layer, input, options.nodeRelative);
     const distributeNode = (node: CrossingNode, side: "EAST" | "WEST") => {
-      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 = graph.layers[layerIndex]!.length;
       for (const face of [side, "SOUTH", "NORTH"] as const) {
         let minimum = 0,
           maximum = 0;
         const inLayer: CrossingPort[] = [];
-        for (const port of node.ports.filter((port) => port.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) {
@@ -135,8 +147,8 @@ export class CanonicalPortDistributor {
             else if (output && !input) sum += position + 1;
             else if (input && output) sum += port.side === "NORTH" ? 0 : large / 2;
           } else {
-            const peers = [...outgoing.get(port.id)!, ...incoming.get(port.id)!];
-            if (peers.some((peer) => layerByPort.get(peer) === layerIndex)) {
+            const sameLayer = (peer: string) => layerByPort.get(peer) === layerIndex;
+            if (outgoing.get(port.id)!.some(sameLayer) || incoming.get(port.id)!.some(sameLayer)) {
               inLayer.push(port);
               continue;
             }
@@ -168,7 +180,7 @@ export class CanonicalPortDistributor {
                 : minimum - (size + 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 = sideRank[a.side] - sideRank[b.side];
         if (side) return side;

package/src/layered/port-edge-order.ts

@@ -1,9 +1,10 @@
 import type { GraphEdge } from "@statelyai/graph";
 import type { LayeredPhaseInput } from "./types";
+import { findNode } from "./node-lookup";
 
 /** ELK traverses connected edges through the node's port list, preserving each port's edge order. */
 export function connectedEdgesInPortOrder(input: LayeredPhaseInput, nodeId: string): GraphEdge[] {
-  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

package/src/layered/spacing.ts

@@ -1,5 +1,6 @@
 import { externalPortDummyOf } from "./external-port-dummy";
 import type { LayeredPhaseInput } from "./types";
+import { findNode } from "./node-lookup";
 
 export type IndividualSpacing = Readonly<Record<string, number>>;
 
@@ -13,8 +14,8 @@ export function nodeNodeSpacing(
   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 !== undefined && externalPortDummyOf(firstNode) !== undefined;
   const secondExternal = secondNode !== undefined && externalPortDummyOf(secondNode) !== undefined;
   const firstDummy = firstId.startsWith("__layout_dummy:") || firstBreakingPoint || firstExternal;
@@ -47,7 +48,7 @@ export function nodeNodeSpacing(
             ? 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") {