@songsid/agend 2.3.0-beta.2 → 2.3.0-beta.21

package/dist/ui/fleet-org.js

@@ -11,6 +11,7 @@ import { t, register } from "/assets/app-i18n.js";
 import { chatPath } from "/assets/app-route.js";
 import { Empty, Skeleton } from "/assets/ui-states.js";
 import { Icon } from "/assets/ui-icons.js";
+import { modelText } from "/assets/instance-nav.js";
 
 register("org", {
   en: {
@@ -19,6 +20,7 @@ register("org", {
     missing: "Not in the fleet", thread_discord: "Discord thread", thread_telegram: "Telegram topic", openChat: "Open chat",
     classic: "ClassicBot room", empty: "No instances yet", emptyHint: "Instances and teams show here once the fleet has them.",
     noTeams: "No teams yet — define them in Fleet → Teams to group the chart.", newTab: "(opens in a new tab)",
+    sending: "Sending:", queuedNote: "(queued)", workingNote: "(in progress)",
   },
   "zh-TW": {
     title: "組織圖", general: "General", unteamed: "未加入 team", members: "{0} 名成員", member: "1 名成員", instances: "{0} 個 instance", instance: "1 個 instance",
@@ -26,6 +28,7 @@ register("org", {
     missing: "不在 fleet 中", thread_discord: "Discord 討論串", thread_telegram: "Telegram topic", openChat: "開啟聊天",
     classic: "ClassicBot 頻道", empty: "還沒有 instance", emptyHint: "fleet 有 instance 和 team 後會顯示在這裡。",
     noTeams: "還沒有 team——到 Fleet → Teams 定義後，組織圖會依 team 分組。", newTab: "（在新分頁開啟）",
+    sending: "傳送中：", queuedNote: "（排隊中）", workingNote: "（進行中）",
   },
 });
 const to = (k, ...v) => t(`org.${k}`, ...v);
@@ -83,15 +86,22 @@ export function buildOrgView(org, app) {
   return { top: general.map(node), teams, rest: { nodes: rest, counts: counts(rest) }, total: all.length, counts: counts(all) };
 }
 
-function Summary({ counts }) {
+/** The states in a group, most pressing first, with how many are in each (the canvas's bar shows it too). */
+export function OrgSummary({ counts }) {
   return html`<ul class="org-counts">${counts.map(([s, n]) => html`<li key=${s} class=${`org-count st-${s}`}>
     <span class=${`dot ${DOT[s]}`} aria-hidden="true"></span>${n} ${to(s)}</li>`)}</ul>`;
 }
 
-function Node({ n }) {
+/** #1918: what an instance is sending now, in words — the canvas's live traffic for the list (and a screen reader). */
+const KIND_WORD = { task: "delegate_task", report: "report_result", query: "request_information", update: "send_to_instance", send: "send_to_instance", broadcast: "broadcast" };
+function Sending({ list }) {
+  return html`<p class="org-sending"><span class="muted">${to("sending")}</span> ${list.map((s, i) => html`<span key=${s.key} class=${`org-send k-${s.kind}`}>${i ? ", " : ""}${KIND_WORD[s.kind] || s.kind} → ${s.to}${s.working ? ` ${to("workingNote")}` : s.queued ? ` ${to("queuedNote")}` : ""}</span>`)}</p>`;
+}
+
+function Node({ n, sending }) {
   const alias = n.i && typeof n.i.display_name === "string" && n.i.display_name.trim() && n.i.display_name.trim() !== n.name ? n.i.display_name.trim() : "";
   const thread = n.info.thread;
-  const model = n.i && n.i.model ? n.i.model : "";
+  const model = n.i && n.i.model ? modelText(n.i) : "";
   return html`<li class=${`org-node st-${n.state}`}>
     <div class="org-node-head">
       <span class=${`dot ${DOT[n.state]}`} aria-hidden="true"></span>
@@ -100,6 +110,7 @@ function Node({ n }) {
       <span class=${`org-state st-${n.state}`}>${to(n.state)}</span>
     </div>
     ${n.info.description ? html`<p class="org-desc" title=${n.info.description}>${n.info.description}</p>` : null}
+    ${sending && sending.length ? html`<${Sending} list=${sending} />` : null}
     ${n.i ? html`<div class="org-meta">${n.i.backend ? html`<span class="org-chip">${n.i.backend}</span>` : null}
       ${model ? html`<span class="org-model mono" title=${model}>${model}</span>` : null}
       ${n.info.classic ? html`<span class="org-chip">${to("classic")}</span>` : null}</div>` : null}
@@ -111,32 +122,36 @@ function Node({ n }) {
   </li>`;
 }
 
-function Team({ id, name, description, nodes, counts, icon }) {
+function Team({ id, name, description, nodes, counts, icon, sending }) {
   return html`<section class="org-team" aria-labelledby=${id}>
     <header class="org-team-head">
       <h3 id=${id}><${Icon} name=${icon} size=${16} /><span>${name}</span></h3>
       ${description ? html`<p class="org-team-desc">${description}</p>` : null}
-      <div class="org-team-sub"><span class="muted">${count("member", "members", nodes.length)}</span><${Summary} counts=${counts} /></div>
+      <div class="org-team-sub"><span class="muted">${count("member", "members", nodes.length)}</span><${OrgSummary} counts=${counts} /></div>
     </header>
-    <ul class="org-nodes">${nodes.map((n) => html`<${Node} key=${n.name} n=${n} />`)}</ul>
+    <ul class="org-nodes">${nodes.map((n) => html`<${Node} key=${n.name} n=${n} sending=${sending && sending.get(n.name)} />`)}</ul>
   </section>`;
 }
 
-/** The tab's body. `org`: what /ui/org answered (the Fleet panel's loader); `app`: the app store. */
-export function OrgChart({ org, app }) {
+/**
+ * The chart as a list. `org`: what /ui/org answered (the Fleet panel's loader); `app`: the app store. #1918: `bare` when
+ * the canvas's bar (fleet-canvas.js) already shows the count and the states; `sending` what each instance is sending
+ * now (name → list), null when Live is off.
+ */
+export function OrgChart({ org, app, bare = false, sending = null }) {
   if (!app.ready) return html`<${Skeleton} lines=${4} />`;
   const view = buildOrgView(org, app);
   if (!view.total) return html`<${Empty} icon="team" title=${to("empty")} hint=${to("emptyHint")} />`;
   return html`<div class="org">
-    <div class="list-head org-head"><span>${count("instance", "instances", view.total)}</span><${Summary} counts=${view.counts} /></div>
+    ${bare ? null : html`<div class="list-head org-head"><span>${count("instance", "instances", view.total)}</span><${OrgSummary} counts=${view.counts} /></div>`}
     ${view.top.length ? html`<section class="org-top" aria-labelledby="org-general">
       <h3 id="org-general" class="sr-only">${to("general")}</h3>
-      <ul class="org-nodes">${view.top.map((n) => html`<${Node} key=${n.name} n=${n} />`)}</ul>
+      <ul class="org-nodes">${view.top.map((n) => html`<${Node} key=${n.name} n=${n} sending=${sending && sending.get(n.name)} />`)}</ul>
     </section>` : null}
     ${view.teams.length ? null : html`<p class="note org-note">${to("noTeams")}</p>`}
     <div class="org-teams">
-      ${view.teams.map((team, k) => html`<${Team} key=${team.name} id=${`org-team-${k}`} icon="team" ...${team} />`)}
-      ${view.rest.nodes.length ? html`<${Team} id="org-rest" icon="fleet" name=${to("unteamed")} description="" ...${view.rest} />` : null}
+      ${view.teams.map((team, k) => html`<${Team} key=${team.name} id=${`org-team-${k}`} icon="team" sending=${sending} ...${team} />`)}
+      ${view.rest.nodes.length ? html`<${Team} id="org-rest" icon="fleet" name=${to("unteamed")} description="" sending=${sending} ...${view.rest} />` : null}
     </div>
   </div>`;
 }

package/dist/ui/fleet-route-scene.js

@@ -0,0 +1,207 @@
+// #2182: the org canvas's traffic lines routed around the canvas, not along fixed lanes. libavoid (Adaptagrams, through
+// libavoid-js 0.4.5, LGPL-2.1-or-later, an npm dependency served unmodified from /ui/vendor/) routes each line between
+// fixed obstacles; this module says what the obstacles are (pure: the worker, the page and the tests share it).
+//
+// - Obstacles: every card (General's and the members'), a folded team's box, each open box's header band (its name and
+//   count are drawn over the lines) and its border as wall pieces in front of its cards. The gaps between the pieces —
+//   the box's padding and the gutters between its rows and columns (L.pad, L.gap: wide enough for a few lines each)
+//   — are the only doors, so a line crosses a border at right angles, through a door, and never runs along it.
+// - Ends: pins on each card's sides (several on the long sides, one on the short), facing out; a line ends on a card,
+//   never on a box. A card with more lines than pins gets more, so two lines never start at one point.
+// - Separation: libavoid nudges lines that share a run ROUTE.NUDGE apart; the same two ends and kind are one line (×N)
+//   before they get here (fleet-traffic.js).
+// A route that comes back otherwise (not orthogonal, not ending on its two shapes) is not drawn: that line keeps the
+// lane route (fleet-traffic.js route()).
+import { OC } from "./fleet-canvas-layout.js";
+
+/** Buffer around every obstacle, the distance nudging keeps between lines, the cost of a bend, pins on a long side. */
+export const ROUTE = { BUF: 5, NUDGE: 8, SEG: 60, PINS: 4, MAX_PINS: 64, MAX_POINTS: 64, MAX_SHAPES: 600, MAX_CONNS: 120 };
+/** libavoid's ConnDirFlags: the way a line leaves a pin. */
+const UP = 1, DOWN = 2, LEFT = 4, RIGHT = 8;
+const PINS_PER_CARD = ROUTE.PINS * 2 + 2;
+
+/** The shape a line's end is on: a card (General's or a member's) or a folded team's box. Null: not routed here. */
+function endShape(end) {
+  if (!end) return null;
+  if (end.kind === "top" || end.kind === "cell") return { key: end.key, x: end.c.x, y: end.c.y, w: end.c.w, h: end.c.h };
+  if (end.kind === "box" && end.b.folded) return { key: end.key, x: end.b.x, y: end.b.y, w: end.b.w, h: end.b.h };
+  return null;
+}
+
+/**
+ * The scene for layout `L` and the lines `lines` ([{ key, a, z }], a and z ends as fleet-traffic.js endOf gives them):
+ * { shapes: [{ x, y, w, h, pins }], conns: [{ key, a, z }], boxes: [{ x, y, w, h }] } — `pins` 0 none (an obstacle
+ * only), 1 the usual pins, more: that many on each long side (a busy card); every pin takes one line; `a`/`z` index
+ * shapes; `boxes` the open teams' outlines (separate() keeps lines off them). A line whose end is not a card or a folded box is left out (it keeps its lane).
+ */
+export function routeScene(L, lines) {
+  const shapes = [], boxes = [], at = new Map();
+  const add = (s, pins) => { shapes.push({ x: s.x, y: s.y, w: s.w, h: s.h, pins }); return shapes.length - 1; };
+  for (const c of L.tops) at.set(c.key, add(c, 1));
+  const { NW, NH, HEAD } = OC, PAD = L.pad ?? OC.PAD, GAP = L.gap ?? OC.GAP;
+  for (const b of L.boxes) {
+    if (b.folded) { at.set(`box:${b.key}`, add(b, 1)); continue; }
+    if (!b.cells.length) { add(b, 0); continue; }
+    boxes.push({ x: b.x, y: b.y, w: b.w, h: b.h });
+    for (const c of b.cells) at.set(c.key, add(c, 1));
+    add({ x: b.x - 1, y: b.y - 1, w: b.w + 2, h: HEAD + 1 }, 0);
+    const lines = Math.ceil(b.cells.length / b.cols);
+    for (let col = 0; col < b.cols; col++) add({ x: b.x + PAD + col * (NW + GAP), y: b.y + b.h - 1, w: NW, h: 2 }, 0);
+    for (const x of [b.x - 1, b.x + b.w - 1]) for (let row = 0; row < lines; row++) add({ x, y: b.y + HEAD + PAD + row * (NH + GAP), w: 2, h: NH }, 0);
+  }
+  const conns = [], demand = new Map();
+  for (const ln of lines) {
+    const a = endShape(ln.a), z = endShape(ln.z);
+    if (!a || !z || !at.has(a.key) || !at.has(z.key) || a.key === z.key) continue;
+    const ia = at.get(a.key), iz = at.get(z.key);
+    conns.push({ key: ln.key, a: ia, z: iz });
+    for (const i of [ia, iz]) demand.set(i, (demand.get(i) || 0) + 1);
+  }
+  // A line each: a shape with more lines than pins gets more pins on its long sides (two lines never leave one point:
+  // libavoid cannot nudge apart runs that start at the same point).
+  for (const [i, n] of demand) if (n > PINS_PER_CARD) shapes[i].pins = Math.min(ROUTE.MAX_PINS, Math.ceil((n - 2) / 2));
+  return { shapes, conns, boxes };
+}
+
+/** A scene from anywhere else (the worker's message): only numbers in range, only indexes it has. Null: refused. */
+export function sceneOk(s) {
+  if (!s || !Array.isArray(s.shapes) || !Array.isArray(s.conns) || !Array.isArray(s.boxes) || s.shapes.length > ROUTE.MAX_SHAPES || s.conns.length > ROUTE.MAX_CONNS
+    || s.boxes.length > ROUTE.MAX_SHAPES) return null;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) && Math.abs(v) < 1e6;
+  for (const b of s.boxes) if (!b || ![b.x, b.y, b.w, b.h].every(num) || b.w <= 0 || b.h <= 0) return null;
+  for (const sh of s.shapes) if (!sh || ![sh.x, sh.y, sh.w, sh.h].every(num) || sh.w <= 0 || sh.h <= 0 || !Number.isInteger(sh.pins) || sh.pins < 0 || sh.pins > ROUTE.MAX_PINS) return null;
+  for (const c of s.conns) {
+    if (!c || typeof c.key !== "string" || c.key.length > 2048) return null;
+    for (const i of [c.a, c.z]) if (!Number.isInteger(i) || i < 0 || i >= s.shapes.length || !s.shapes[i].pins) return null;
+  }
+  return s;
+}
+
+const onEdge = (p, s) => (Math.abs(p.x - s.x) < 0.5 || Math.abs(p.x - s.x - s.w) < 0.5) && p.y >= s.y - 0.5 && p.y <= s.y + s.h + 0.5
+  || (Math.abs(p.y - s.y) < 0.5 || Math.abs(p.y - s.y - s.h) < 0.5) && p.x >= s.x - 0.5 && p.x <= s.x + s.w + 0.5;
+/**
+ * A route for connection `c` of `scene`, or null: at most MAX_POINTS finite points, every segment horizontal or
+ * vertical, starting on its first shape's edge and ending on its second's.
+ */
+export function routeOk(pts, scene, c) {
+  if (!Array.isArray(pts) || pts.length < 2 || pts.length > ROUTE.MAX_POINTS) return null;
+  for (const p of pts) if (!p || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return null;
+  for (let i = 1; i < pts.length; i++) if (pts[i].x !== pts[i - 1].x && pts[i].y !== pts[i - 1].y) return null;
+  if (!onEdge(pts[0], scene.shapes[c.a]) || !onEdge(pts[pts.length - 1], scene.shapes[c.z])) return null;
+  return pts.map((p) => ({ x: p.x, y: p.y }));
+}
+
+/** The worker's answer to a route request `m`: its scene checked (sceneOk) before libavoid sees any of it. */
+export function answerRoute(A, m) {
+  const scene = sceneOk(m && m.scene);
+  return { type: "routes", id: m.id, routes: scene ? [...routeWith(A, scene)] : null };
+}
+
+/**
+ * libavoid nudges lines that share a run apart, but not always: in a channel shared by many lines it packs them closer
+ * than ROUTE.NUDGE, and lines fanning out of one card can come back on the very same run. This pass moves the middle
+ * segments of such lines (never a line's first or last, which end on a pin) sideways to the nearest place at least
+ * SEPARATE from every parallel line along them — only where the moved segment and the two it joins stay clear of
+ * every shape's buffer and keep their direction. What cannot move stays as libavoid left it.
+ */
+export const SEPARATE = 6;
+export function separate(routes, scene) {
+  const B = ROUTE.BUF - 0.5, OVER = 8;
+  const segsOf = (r, p) => p.slice(1).map((q, i) => ({ r, i, h: p[i].y === q.y }));
+  const coord = (p, s) => (s.h ? p[s.i].y : p[s.i].x);
+  const span = (p, s) => (s.h ? [Math.min(p[s.i].x, p[s.i + 1].x), Math.max(p[s.i].x, p[s.i + 1].x)] : [Math.min(p[s.i].y, p[s.i + 1].y), Math.max(p[s.i].y, p[s.i + 1].y)]);
+  /**
+   * A segment from a to b clear of every shape's buffer (but `own`, the card a line's first or last run starts on at its
+   * pin), and not along a box's border (through a door, say).
+   */
+  const clear = (a, b, own = -1) => {
+    const x0 = Math.min(a.x, b.x), x1 = Math.max(a.x, b.x), y0 = Math.min(a.y, b.y), y1 = Math.max(a.y, b.y), h = y0 === y1;
+    return scene.shapes.every((sh, k) => k === own || x1 <= sh.x - B || x0 >= sh.x + sh.w + B || y1 <= sh.y - B || y0 >= sh.y + sh.h + B)
+      && (scene.boxes ?? []).every((bx) => (h ? [bx.y, bx.y + bx.h].every((v) => Math.abs(v - y0) >= SEPARATE + 1) || Math.min(x1, bx.x + bx.w) - Math.max(x0, bx.x) <= 12
+        : [bx.x, bx.x + bx.w].every((v) => Math.abs(v - x0) >= SEPARATE + 1) || Math.min(y1, bx.y + bx.h) - Math.max(y0, bx.y) <= 12));
+  };
+  const keys = [...routes.keys()];
+  const connOf = new Map(scene.conns.map((c) => [c.key, c]));
+  const pts = keys.map((k) => routes.get(k).map((p) => ({ x: p.x, y: p.y })));
+  /** The segments of other lines (and this one's) parallel to segment s of line r, overlapping it, closer than SEPARATE. */
+  const near = (r, s, c, lo, hi) => {
+    const out = [];
+    pts.forEach((p, r2) => segsOf(r2, p).forEach((t) => {
+      if (t.h !== s.h || (r2 === r && t.i === s.i)) return;
+      const [l2, h2] = span(p, t);
+      if (Math.min(hi, h2) - Math.max(lo, l2) > OVER) out.push(coord(p, t));
+    }));
+    return out.filter((c2) => Math.abs(c2 - c) < SEPARATE);
+  };
+  for (let pass = 0; pass < 8; pass++) {
+    let moved = false;
+    pts.forEach((p, r) => segsOf(r, p).forEach((s) => {
+      if (s.i === 0 || s.i + 1 >= p.length - 1) return;                 // a first or last segment ends on a pin
+      const c = coord(p, s), [lo, hi] = span(p, s);
+      const close = near(r, s, c, lo, hi);
+      if (!close.length) return;
+      // Try the nearest places SEPARATE from the lines it is close to, both ways.
+      const tries = [...new Set(close.flatMap((c2) => [1, 2, 3, 4, 5, 6].flatMap((m) => [c2 + m * SEPARATE, c2 - m * SEPARATE])))].sort((u, v) => Math.abs(u - c) - Math.abs(v - c));
+      for (const c2 of tries) {
+        const a = { ...p[s.i] }, b = { ...p[s.i + 1] };
+        if (s.h) { a.y = c2; b.y = c2; } else { a.x = c2; b.x = c2; }
+        const prev = p[s.i - 1], next = p[s.i + 2];
+        // The joining segments keep their direction (never shrink through zero).
+        const dir = (u, v) => Math.sign(s.h ? v.y - u.y : v.x - u.x);
+        if (dir(prev, a) !== dir(prev, p[s.i]) || dir(b, next) !== dir(p[s.i + 1], next) || dir(prev, a) === 0 || dir(b, next) === 0) continue;
+        const c0 = connOf.get(keys[r]);
+        if (!clear(a, b) || !clear(prev, a, s.i - 1 === 0 && c0 ? c0.a : -1) || !clear(b, next, s.i + 2 === p.length - 1 && c0 ? c0.z : -1)) continue;
+        const old = [p[s.i], p[s.i + 1]];
+        p[s.i] = a; p[s.i + 1] = b;
+        const ok = !near(r, s, c2, lo, hi).length && [s.i - 1, s.i + 1].every((j) => { const t = { r, i: j, h: !s.h }; const [l3, h3] = span(p, t); return !near(r, t, coord(p, t), l3, h3).length; });
+        if (ok) { moved = true; break; }
+        [p[s.i], p[s.i + 1]] = old;
+      }
+    }));
+    if (!moved) break;
+  }
+  return new Map(keys.map((k, i) => [k, pts[i]]));
+}
+
+/**
+ * Route `scene` with libavoid instance `A` (libavoid-js 0.4.5's: its constants are numbers on `A`). A Map of
+ * connection key → points, for the routes that pass routeOk only.
+ */
+export function routeWith(A, scene) {
+  const r = new A.Router(A.OrthogonalRouting);
+  try {
+    r.setRoutingParameter(A.shapeBufferDistance, ROUTE.BUF);
+    r.setRoutingParameter(A.idealNudgingDistance, ROUTE.NUDGE);
+    r.setRoutingParameter(A.segmentPenalty, ROUTE.SEG);
+    r.setRoutingOption(A.nudgeOrthogonalSegmentsConnectedToShapes, true);
+    r.setRoutingOption(A.nudgeSharedPathsWithCommonEndPoint, true);
+    for (const [k, v] of Object.entries(ROUTE.EXTRA_OPT ?? {})) r.setRoutingOption(A[k], v);
+    for (const [k, v] of Object.entries(ROUTE.EXTRA_PARAM ?? {})) r.setRoutingParameter(A[k], v);
+    // The router owns its shapes, pins and connectors (A.destroy(r) frees them); the points, rectangles and ends it
+    // copies are freed here, or the wasm heap grows with every route.
+    const temp = (o) => { made.push(o); return o; }, made = [];
+    const refs = scene.shapes.map((s) => {
+      const ref = new A.ShapeRef(r, temp(new A.Rectangle(temp(new A.Point(s.x, s.y)), temp(new A.Point(s.x + s.w, s.y + s.h)))));
+      if (s.pins) {
+        const k = s.pins === 1 ? ROUTE.PINS : s.pins;
+        const pin = (x, y, dir) => new A.ShapeConnectionPin(ref, 1, x, y, true, 0, dir).setExclusive(true);
+        for (let i = 1; i <= k; i++) { pin(i / (k + 1), 0, UP); pin(i / (k + 1), 1, DOWN); }
+        pin(0, 0.5, LEFT); pin(1, 0.5, RIGHT);
+      }
+      return ref;
+    });
+    const conns = scene.conns.map((c) => new A.ConnRef(r, temp(new A.ConnEnd(refs[c.a], 1)), temp(new A.ConnEnd(refs[c.z], 1))));
+    for (const o of made.splice(0)) A.destroy(o);
+    r.processTransaction();
+    const out = new Map();
+    scene.conns.forEach((c, i) => {
+      const line = conns[i].displayRoute(), pts = [];
+      for (let k = 0; k < line.size() && k <= ROUTE.MAX_POINTS; k++) { const p = line.get_ps(k); pts.push({ x: p.x, y: p.y }); }
+      const ok = routeOk(pts, scene, c);
+      if (ok) out.set(c.key, ok);
+    });
+    return ROUTE.SEPARATE === false ? out : separate(out, scene);
+  } finally {
+    A.destroy(r);
+  }
+}

package/dist/ui/fleet-route-worker.js

@@ -0,0 +1,21 @@
+// #2182: the worker that routes the org canvas's traffic lines (fleet-route-scene.js says what to route). It is served
+// with a policy of its own (web-host-guard.ts ROUTE_WORKER_CSP): WebAssembly may run here, as it may not on the page,
+// and it may reach nothing — the page fetches libavoid.wasm and hands the bytes over; they are instantiated from a
+// blob: URL. It receives numbers and answers numbers; the page checks both.
+import { AvoidLib } from "/ui/vendor/libavoid-0.4.5/libavoid.js";
+import { answerRoute } from "./fleet-route-scene.js";
+
+let ready = null;
+self.onmessage = (ev) => {
+  const m = ev.data;
+  if (!m || typeof m !== "object") return;
+  if (m.type === "init" && !ready && m.wasm instanceof ArrayBuffer) {
+    const url = URL.createObjectURL(new Blob([m.wasm], { type: "application/wasm" }));
+    ready = AvoidLib.load(url).then(() => AvoidLib.getInstance()).finally(() => URL.revokeObjectURL(url));
+    ready.then(() => self.postMessage({ type: "ready" }), () => self.postMessage({ type: "failed" }));
+    return;
+  }
+  if (m.type === "route" && ready && Number.isInteger(m.id)) {
+    ready.then((A) => self.postMessage(answerRoute(A, m))).catch(() => self.postMessage({ type: "routes", id: m.id, routes: null }));
+  }
+};

package/dist/ui/fleet-route.js

@@ -0,0 +1,88 @@
+// #2182: the page's side of the traffic router — one worker (fleet-route-worker.js), started the first time Live
+// traffic is drawn, fed the libavoid.wasm bytes the page fetched. One scene at a time: a newer one replaces any still
+// waiting (the older one's answer would be stale anyway). A worker that fails, or takes longer than TIMEOUT_MS, is
+// ended; after FAIL_LIMIT failures in a row this page stops asking, and every line keeps its lane route (the caller's
+// fallback for a null answer).
+import { routeOk } from "./fleet-route-scene.js";
+
+export const WORKER_URL = "/ui/js/fleet-route-worker.js";
+export const WASM_URL = "/ui/vendor/libavoid-0.4.5/libavoid.wasm";
+export const TIMEOUT_MS = 4000;
+const FAIL_LIMIT = 2;
+
+/**
+ * A client: route(scene) → a Promise of a Map (connection key → points, checked against the scene) or null (not
+ * routed: superseded, failed, unavailable). `deps` replaces Worker, fetch and the clock in tests.
+ */
+export function createRouteClient(deps = {}) {
+  const W = deps.Worker ?? (typeof Worker === "function" ? Worker : null);
+  const get = deps.fetch ?? ((...a) => fetch(...a));
+  const timers = deps.timers ?? { set: (f, ms) => setTimeout(f, ms), clear: (t) => clearTimeout(t) };
+  let worker = null, wasm = null, fails = 0, nextId = 1;
+  let busy = null, waiting = null;          // { id, scene, resolve, timer }
+  const end = () => { try { worker?.terminate(); } catch { /* gone */ } worker = null; };
+  const fail = () => {
+    fails++;
+    end();
+    if (busy) { timers.clear(busy.timer); busy.resolve(null); busy = null; }
+    if (fails >= FAIL_LIMIT && waiting) { waiting.resolve(null); waiting = null; }
+    pump();
+  };
+  async function start(job) {
+    if (!wasm) {
+      const res = await get(WASM_URL, { credentials: "same-origin" });
+      if (!res.ok) throw new Error(`libavoid.wasm: ${res.status}`);
+      wasm = await res.arrayBuffer();
+    }
+    // #2194 review: closed, timed out or replaced while the .wasm was on its way — start nothing (a worker made now
+    // would be nobody's, and a later start would make another).
+    if (busy !== job || worker) return;
+    const w = new W(WORKER_URL, { type: "module" });
+    w.onmessage = (ev) => {
+      const m = ev.data;
+      if (!m || typeof m !== "object" || w !== worker) return;
+      if (m.type === "failed") { fail(); return; }
+      if (m.type !== "routes" || !busy || m.id !== busy.id) return;
+      const { scene, resolve, timer } = busy;
+      busy = null;
+      timers.clear(timer);
+      if (!Array.isArray(m.routes)) { fail(); resolve(null); return; }
+      fails = 0;
+      const out = new Map();
+      for (const pair of m.routes.slice(0, scene.conns.length)) {
+        if (!Array.isArray(pair) || typeof pair[0] !== "string") continue;
+        const c = scene.conns.find((x) => x.key === pair[0]);
+        const pts = c && routeOk(pair[1], scene, c);
+        if (pts) out.set(c.key, pts);
+      }
+      resolve(out);
+      pump();
+    };
+    w.onerror = (e) => { e?.preventDefault?.(); if (w === worker) fail(); };
+    worker = w;
+    w.postMessage({ type: "init", wasm: wasm.slice(0) });
+  }
+  function pump() {
+    if (busy || !waiting) return;
+    if (fails >= FAIL_LIMIT || !W) { waiting.resolve(null); waiting = null; return; }
+    busy = waiting; waiting = null;
+    const job = busy;
+    job.timer = timers.set(() => { if (busy === job) fail(); }, TIMEOUT_MS);
+    (worker ? Promise.resolve() : start(job)).then(() => {
+      if (busy === job) worker.postMessage({ type: "route", id: job.id, scene: job.scene });
+    }, () => { if (busy === job) fail(); });
+  }
+  return {
+    route(scene) {
+      if (waiting) waiting.resolve(null);
+      return new Promise((resolve) => { waiting = { id: nextId++, scene, resolve, timer: null }; pump(); });
+    },
+    /** Off: the worker ended; what was waiting gets null. */
+    close() {
+      if (waiting) { waiting.resolve(null); waiting = null; }
+      if (busy) { timers.clear(busy.timer); busy.resolve(null); busy = null; }
+      end();
+    },
+    get available() { return !!W && fails < FAIL_LIMIT; },
+  };
+}