@mark1russell7/highways 0.9.1 → 0.9.3

package/src/plugs/spread/index.ts

@@ -0,0 +1,217 @@
+/**
+ * The plug strategy `spread` (PLUG-SPREAD): the free plugs of each wall share the room of that wall with a minimum gap.
+ * The order on the wall keeps the order of the far ends, so two routes do not cross at the wall. No plug drops.
+ */
+import { center, type Box, type Point } from "../../geom.ts";
+import { nodeIndex, portOffset, type End, type Node, type Side } from "../../model.ts";
+import { nearestSide, placePlug, SIDE_NORMAL, sideToward, type Plug } from "../../plugs.ts";
+import type { PlugInput, PlugPair } from "../../strategies/model.ts";
+import { isotonic } from "../justify.ts";
+
+/** The options of the plug strategy `spread`. */
+export interface SpreadOptions {
+  /** The least gap between two plugs of one wall. When the room of the wall is too small, the gap shrinks evenly. The default is 8. */
+  readonly plugGap?: number;
+  /** The distance from a plug to a corner of its box, or a quarter of the wall when the wall is short. The default is 6. */
+  readonly inset?: number;
+  /** The number of passes that sort each wall again by the new places of the far ends. The default is 2. */
+  readonly rounds?: number;
+}
+
+/** The defaults of the plug strategy `spread`. */
+export const SPREAD_DEFAULTS: Required<SpreadOptions> = Object.freeze({ plugGap: 8, inset: 6, rounds: 2 });
+
+/** A free plug: one port of a node, or one end without a port. All the ends of one port share its plug. */
+interface Slot {
+  readonly node: Node;
+  readonly side: Side;
+  /** The place of the plug that faces the far end (`placePlug`), on the axis along the wall. */
+  readonly ideal: number;
+  /** The index of the port in the ports of its node, then the index of the slot. Thus the rows of a card keep their order in a tie. */
+  readonly rank: readonly [number, number];
+  /** The far end of the first end of the slot: a fixed plug, or the key of its slot. */
+  far?: Plug | string;
+  /** The place of the plug on the axis along the wall. */
+  at: number;
+}
+
+/** A wall: one side of one node, with its free slots and the places of its fixed plugs on the axis along the wall. */
+interface Wall {
+  readonly node: Node;
+  readonly side: Side;
+  readonly slots: Slot[];
+  readonly fixed: number[];
+}
+
+/** This function gives the axis along a side. */
+function alongOf(side: Side): "x" | "y" {
+  return side === "east" || side === "west" ? "y" : "x";
+}
+
+/** This function gives the room of a wall: the segment of the axis along the side, without the corner insets. */
+function roomOf(box: Box, side: Side, inset: number): [number, number] {
+  const along = alongOf(side);
+  const start = along === "y" ? box.y : box.x;
+  const len = along === "y" ? box.h : box.w;
+  const m = Math.min(inset, len / 4);
+  return [start + m, start + len - m];
+}
+
+/** This function gives the point of a side at `v` on the axis along the side. */
+function pointAt(box: Box, side: Side, v: number): Point {
+  if (side === "east") return { x: box.x + box.w, y: v };
+  if (side === "west") return { x: box.x, y: v };
+  if (side === "south") return { x: v, y: box.y + box.h };
+  return { x: v, y: box.y };
+}
+
+/**
+ * This function gives the sort key of a far point on a wall. The key has the order of the angle from the normal of the wall, from the center of the box.
+ * The key grows in the direction of the axis along the wall. Thus the plugs in the order of the keys do not cross at the wall.
+ */
+function keyOf(box: Box, side: Side, far: Point): number {
+  const c = center(box);
+  const n = SIDE_NORMAL[side];
+  const dx = far.x - c.x;
+  const dy = far.y - c.y;
+  const out = dx * n.x + dy * n.y;
+  const along = alongOf(side) === "y" ? dy : dx;
+  // A pseudo-angle with the order of the angle: a sum and one division, with no transcendental call. It goes from -2 to 2.
+  const size = Math.abs(out) + Math.abs(along);
+  if (size === 0) return 0;
+  const p = along / size;
+  if (out >= 0) return p;
+  return along >= 0 ? 2 - p : -2 - p;
+}
+
+/**
+ * This function places `ideal.length` plugs in their given order on the segment from `lo` to `hi`. Two neighbours are at least `gap` apart.
+ * The gap shrinks evenly when the segment is too short. The sum of the squares of the moves from the ideal places is the least.
+ */
+function placeInOrder(ideal: readonly number[], lo: number, hi: number, gap: number): number[] {
+  const k = ideal.length;
+  if (k === 0) return [];
+  const s = k > 1 ? Math.max(0, Math.min(gap, (hi - lo) / (k - 1))) : 0;
+  const y = isotonic(ideal.map((v, i) => v - i * s));
+  const top = Math.max(lo, hi - (k - 1) * s);
+  return y.map((v, i) => Math.max(lo, Math.min(top, v)) + i * s);
+}
+
+/**
+ * This function places the slots of one wall in their order. The fixed plugs cut the room into parts.
+ * Each slot goes into the part of its ideal place, and the parts keep the order of the slots. In each part, two plugs and a plug and a fixed plug are at least `gap` apart.
+ * The gap of a part shrinks evenly when the part is too short.
+ */
+function placeWall(slots: readonly Slot[], fixed: readonly number[], lo: number, hi: number, gap: number): void {
+  const cuts = [...new Set(fixed.filter((f) => f > lo - 1e-9 && f < hi + 1e-9))].sort((a, b) => a - b);
+  // The part i is from cuts[i - 1] to cuts[i]. The first part starts at lo, and the last part ends at hi.
+  const ends = [lo, ...cuts, hi];
+  const parts: Slot[][] = cuts.map(() => []).concat([[]]);
+  let part = 0;
+  for (const s of slots) {
+    let p = 0;
+    while (p < cuts.length && s.ideal > cuts[p]!) p++;
+    part = Math.max(part, p);
+    parts[part]!.push(s);
+  }
+  parts.forEach((list, p) => {
+    if (list.length === 0) return;
+    const a = ends[p]!;
+    const b = ends[p + 1]!;
+    const fa = p > 0 ? 1 : 0;
+    const fb = p < cuts.length ? 1 : 0;
+    const steps = list.length - 1 + fa + fb;
+    const s = steps > 0 ? Math.max(0, Math.min(gap, (b - a) / steps)) : gap;
+    const lower = a + fa * s;
+    const upper = Math.max(lower, b - fb * s);
+    const at = placeInOrder(
+      list.map((x) => x.ideal),
+      lower,
+      upper,
+      s,
+    );
+    list.forEach((x, i) => {
+      x.at = at[i]!;
+    });
+  });
+}
+
+/**
+ * This function gives the plugs of the plug strategy `spread`. A fixed plug stays at its point, and a plug with a side stays on that side.
+ * Each free plug goes on the side that faces the other end (`sideToward`). Then the free plugs of each wall share its room with at least `plugGap` between two of them.
+ * They keep the order of their far ends. The ends of one port share one plug.
+ *
+ * The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export function spreadEnds(input: PlugInput, options: SpreadOptions = {}): PlugPair[] {
+  const { graph } = input;
+  const gap = options.plugGap ?? SPREAD_DEFAULTS.plugGap;
+  const inset = options.inset ?? SPREAD_DEFAULTS.inset;
+  const rounds = options.rounds ?? SPREAD_DEFAULTS.rounds;
+  const byId = nodeIndex(graph);
+  const slots = new Map<string, Slot>();
+  const walls = new Map<string, Wall>();
+  // The plug of each end: a fixed plug, or the key of its slot.
+  const ends: { edge: string; source: Plug | string; target: Plug | string }[] = [];
+  const wallOf = (node: Node, side: Side): Wall => {
+    const key = JSON.stringify([node.id, side]);
+    let wall = walls.get(key);
+    if (!wall) {
+      const fixed: number[] = [];
+      for (const p of node.ports ?? []) {
+        const at = portOffset(node.box, p);
+        if (at === undefined) continue;
+        const point = { x: node.box.x + at.x, y: node.box.y + at.y };
+        if ((p.side ?? nearestSide(node.box, point)) === side) fixed.push(point[alongOf(side)]);
+      }
+      walls.set(key, (wall = { node, side, slots: [], fixed }));
+    }
+    return wall;
+  };
+  const plugOf = (node: Node, end: End, far: Node): Plug | string => {
+    const toward = center(far.box);
+    const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
+    if (port && portOffset(node.box, port) !== undefined) return placePlug(node, end, toward);
+    const key = port ? JSON.stringify([node.id, port.id]) : JSON.stringify([node.id, slots.size]);
+    if (slots.has(key)) return key;
+    const side = port?.side ?? sideToward(node.box, toward);
+    const ideal = placePlug(node, end, toward).point[alongOf(side)];
+    const slot: Slot = { node, side, ideal, rank: [port ? node.ports!.indexOf(port) : -1, slots.size], at: ideal };
+    slots.set(key, slot);
+    wallOf(node, side).slots.push(slot);
+    return key;
+  };
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t) continue;
+    const source = plugOf(s, e.source, t);
+    const target = plugOf(t, e.target, s);
+    for (const [own, far] of [
+      [source, target],
+      [target, source],
+    ] as const) {
+      const slot = typeof own === "string" ? slots.get(own)! : undefined;
+      if (slot && slot.far === undefined) slot.far = far;
+    }
+    ends.push({ edge: e.id, source, target });
+  }
+  const resolve = (p: Plug | string): Plug => {
+    if (typeof p !== "string") return p;
+    const s = slots.get(p)!;
+    return { point: pointAt(s.node.box, s.side, s.at), normal: SIDE_NORMAL[s.side] };
+  };
+  // A pass sorts each wall by the places of the far ends as they are now, and places its plugs. A tie keeps the order of the last pass.
+  const order = new Map<Slot, number>();
+  for (let round = 0; round <= rounds; round++) {
+    for (const wall of walls.values()) {
+      const [lo, hi] = roomOf(wall.node.box, wall.side, inset);
+      const keys = new Map<Slot, number>(wall.slots.map((s) => [s, keyOf(wall.node.box, wall.side, resolve(s.far!).point)]));
+      const tie = (a: Slot, b: Slot): number => (round === 0 ? a.rank[0] - b.rank[0] || a.rank[1] - b.rank[1] : order.get(a)! - order.get(b)!);
+      const sorted = [...wall.slots].sort((a, b) => keys.get(a)! - keys.get(b)! || tie(a, b));
+      sorted.forEach((s, i) => order.set(s, i));
+      placeWall(sorted, wall.fixed, lo, hi, gap);
+    }
+  }
+  return ends.map((x) => ({ edge: x.edge, source: resolve(x.source), target: resolve(x.target) }));
+}

package/src/routers/corners.ts

@@ -1,16 +1,17 @@
-import { center, type Point } from "../geom.ts";
-import { nodeIndex, fixedPortPoint, resolvePorts, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
+import { center } from "../geom.ts";
+import { nodeIndex, resolvePorts, splitFrames, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
-import { justifyPlugs } from "../plugs/justify.ts";
+import { spacePlugs } from "../plugs/justify.ts";
 import { sidePlugs } from "../plugs/side.ts";
 import type { PlugPair, Strategy } from "../strategies/model.ts";
-import { WayFinder, type WayOptions } from "../ways.ts";
+import { WayFinder } from "../ways.ts";
+import { frameRoutes, type FrameOptions } from "./frames.ts";
 
 /** The ways to place a free plug of the corner router. */
 export type PlugPlace = "facing" | "side";
 
 /** The options of the corner router. */
