components/system-map/system-map-inside.ts

Functions

Imports

It imports components/system-map/system-map-data.ts, components/system-map/system-map-html.ts. Imported by components/system-map/system-map-circles-search.ts, components/system-map/system-map-circles.ts, components/system-map/system-map-html.ts, components/system-map/system-map.ts.

Source

1// The system map's inside view: the core's parts placed in its boundary and the lines routed between them (system-map.ts).
2
3import { BOX_W, EXTERNAL, type Layout, type MapContainer, type MapFlow, type MapLink, type MapSystem, STORE_KINDS, type SystemMapData, layoutMap } from "./system-map-data.ts";
4import type { Box } from "./system-map-html.ts";
5
6// ---------------------------------------------------------------------------------------
7// Inside the core. The core's parts sit inside a dashed circle, the capsid's own outline and
8// C4's system boundary, as large as the stage allows, its name at its foot; what the core
9// works with outside it (`external` parts: the agents that call it, the host its code lives
10// on) sits in the stage's corners outside the circle, above it and, when there are more than
11// two, below it (Dustin, 2026-10-13: the circle, made bigger). The seat's rulings on
12// capsomer#64 decide how lines run between them:
13//
14//   - no line runs under a box it does not end at, or under the boundary's name: a line under
15//     a box reads as a connection to it (an edge tunnel; Dunne and Shneiderman 2009);
16//   - every line keeps ROUTE_CLEAR from every box but its two ends;
17//   - lines that share a box leave it at their own points along its edge (ports), and two
18//     lines running nearly parallel keep LINE_SEP apart, so neither reads as one doubled line;
19//   - a line never crosses another near that line's ends, nor anywhere along a short one,
20//     where a crossing reads as a three-way junction;
21//   - no bend sits near another line, where it would read as a connection.
22//
23// Lines are routed one at a time, shortest first, each the shortest way from port to port
24// through the corners of what is in its way (boxes, the name, the junctions of the lines
25// already drawn) that keeps every rule. A core has a dozen parts and a dozen lines, so a
26// plain search does it: no layout engine.
27
28export const BOX_H = 32;
29export const ROUTE_CLEAR = 8;
30// In drawing units; a 320 px phone draws a unit at about three quarters of a pixel, so each
31// is chosen to stay clear there: ROUTE_CLEAR over 5 px, the rest 8 to 10 px or more.
32export const LINE_SEP = 11;
33export const JUNCTION_END = 14;
34export const SHORT_LINK = 90;
35export const BEND_CLEAR = 14;
36const LABEL_PAD = 4;
37// The stage is the shell's drawing; inside, the drawing is at least this wide, so a small
38// family's map is scaled down rather than crowded.
39const MIN_INSIDE_W = 380;
40const MARGIN = 8;
41const OUT_GAP = 30;
42const PAD = 16;
43const LABEL_H = 18;
44// The name's baseline sits this far above the circle's foot.
45const LABEL_FOOT = 16;
46// Every part outside keeps this far from the circle.
47const OUT_CLEAR = 2 * ROUTE_CLEAR;
48const MIN_PITCH = BOX_H + 2 * ROUTE_CLEAR + 12;
49const MAX_PITCH = 104;
50const ROOMY_PITCH = 80;
51const COL_GAP = 2 * ROUTE_CLEAR + 12;
52
53type Pt = [number, number];
54
55export interface Rect {
56  x: number;
57  y: number;
58  w: number;
59  h: number;
60}
61
62export interface InsideWire {
63  from: string;
64  to: string;
65  route: Pt[];
66}
67
68export interface Circle {
69  cx: number;
70  cy: number;
71  r: number;
72}
73
74export interface InsideScene {
75  viewBox: [number, number, number, number];
76  boundary: Circle;
77  // The boundary's name: its text starts at (textX, textY), and `box` is what lines avoid.
78  label: { text: string; textX: number; textY: number; box: Rect; squeeze: number | null };
79  boxes: Box[];
80  wires: InsideWire[];
81}
82
83const rectOf = (b: Box): Rect => ({ x: b.x - b.w / 2, y: b.y - BOX_H / 2, w: b.w, h: BOX_H });
84const rectCorners = (r: Rect): Pt[] => [[r.x, r.y], [r.x + r.w, r.y], [r.x, r.y + r.h], [r.x + r.w, r.y + r.h]];
85
86/** How far a rectangle sits inside a circle: the circle's radius less its farthest corner's
87 *  distance from the centre (below 0, a corner is outside). */
88export function rectInset(r: Rect, c: Circle): number {
89  return c.r - Math.max(...rectCorners(r).map(([x, y]) => Math.hypot(x - c.cx, y - c.cy)));
90}
91
92/** How far a rectangle sits outside a circle: its nearest point's distance from the centre
93 *  less the radius (below 0, it reaches inside). */
94export function rectOutset(r: Rect, c: Circle): number {
95  return Math.hypot(Math.max(r.x - c.cx, 0, c.cx - r.x - r.w), Math.max(r.y - c.cy, 0, c.cy - r.y - r.h)) - c.r;
96}
97const grow = (r: Rect, g: number): Rect => ({ x: r.x - g, y: r.y - g, w: r.w + 2 * g, h: r.h + 2 * g });
98
99/** Whether the segment p-q passes through the rectangle's inside (a touch is not a hit). */
100export function segmentHitsRect(p: Pt, q: Pt, r: Rect): boolean {
101  return hitsRect(p[0], p[1], q[0], q[1], r);
102}
103
104/** The same from four numbers, for a search's hot path (system-map-circles-search.ts). */
105export function hitsRect(px: number, py: number, qx: number, qy: number, r: Rect): boolean {
106  let t0 = 0;
107  let t1 = 1;
108  const dx = qx - px;
109  const dy = qy - py;
110  for (const [pk, qk] of [[-dx, px - r.x], [dx, r.x + r.w - px], [-dy, py - r.y], [dy, r.y + r.h - py]] as const) {
111    if (pk === 0) {
112      if (qk <= 0) return false;
113      continue;
114    }
115    const t = qk / pk;
116    if (pk < 0) t0 = Math.max(t0, t);
117    else t1 = Math.min(t1, t);
118    if (t0 >= t1) return false;
119  }
120  return t1 - t0 > 1e-9;
121}
122
123/** Whether the segment p-q passes through the box's inside, grown by `g`. */
124export function segmentHitsBox(p: Pt, q: Pt, b: { x: number; y: number; w: number }, g = 0): boolean {
125  return segmentHitsRect(p, q, { x: b.x - b.w / 2 - g, y: b.y - BOX_H / 2 - g, w: b.w + 2 * g, h: BOX_H + 2 * g });
126}
127
128const sub = (a: Pt, b: Pt): Pt => [a[0] - b[0], a[1] - b[1]];
129const len = (v: Pt) => Math.hypot(v[0], v[1]);
130
131/** The distance from point p to segment a-b. */
132export function pointSegDist(p: Pt, a: Pt, b: Pt): number {
133  const ab = sub(b, a);
134  const l2 = ab[0] ** 2 + ab[1] ** 2;
135  const t = l2 ? Math.max(0, Math.min(1, ((p[0] - a[0]) * ab[0] + (p[1] - a[1]) * ab[1]) / l2)) : 0;
136  return len(sub(p, [a[0] + t * ab[0], a[1] + t * ab[1]]));
137}
138
139/** Where segments a-b and c-d cross, or null. */
140export function segmentCross(a: Pt, b: Pt, c: Pt, d: Pt): Pt | null {
141  const r = sub(b, a);
142  const s = sub(d, c);
143  const den = r[0] * s[1] - r[1] * s[0];
144  if (Math.abs(den) < 1e-9) return null;
145  const t = ((c[0] - a[0]) * s[1] - (c[1] - a[1]) * s[0]) / den;
146  const u = ((c[0] - a[0]) * r[1] - (c[1] - a[1]) * r[0]) / den;
147  return t > 0 && t < 1 && u > 0 && u < 1 ? [a[0] + t * r[0], a[1] + t * r[1]] : null;
148}
149
150/** The distance between two segments: 0 where they cross. */
151export function segDist(a: Pt, b: Pt, c: Pt, d: Pt): number {
152  if (segmentCross(a, b, c, d)) return 0;
153  return Math.min(pointSegDist(a, c, d), pointSegDist(b, c, d), pointSegDist(c, a, b), pointSegDist(d, a, b));
154}
155
156/** The angle between two segments' directions, 0 to 90 degrees. */
157export function segAngle(a: Pt, b: Pt, c: Pt, d: Pt): number {
158  const u = sub(b, a);
159  const v = sub(d, c);
160  const cos = Math.abs(u[0] * v[0] + u[1] * v[1]) / (len(u) * len(v) || 1);
161  return (Math.acos(Math.min(1, cos)) * 180) / Math.PI;
162}
163
164/** Whether two segments run side by side: nearly parallel, and one's span overlaps the other's. */
165export function sideBySide(a: Pt, b: Pt, c: Pt, d: Pt): boolean {
166  if (segAngle(a, b, c, d) >= 20) return false;
167  const u = sub(b, a);
168  const l = len(u) || 1;
169  const along = (p: Pt) => ((p[0] - a[0]) * u[0] + (p[1] - a[1]) * u[1]) / l;
170  const [lo, hi] = [Math.min(along(c), along(d)), Math.max(along(c), along(d))];
171  return hi > 0 && lo < l;
172}
173
174const segmentsOf = (route: readonly Pt[]): Array<[Pt, Pt]> => route.slice(1).map((q, i) => [route[i]!, q]);
175
176/** What a route must keep, against the lines drawn before it. */
177interface Drawn {
178  segments: Array<[Pt, Pt]>;
179  ends: [Pt, Pt];
180  short: boolean;
181  bends: Pt[];
182}
183
184function routeLength(route: readonly Pt[]): number {
185  return segmentsOf(route).reduce((n, [p, q]) => n + len(sub(q, p)), 0);
186}
187
188function drawnOf(route: Pt[]): Drawn {
189  return { segments: segmentsOf(route), ends: [route[0]!, route.at(-1)!], short: routeLength(route) < SHORT_LINK, bends: route.slice(1, -1) };
190}
191
192/** Which rules a segment breaks: a box or the boundary's name, which no line may cross, and the
193 *  softer rules a crowded core may leave no way to keep. `own` is the new line's two ports. */
194export function segmentFaults(p: Pt, q: Pt, ends: readonly Box[], boxes: readonly Box[], label: Rect | null, drawn: readonly Drawn[], own: readonly Pt[] = []): string[] {
195  const out: string[] = [];
196  for (const o of boxes) {
197    if (ends.includes(o) ? segmentHitsBox(p, q, o, 0) : segmentHitsBox(p, q, o, ROUTE_CLEAR)) out.push(`box ${o.c.id}`);
198  }
199  if (label && segmentHitsRect(p, q, grow(label, LABEL_PAD))) out.push("label");
200  for (const d of drawn) {
201    for (const [c, e] of d.segments) {
202      const x = segmentCross(p, q, c, e);
203      if (x && (d.short || [...d.ends, ...own].some((end) => len(sub(x, end)) < JUNCTION_END))) out.push("junction");
204      if (!x && (sideBySide(p, q, c, e) || sideBySide(c, e, p, q)) && segDist(p, q, c, e) < LINE_SEP) out.push("side by side");
205    }
206    if (d.bends.some((b) => pointSegDist(b, p, q) < BEND_CLEAR)) out.push("near a bend");
207  }
208  return out;
209}
210
211const HARD = /^(box|label)/;
212// What a broken soft rule costs a route, in drawing units: far more than any detour, so a
213// route breaks one only when every way around breaks one too, and then as few as it can.
214const SOFT_COST = 2000;
215
216/** The shortest way from port to port that crosses no box and no name, breaking the fewest
217 *  softer rules, or null when every way crosses a box. */
218function searchRoute(start: Pt, end: Pt, ends: readonly Box[], boxes: readonly Box[], label: Rect | null, drawn: readonly Drawn[], within: (p: Pt) => boolean): Pt[] | null {
219  const own = [start, end];
220  const cost = (p: Pt, q: Pt) => {
221    const f = segmentFaults(p, q, ends, boxes, label, drawn, own);
222    return f.some((x) => HARD.test(x)) ? Number.POSITIVE_INFINITY : len(sub(q, p)) + SOFT_COST * f.length;
223  };
224  const direct = cost(start, end);
225  if (direct < SOFT_COST) return [start, end];
226  // Corners just outside what is in the way, and a second ring further out, so a bend can
227  // stand clear of the lines that pass the same corner.
228  const solid: Rect[] = [...boxes.map((o) => rectOf(o)), ...(label ? [grow(label, LABEL_PAD - ROUTE_CLEAR)] : [])];
229  const junctions: Rect[] = drawn.flatMap((d) =>
230    d.ends.map(([x, y]) => ({ x: x - JUNCTION_END, y: y - JUNCTION_END, w: 2 * JUNCTION_END, h: 2 * JUNCTION_END })),
231  );
232  const corners: Pt[] = [
233    ...[ROUTE_CLEAR + 2, ROUTE_CLEAR + 2 + BEND_CLEAR].flatMap((g) => solid.map((r) => grow(r, g))),
234    ...junctions.map((r) => grow(r, 2)),
235  ]
236    .flatMap(rectCorners)
237    .filter(([x, y]) => within([x, y]) && boxes.every((o) => !(Math.abs(x - o.x) < o.w / 2 + ROUTE_CLEAR && Math.abs(y - o.y) < BOX_H / 2 + ROUTE_CLEAR)));
238  const nodes: Pt[] = [start, end, ...corners];
239  // A bend near a line already drawn reads as a connection to it.
240  const nodeCost = nodes.map((pt, k) => (k > 1 && drawn.some((d) => d.segments.some(([c, e]) => pointSegDist(pt, c, e) < BEND_CLEAR)) ? SOFT_COST : 0));
241  const dist = nodes.map(() => Number.POSITIVE_INFINITY);
242  const prev = nodes.map(() => -1);
243  const done = nodes.map(() => false);
244  dist[0] = 0;
245  // A*: the straight distance to the end never overstates what is left.
246  const toEnd = nodes.map((pt) => len(sub(end, pt)));
247  for (;;) {
248    let i = -1;
249    for (let k = 0; k < nodes.length; k++) if (!done[k] && (i < 0 || dist[k]! + toEnd[k]! < dist[i]! + toEnd[i]!)) i = k;
250    if (i < 0 || dist[i] === Number.POSITIVE_INFINITY || i === 1) break;
251    done[i] = true;
252    for (let k = 1; k < nodes.length; k++) {
253      if (done[k]) continue;
254      // Each bend costs a little, so of two near-equal ways the plainer wins.
255      const lower = dist[i]! + len(sub(nodes[k]!, nodes[i]!)) + 10 + nodeCost[k]!;
256      if (lower >= dist[k]!) continue;
257      const dd = dist[i]! + cost(nodes[i]!, nodes[k]!) + 10 + nodeCost[k]!;
258      if (dd < dist[k]!) {
259        dist[k] = dd;
260        prev[k] = i;
261      }
262    }
263  }
264  if (prev[1] === -1) return direct < Number.POSITIVE_INFINITY ? [start, end] : null;
265  const path: Pt[] = [];
266  for (let k = 1; k !== -1; k = prev[k]!) path.unshift(nodes[k]!);
267  return path;
268}
269
270/** Each line's two ports: where it leaves each of its boxes, on the side facing the other end,
271 *  the lines sharing a side spread evenly along it in the order of where each heads (its far
272 *  end, or `toward`, the first point it was routed to), so lines leaving a side do not cross. */
273export function portsOf(boxes: readonly Box[], pairs: ReadonlyArray<readonly [string, string]>, toward?: ReadonlyMap<string, Pt>): Map<string, Pt> {
274  const at = new Map(boxes.map((b) => [b.c.id, b]));
275  type Use = { key: string; side: "top" | "bottom" | "left" | "right"; along: number };
276  const uses = new Map<string, Use[]>();
277  for (const [a, b] of pairs) {
278    for (const [me, other] of [[a, b], [b, a]] as const) {
279      const m = at.get(me)!;
280      const o = at.get(other)!;
281      const dx = o.x - m.x;
282      const dy = o.y - m.y;
283      const vertical = Math.abs(dy) / (BOX_H / 2) >= Math.abs(dx) / (m.w / 2);
284      const side = vertical ? (dy < 0 ? "top" : "bottom") : dx < 0 ? "left" : "right";
285      const list = uses.get(`${me} ${side}`) ?? [];
286      const [hx, hy] = toward?.get(`${me}>${other}`) ?? [o.x, o.y];
287      list.push({ key: `${me}>${other}`, side, along: vertical ? hx : hy });
288      uses.set(`${me} ${side}`, list);
289    }
290  }
291  const out = new Map<string, Pt>();
292  for (const [k, list] of uses) {
293    const m = at.get(k.split(" ")[0]!)!;
294    list.sort((u, v) => u.along - v.along);
295    list.forEach((u, i) => {
296      const f = (i + 1) / (list.length + 1);
297      const p: Pt =
298        u.side === "top" || u.side === "bottom"
299          ? [m.x - m.w / 2 + m.w * f, m.y + (u.side === "top" ? -BOX_H / 2 : BOX_H / 2)]
300          : [m.x + (u.side === "left" ? -m.w / 2 : m.w / 2), m.y - BOX_H / 2 + BOX_H * f];
301      out.set(u.key, p);
302    });
303  }
304  return out;
305}
306
307/** The inside drawing's own size: the shell's, at least MIN_INSIDE_W wide and tall enough
308 *  for every row of parts, with the shell's proportions so it fills the same stage. */
309function insideViewBox(layout: Layout, containers: readonly MapContainer[]): [number, number, number, number] {
310  const [, , vw, vh] = layout.viewBox;
311  const ext = containers.filter((c) => c.kind === EXTERNAL).length;
312  const bands = (ext > 0 ? 1 : 0) + (ext > 2 ? 1 : 0);
313  const rowsFor = (w: number) => {
314    const innerW = w - 2 * MARGIN - 2 * PAD;
315    const perRow = (bw: number, max: number) => Math.max(1, Math.min(max, Math.floor((innerW + COL_GAP) / (bw + COL_GAP))));
316    const tops = containers.filter((c) => c.kind !== EXTERNAL && !STORE_KINDS.has(c.kind)).length;
317    const stores = containers.filter((c) => STORE_KINDS.has(c.kind)).length;
318    return Math.ceil(tops / perRow(BOX_W, 2)) + Math.ceil(stores / perRow(88, 3));
319  };
320  let scale = Math.max(1, MIN_INSIDE_W / vw);
321  for (let k = 0; k < 20; k++) {
322    const h = vh * scale;
323    const rows = rowsFor(vw * scale);
324    const need = 2 * MARGIN + bands * (BOX_H + OUT_GAP) + 2 * PAD + LABEL_H + Math.max(0, rows - 1) * MIN_PITCH + BOX_H;
325    if (need <= h) break;
326    scale *= need / h;
327  }
328  const w = Math.round(vw * scale * 10) / 10;
329  const h = Math.round(vh * scale * 10) / 10;
330  return [-w / 2, -h / 2, w, h];
331}
332
333/** The core's parts in rows inside the circle: rows of two (workers, sites, crons) above rows
334 *  of three (stores), the rows as far apart as fits (at most MAX_PITCH), each spread along its
335 *  chord, every box at least PAD inside the circle and the name's band left clear at its
336 *  foot. Null when they do not fit, so the drawing is made larger. */
337function placeInside(containers: readonly MapContainer[], c: Circle, minPitch: number): Box[] | null {
338  const tops = containers.filter((k) => k.kind !== EXTERNAL && !STORE_KINDS.has(k.kind));
339  const stores = containers.filter((k) => STORE_KINDS.has(k.kind));
340  const R = c.r - PAD;
341  // Two to a row above three; a drawing too small for that is made larger rather than stacked.
342  {
343    const [maxTop, maxStore] = [2, 3];
344    const rows: Array<{ items: MapContainer[]; w: number }> = [];
345    for (const [list, bw, max] of [[tops, BOX_W, maxTop], [stores, 88, maxStore]] as const) {
346      for (let i = 0; i < list.length; i += max) rows.push({ items: list.slice(i, i + max), w: bw });
347    }
348    if (rows.length === 0) return [];
349    // Half a box's width from the centre of each slot to its edge; the slots sit COL_GAP apart.
350    const fits = (pitch: number): Box[] | null => {
351      const mid = c.cy - LABEL_H / 2;
352      const out: Box[] = [];
353      for (const [r, row] of rows.entries()) {
354        const y = mid + (r - (rows.length - 1) / 2) * pitch;
355        const far = Math.abs(y - c.cy) + BOX_H / 2;
356        if (far >= R || y + BOX_H / 2 > c.cy + c.r - PAD - LABEL_H) return null;
357        const half = Math.sqrt(R * R - far * far);
358        const n = row.items.length;
359        const step = n > 1 ? Math.min((2 * half - row.w) / (n - 1), (2 * R) / n) : 0;
360        if (n > 1 && step < row.w + COL_GAP) return null;
361        if (n === 1 && row.w / 2 > half) return null;
362        row.items.forEach((k, i) => out.push({ c: k, x: Math.round((c.cx + (i - (n - 1) / 2) * step) * 10) / 10, y: Math.round(y * 10) / 10, w: row.w }));
363      }
364      return out;
365    };
366    for (let pitch = rows.length > 1 ? MAX_PITCH : 0; pitch >= (rows.length > 1 ? minPitch : 0); pitch -= 2) {
367      const placed = fits(pitch);
368      if (placed) return placed;
369      if (rows.length === 1) break;
370    }
371  }
372  return null;
373}
374
375/** Everything drawn inside the core: the circle and its name, the parts in and out of it,
376 *  and every line between them, routed by the rules above. */
377export function insideScene(containers: readonly MapContainer[], links: readonly MapLink[], layout: Layout, name = "Inside"): InsideScene {
378  const externals = containers.filter((c) => c.kind === EXTERNAL).slice(0, 4);
379  // The drawing grows until its parts fit inside the circle.
380  let [vx, vy, vw, vh] = insideViewBox(layout, containers);
381  let boundary: Circle = { cx: 0, cy: 0, r: 0 };
382  let outside: Box[] = [];
383  let inside: Box[] | null = null;
384  for (let k = 0; k < 40; k++) {
385    const xl = vx + MARGIN + BOX_W / 2;
386    const xr = vx + vw - MARGIN - BOX_W / 2;
387    outside = externals.map((c, i) => ({ c, x: i % 2 === 0 ? xl : xr, y: i < 2 ? vy + MARGIN + BOX_H / 2 : vy + vh - MARGIN - BOX_H / 2, w: BOX_W }));
388    // The circle is centred between the bands the parts outside sit in, and as large as the
389    // drawing allows: within its margins, and OUT_CLEAR from every part outside, which sit in
390    // the corners it leaves.
391    const top = externals.length ? vy + MARGIN + BOX_H + OUT_GAP : vy + MARGIN;
392    const bottom = externals.length > 2 ? vy + vh - MARGIN - BOX_H - OUT_GAP : vy + vh - MARGIN;
393    const cx = vx + vw / 2;
394    const cy = (top + bottom) / 2;
395    const r = Math.min(vw / 2 - MARGIN, cy - vy - MARGIN, vy + vh - MARGIN - cy, ...outside.map((o) => rectOutset(rectOf(o), { cx, cy, r: 0 }) - OUT_CLEAR));
396    boundary = { cx, cy, r: Math.floor(r * 10) / 10 };
397    // Rows at least ROOMY_PITCH apart leave the lines room to keep their rules; a drawing
398    // grown a third larger still short of that takes the rows as close as MIN_PITCH.
399    inside = placeInside(containers, boundary, ROOMY_PITCH) ?? (k >= 4 ? placeInside(containers, boundary, MIN_PITCH) : null);
400    if (inside) break;
401    [vx, vy, vw, vh] = [vx * 1.08, vy * 1.08, vw * 1.08, vh * 1.08];
402  }
403  if (!inside) inside = [];
404  const viewBox: [number, number, number, number] = [Math.round(vx * 10) / 10, Math.round(vy * 10) / 10, Math.round(vw * 10) / 10, Math.round(vh * 10) / 10];
405  // The name is 9-unit capitals in a monospace face, a little under 7 units a letter, centred
406  // at the circle's foot; a name too long for the chord there is squeezed to fit (textLength),
407  // so lines avoid all of it.
408  const textY = boundary.cy + boundary.r - LABEL_FOOT;
409  const chord = 2 * Math.sqrt(Math.max(0, boundary.r ** 2 - (textY + 3 - boundary.cy) ** 2));
410  const maxLabel = Math.max(24, Math.floor(chord - 12));
411  const labelW = Math.min(Math.round(name.length * 7 + 6), maxLabel);
412  const label = {
413    text: name,
414    textX: boundary.cx,
415    textY,
416    box: { x: boundary.cx - labelW / 2, y: textY - 11, w: labelW, h: 14 },
417    squeeze: labelW === maxLabel ? labelW - 6 : null,
418  };
419  const boxes = [...inside, ...outside];
420  const at = new Map(boxes.map((b) => [b.c.id, b]));
421  // One line for a pair, drawn the way the data first names it.
422  const pairs: Array<[string, string]> = [];
423  const seen = new Set<string>();
424  for (const l of links) {
425    if (!at.has(l.from) || !at.has(l.to) || l.from === l.to) continue;
426    const key = [l.from, l.to].sort().join(" ");
427    if (seen.has(key)) continue;
428    seen.add(key);
429    pairs.push([l.from, l.to]);
430  }
431  const inView = ([x, y]: Pt) => x >= vx && x <= vx + vw && y >= vy && y <= vy + vh;
432  const inCircle = ([x, y]: Pt) => Math.hypot(x - boundary.cx, y - boundary.cy) <= boundary.r - 4;
433  // Every line, shortest first, each against the lines before it; with how many soft rules
434  // the drawing breaks in all.
435  const routeAll = (ports: Map<string, Pt>) => {
436    const portOf = (p: readonly [string, string]) => len(sub(ports.get(`${p[0]}>${p[1]}`)!, ports.get(`${p[1]}>${p[0]}`)!));
437    const order = [...pairs].sort((p, q) => portOf(p) - portOf(q));
438    const drawn: Drawn[] = [];
439    const routes = new Map<string, Pt[]>();
440    let broken = 0;
441    for (const [a, b] of order) {
442      const start = ports.get(`${a}>${b}`)!;
443      const end = ports.get(`${b}>${a}`)!;
444      const ends = [at.get(a)!, at.get(b)!];
445      // A line between two parts inside stays inside the circle; one to a part outside may
446      // use the whole drawing. A box or the name is never given up; if every way crosses one
447      // (a core too crowded to draw), the line goes straight and the tests say so.
448      const within = ends.every((e) => e.c.kind !== EXTERNAL) ? inCircle : inView;
449      const route = searchRoute(start, end, ends, boxes, label.box, drawn, within) ?? [start, end];
450      broken += segmentsOf(route).reduce((n, [p, q]) => n + segmentFaults(p, q, ends, boxes, label.box, drawn, [start, end]).length, 0);
451      drawn.push(drawnOf(route));
452      routes.set(`${a} ${b}`, route);
453    }
454    return { routes, broken };
455  };
456  // Twice: the second time each box's ports are ordered by where its lines were first routed
457  // to, which undoes most crossings at the ports; the drawing breaking fewer rules is kept.
458  const first = routeAll(portsOf(boxes, pairs));
459  let best = first;
460  if (first.broken > 0) {
461    const toward = new Map<string, Pt>();
462    for (const [a, b] of pairs) {
463      const r = first.routes.get(`${a} ${b}`)!;
464      toward.set(`${a}>${b}`, r[1]!);
465      toward.set(`${b}>${a}`, r.at(-2)!);
466    }
467    const second = routeAll(portsOf(boxes, pairs, toward));
468    if (second.broken < first.broken) best = second;
469  }
470  const routes = best.routes;
471  return { viewBox, boundary, label, boxes, wires: pairs.map(([a, b]) => ({ from: a, to: b, route: routes.get(`${a} ${b}`)! })) };
472}
473
474/** The flows a map can play: those whose every step runs along a line between two of the
475 *  core's drawn parts, toward one of its ends, lighting only drawn parts. */
476export function playableFlows(data: SystemMapData, core: MapSystem | undefined, layout: Layout = layoutMap(data.systems)): MapFlow[] {
477  if (!core) return [];
478  const mine = (data.containers ?? []).filter((c) => c.system === core.id);
479  // What insideScene draws: every part inside, and the first four outside.
480  const parts = new Set([...mine.filter((c) => c.kind !== EXTERNAL), ...mine.filter((c) => c.kind === EXTERNAL).slice(0, 4)].map((c) => c.id));
481  const lines = new Set((data.relationships ?? []).filter((l) => parts.has(l.from) && parts.has(l.to)).map((l) => `${l.from} ${l.to}`));
482  return (data.flows ?? []).filter(
483    (f) =>
484      f.steps.length > 0 &&
485      f.steps.every((st) => st.from !== st.to && lines.has(`${st.from} ${st.to}`) && (st.toward === st.from || st.toward === st.to) && (st.lights ?? []).every((l) => parts.has(l))),
486  );
487}