-export interface CornersOptions extends WayOptions {
+export interface CornersOptions extends FrameOptions {
   /** The name in the benchmark. */
   readonly name: string;
   /** The benchmark skips a fixture with more nodes. */
@@ -38,15 +39,21 @@ export interface CornersOptions extends WayOptions {
  * This function makes a router that goes around the nodes.
  * Each edge leaves its plug along the normal of the side. It goes a shortest way (A*) through a sparse visibility graph
  * of the box corners, without the needless corners. It enters the target plug along its normal.
+ * An inner edge (`splitFrames`) gets an inner route in the bounds of its frame (`frameRoutes`), after the outer routes.
  */
 export function cornersRouter(options: CornersOptions): Router {
   const router: Router = {
     name: options.name,
     route(input: Graph): Result {
-      const graph = resolvePorts(input);
+      const { graph, inner } = splitFrames(resolvePorts(input));
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const routes: Route[] = [];
+      // The inner routes come after the outer routes.
+      const done = (): Result => {
+        if (inner.length > 0) routes.push(...frameRoutes(graph, inner, options));
+        return { routes };
+      };
       if (!options.plug && (options.plugs ?? "facing") === "facing" && !((options.plugGap ?? 0) > 0)) {
         for (const e of graph.edges) {
           const s = byId.get(e.source.node);
@@ -56,7 +63,7 @@ export function cornersRouter(options: CornersOptions): Router {
           const pt = placePlug(t, e.target, center(s.box));
           routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
         }
-        return { routes };
+        return done();
       }
       // First the plugs of each edge, then the gaps of the plugs of each side, then the ways between the plugs.
       const ends: [Edge, Node, Node, Plug, Plug][] = [];
@@ -75,7 +82,7 @@ export function cornersRouter(options: CornersOptions): Router {
       }
       if ((options.plugGap ?? 0) > 0) spacePlugs(ends, options.plugGap!);
       for (const [e, s, t, ps, pt] of ends) routes.push({ edge: e.id, points: ways.between(ps, pt, new Set<Node>([s, t])) });
-      return { routes };
+      return done();
     },
   };
   return options.maxNodes === undefined ? router : { ...router, maxNodes: options.maxNodes };
@@ -91,39 +98,3 @@ function plugsByEdge(list: readonly PlugPair[]): Map<string, PlugPair[]> {
   }
   return out;
 }
-
-/**
- * This function moves the free plugs of each side of each node, so that two of them are at least `gap` apart (`justifyPlugs`).
- * The plugs keep their order on the side. Two plugs at one place take the order of their other ends. A fixed plug does not move.
- */
-function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number): void {
-  const inset = 6;
-  // The free plugs of each side: the index of the edge, the end (3 for the source, 4 for the target) and the point of the other end.
-  const sides = new Map<string, { node: Node; normal: Point; items: [number, 3 | 4, Point][] }>();
-  ends.forEach(([e, s, t, ps, pt], i) => {
-    for (const [end, node, plug, other, k] of [
-      [e.source, s, ps, pt, 3],
-      [e.target, t, pt, ps, 4],
-    ] as const) {
-      if (fixedPortPoint(node, end) !== undefined) continue;
-      const key = JSON.stringify([node.id, plug.normal.x, plug.normal.y]);
-      let side = sides.get(key);
-      if (!side) sides.set(key, (side = { node, normal: plug.normal, items: [] }));
-      side.items.push([i, k, other.point]);
-    }
-  });
-  for (const { node, normal, items } of sides.values()) {
-    if (items.length < 2) continue;
-    const along = normal.x !== 0 ? "y" : "x";
-    const b = node.box;
-    const start = along === "y" ? b.y : b.x;
-    const len = along === "y" ? b.h : b.w;
-    const m = Math.min(inset, len / 4);
-    const ideal = items.map(([i, k]) => ends[i]![k].point[along]);
-    const placed = justifyPlugs(ideal, start + m, start + len - m, gap, (j) => items[j]![2][along]);
-    items.forEach(([i, k], j) => {
-      const old = ends[i]![k];
-      ends[i]![k] = { point: along === "y" ? { x: old.point.x, y: placed[j]! } : { x: placed[j]!, y: old.point.y }, normal: old.normal };
-    });
-  }
-}

package/src/routers/frames.ts

@@ -0,0 +1,136 @@
+import { center, dist, type Box, type Point } from "../geom.ts";
+import { nodeIndex, type Graph, type InnerEdge, type Node, type Route } from "../model.ts";
+import { placePlug, type Plug } from "../plugs.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+
+/**
+ * The rule for a node box that is not fully inside the box of its frame.
+ * With `throw`, the router throws a `RangeError`. With `skip`, the node is not an obstacle, and its inner edges get no route.
+ * With `clamp`, the router cuts the box to the bounds of the frame.
+ */
+export type Outside = "throw" | "skip" | "clamp";
+
+/** The options of the inner routes: the options of the way finder, the rule `outside` and the inset `frameInset`. */
+export interface FrameOptions extends WayOptions {
+  /** The rule for a node box outside the box of its frame. The default is `throw`. */
+  readonly outside?: Outside;
+  /** The distance from the walls of a frame to the bounds of its inner routes. The default is the margin of the router. */
+  readonly frameInset?: number;
+}
+
+/** The inside of one frame for the inner edges to one depth: the bounds, the way finder and the obstacles by id. */
+interface Room {
+  readonly ways: WayFinder;
+  readonly nodes: ReadonlyMap<string, Node>;
+}
+
+/** The tiny gap between the bounds and the band of a wall, so that a way along the bounds stays clear of the wall. */
+const EPS = 1e-6;
+
+/**
+ * This function gives the inner routes of the inner edges (`splitFrames`). Each route stays in the bounds of its frame:
+ * the box of the frame, smaller by `frameInset`. It goes around the other nodes of the frame.
+ * It leaves the plug of the frame into the frame, along the normal of the wall. Each route has the id of its frame in `frame`.
+ */
+export function frameRoutes(graph: Graph, inner: readonly InnerEdge[], options: FrameOptions): Route[] {
+  const byId = nodeIndex(graph);
+  const children = new Map<string, Node[]>();
+  for (const n of graph.nodes) {
+    if (n.parent === undefined) continue;
+    const list = children.get(n.parent);
+    if (list) list.push(n);
+    else children.set(n.parent, [n]);
+  }
+  const margin = options.margin ?? 5;
+  const inset = options.frameInset ?? margin;
+  const rooms = new Map<string, Room>();
+  const routes: Route[] = [];
+  for (const { edge, frame, plug } of inner) {
+    const f = byId.get(frame)!;
+    const [own, far] = plug === "source" ? [edge.source, edge.target] : [edge.target, edge.source];
+    // The nodes between the frame and the far end: each of them holds the far end, so it is not an obstacle.
+    const chain: string[] = [];
+    for (let p = byId.get(far.node)!.parent!; p !== frame; p = byId.get(p)!.parent!) chain.push(p);
+    const key = JSON.stringify([frame, ...chain]);
+    let room = rooms.get(key);
+    if (!room) rooms.set(key, (room = makeRoom(f, chain, children, byId, inset, options)));
+    const end = room.nodes.get(far.node);
+    if (!end) continue;
+    const fp = placePlug(f, own, center(end.box));
+    const inward = { x: -fp.normal.x, y: -fp.normal.y };
+    // The way starts on the bounds, straight in from the plug of the wall.
+    const start: Plug = { point: { x: fp.point.x + inward.x * inset, y: fp.point.y + inward.y * inset }, normal: inward };
+    const ep = placePlug(end, far, fp.point);
+    const ends = new Set<Node>([end]);
+    const points =
+      plug === "source" ? stub(fp.point, room.ways.between(start, ep, ends)) : stub(fp.point, room.ways.between(ep, start, ends).reverse()).reverse();
+    routes.push({ edge: edge.id, points, frame });
+  }
+  return routes;
+}
+
+/** This function puts the plug of the wall before a way that starts on the bounds. A first point on the line of the stub goes. */
+function stub(plug: Point, way: Point[]): Point[] {
+  const [a, b] = way;
+  if (!a || dist(a, plug) === 0) return way;
+  if (b && Math.abs((a.x - plug.x) * (b.y - plug.y) - (a.y - plug.y) * (b.x - plug.x)) < 1e-9 && (a.x - plug.x) * (b.x - a.x) + (a.y - plug.y) * (b.y - a.y) > 0)
+    return [plug, ...way.slice(1)];
+  return [plug, ...way];
+}
+
+/**
+ * This function makes the room of a frame for the far ends below the nodes of `chain` (the nearest first).
+ * The obstacles are the children of the frame and of each node of the chain, except the nodes of the chain.
+ * Four walls close the bounds, so that no way leaves them.
+ */
+function makeRoom(f: Node, chain: readonly string[], children: ReadonlyMap<string, readonly Node[]>, byId: ReadonlyMap<string, Node>, inset: number, options: FrameOptions): Room {
+  const margin = options.margin ?? 5;
+  const bounds = shrink(f.box, inset);
+  const skip = new Set(chain);
+  const nodes = new Map<string, Node>();
+  for (const holder of [f.id, ...chain]) {
+    for (const n of children.get(holder) ?? []) {
+      if (skip.has(n.id)) continue;
+      const box = byId.get(holder)!.box;
+      if (inside(n.box, box)) {
+        nodes.set(n.id, n);
+        continue;
+      }
+      const rule = options.outside ?? "throw";
+      if (rule === "throw")
+        throw new RangeError(`The box of the node "${n.id}" is not inside the box of its frame "${holder}". The option outside can skip or clamp it.`);
+      if (rule === "skip") continue;
+      const cut = cutBox(n.box, bounds);
+      if (cut) nodes.set(n.id, { ...n, box: cut, ...(n.ports ? { ports: n.ports.map((p) => (p.at ? { ...p, at: { x: p.at.x + n.box.x - cut.x, y: p.at.y + n.box.y - cut.y } } : p)) } : {}) });
+    }
+  }
+  // The band of each wall starts half a margin outside the bounds, so that a way keeps in the bounds.
+  const w = shrink(bounds, -(margin / 2 + EPS));
+  const t = 2 * margin + 1;
+  const walls: Node[] = [
+    { x: w.x - t, y: w.y - t, w: w.w + 2 * t, h: t },
+    { x: w.x - t, y: w.y + w.h, w: w.w + 2 * t, h: t },
+    { x: w.x - t, y: w.y, w: t, h: w.h },
+    { x: w.x + w.w, y: w.y, w: t, h: w.h },
+  ].map((box, i) => ({ id: `\u0000wall${i}`, box }));
+  return { ways: new WayFinder([...nodes.values(), ...walls], options), nodes };
+}
+
+/** This function gives the box, smaller by `d` on each side. A negative `d` makes it larger. */
+function shrink(b: Box, d: number): Box {
+  return { x: b.x + d, y: b.y + d, w: Math.max(0, b.w - 2 * d), h: Math.max(0, b.h - 2 * d) };
+}
+
+/** This function tells if the box `a` is inside the box `b`. */
+function inside(a: Box, b: Box): boolean {
+  return a.x >= b.x && a.y >= b.y && a.x + a.w <= b.x + b.w && a.y + a.h <= b.y + b.h;
+}
+
+/** This function gives the part of the box `a` inside the box `b`, or `undefined` when they have no common area. */
+function cutBox(a: Box, b: Box): Box | undefined {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const w = Math.min(a.x + a.w, b.x + b.w) - x;
+  const h = Math.min(a.y + a.h, b.y + b.h) - y;
+  return w > 0 && h > 0 ? { x, y, w, h } : undefined;
+}

package/src/routers/index.ts

@@ -9,6 +9,7 @@ import { byCollection, trunksRouter } from "./trunks.ts";
 export { boxExit, straightRouter } from "./straight.ts";
 export { plugsRouter } from "./plugs.ts";
 export { cornersRouter, type CornersOptions } from "./corners.ts";
+export { frameRoutes, type FrameOptions, type Outside } from "./frames.ts";
 export { sharedRouter, type ShareCost, type SharedNegotiation, type SharedOptions, type ShareMerge, type ShareOrder } from "./shared.ts";
 export { ATTRACTION_DEFAULTS, ATTRACTION_SCHEMA, attractionRouter, attractionStrategy, type AttractionOptions } from "./attraction/index.ts";
 export { sectionsRouter, type SectionsOptions } from "./sections.ts";

package/src/routers/plugs.ts

@@ -1,6 +1,6 @@
 import { inflectionCurve } from "../curves.ts";
 import { center } from "../geom.ts";
-import { nodeIndex, resolvePorts, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { nodeIndex, outerGraph, type Graph, type Result, type Route, type Router } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 
 /**
@@ -10,7 +10,7 @@ import { placePlug } from "../plugs.ts";
 export const plugsRouter: Router = {
   name: "plugs",
   route(input: Graph): Result {
-    const graph = resolvePorts(input);
+    const graph = outerGraph(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/sections.ts

@@ -2,7 +2,7 @@ import { BACKTRACK_MIN, goesOutAndBack } from "../bench/links.ts";
 import { center, dist, pointSegmentDistance, polylineLength, type Point } from "../geom.ts";
 import { LEVEL_LINK_DEFAULTS, type LevelLinkOptions } from "../levels.ts";
 import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
-import { nodeIndex, resolvePorts, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, outerGraph, type Graph, type Level, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 import { allSections, buildSections, checkSections, SECTION_DEFAULTS, type Section, type SectionOptions } from "../sections.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
@@ -92,7 +92,7 @@ export function sectionsRouter(options: SectionsOptions): Router {
   const router: Router = {
     name: options.name,
     route(input: Graph): Result {
-      const graph = resolvePorts(input);
+      const graph = outerGraph(input);
       const stretch = options.stretch ?? SECTIONS_DEFAULTS.stretch;
       const stretchPad = options.stretchPad ?? SECTIONS_DEFAULTS.stretchPad;
       const hubSlack = options.hubSlack ?? SECTIONS_DEFAULTS.hubSlack;

package/src/routers/shared.ts

@@ -1,5 +1,5 @@
 import { center, dist, type Point } from "../geom.ts";
-import { nodeIndex, resolvePorts, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, outerGraph, type Edge, type Graph, type GroupRule, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { channelWidth } from "../channels.ts";
 import { orderRun } from "../lane-order.ts";
 import { stretchLaneOrders, type LaneStretchOrder } from "../lane-orders/stretch/index.ts";
@@ -149,7 +149,7 @@ export function sharedRouter(options: SharedOptions, negotiation?: SharedNegotia
   const router: Router = {
     name: options.name,
     route(input: Graph): Result {
-      const graph = resolvePorts(input);
+      const graph = outerGraph(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const corners = ways.corners;

package/src/routers/straight.ts

@@ -1,5 +1,5 @@
 import { center, type Box, type Point } from "../geom.ts";
-import { fixedPortPoint, nodeIndex, resolvePorts, type Graph, type Result, type Route, type Router } from "../model.ts";
+import { fixedPortPoint, nodeIndex, outerGraph, type Graph, type Result, type Route, type Router } from "../model.ts";
 
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
 export function boxExit(box: Box, toward: Point): Point {
@@ -20,7 +20,7 @@ export function boxExit(box: Box, toward: Point): Point {
 export const straightRouter: Router = {
   name: "straight",
   route(input: Graph): Result {
-    const graph = resolvePorts(input);
+    const graph = outerGraph(input);
     const byId = nodeIndex(graph);
     const routes: Route[] = [];
     for (const e of graph.edges) {

package/src/routers/trunks.ts

@@ -1,5 +1,5 @@
 import { center, dist, type Point } from "../geom.ts";
-import { nodeIndex, resolvePorts, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
+import { nodeIndex, outerGraph, type Bundle, type Edge, type Graph, type GroupRule, type Node, type Result, type Route, type Router, type SharedRun } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
@@ -210,7 +210,7 @@ export function trunksRouter(options: TrunksOptions): Router {
   const router: Router = {
     name: options.name,
     route(input: Graph): Result {
-      const graph = resolvePorts(input);
+      const graph = outerGraph(input);
       const byId = nodeIndex(graph);
       const ways = new WayFinder(graph.nodes, options);
       const points = new Map<string, readonly Point[]>();

package/src/strategies/builtins.ts

@@ -74,6 +74,9 @@ import { ZIPPER_DEFAULTS, zipperPlan, type ZipperOptions } from "../highways/zip
 import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
 import type { Graph, Result, Router } from "../model.ts";
 import { facingEnds } from "../plugs/facing/index.ts";
+import { justifyEnds, type JustifyOptions } from "../plugs/justify.ts";
+import { sideEnds, type SidePlugOptions } from "../plugs/side.ts";
+import { SPREAD_DEFAULTS, spreadEnds, type SpreadOptions } from "../plugs/spread/index.ts";
 import { roomDemand, type RoomMethod, type RoomOptions } from "../room/index.ts";
 import { levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
 import { cornersRouter, type CornersOptions } from "../routers/corners.ts";
@@ -87,7 +90,7 @@ import { runPipeline, type PipelineOptions } from "../whole/pipeline/index.ts";
 import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type LaneBoard, type Registry, type Strategy } from "./model.ts";
 import type { OptionSchema } from "./options.ts";
 import { AREA_SCHEMA, CONFLUENT_SCHEMA, CROSSBAR_SCHEMA, FRECHET_SCHEMA, MLSEB_SCHEMA, POWER_SCHEMA, SBEB_SCHEMA } from "./schemas.ts";
-import { DEPTHS_SCHEMA, PIPELINE_SCHEMA } from "./schemas.ts";
+import { DEPTHS_SCHEMA, JUSTIFY_SCHEMA, PIPELINE_SCHEMA, SIDE_PLUG_SCHEMA, SPREAD_SCHEMA } from "./schemas.ts";
 import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_ALL_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA, STEINER_SCHEMA, GAP_SCHEMA, STREET_SCHEMA, SEARCH_SCHEMA, INTERCHANGE_SCHEMA } from "./schemas.ts";
 
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
@@ -957,6 +960,9 @@ export const highwayStrategies: {
 /** The built-in plug rules: the strategies of the step `plugs`. The router `corners` routes between their plugs with its option `plug`. */
 export const plugStrategies: {
   readonly facing: Strategy<"plugs", object>;
+  readonly side: Strategy<"plugs", SidePlugOptions>;
+  readonly justify: Strategy<"plugs", JustifyOptions>;
+  readonly spread: Strategy<"plugs", SpreadOptions>;
 } = Object.freeze({
   facing: defineStrategy({
     step: "plugs",
@@ -966,6 +972,30 @@ export const plugStrategies: {
     schema: {},
     run: (input) => facingEnds(input),
   }),
+  side: defineStrategy<"plugs", SidePlugOptions>({
+    step: "plugs",
+    name: "side",
+    describe: "WILD-001. The search of a route starts from the whole free side, and the plug goes where the way leaves the side. It is `corners` with `plugs: side`.",
+    defaults: { bend: 1, inset: 6, most: 16 },
+    schema: SIDE_PLUG_SCHEMA,
+    run: (input, o) => sideEnds(input, o),
+  }),
+  justify: defineStrategy<"plugs", JustifyOptions>({
+    step: "plugs",
+    name: "justify",
+    describe: "WILD-002. The plugs of `facing`, then the free plugs of each side keep their order and a minimum gap. They move the least distance.",
+    defaults: { plugGap: 8 },
+    schema: JUSTIFY_SCHEMA,
+    run: (input, o) => justifyEnds(input, o),
+  }),
+  spread: defineStrategy<"plugs", SpreadOptions>({
+    step: "plugs",
+    name: "spread",
+    describe: "PLUG-SPREAD. The free plugs of each wall share its room with a minimum gap, in the order of their far ends. On a short wall the gap shrinks, and no plug drops.",
+    defaults: { ...SPREAD_DEFAULTS },
+    schema: SPREAD_SCHEMA,
+    run: (input, o) => spreadEnds(input, o),
+  }),
 });
 
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */