@isothrum/editor 0.0.0-stage → 0.1.0

package/src/lib/tool/cables.ts

@@ -0,0 +1,215 @@
+import type { Connection } from "@xyflow/react";
+import { sideOnLan } from "./geometry";
+import { isAppliance, isLan, isMachine, isRealRouter, isSwitch, routerPort, uid, type CableEdge, type LabNode, type LanNode, type MachineNode } from "./model";
+import { accessVlan, switchPortLabel, vlanName } from "./vlans";
+
+/** Cables: where they plug in, what their ends are called, and which network each one is. */
+
+/** The handle a cable uses on a machine: an appliance's single port, or a machine's top/bottom. */
+function machineHandle(m: MachineNode, old: string | null | undefined): string {
+  if (isAppliance(m)) return "port";
+  return old === "bottom" ? "bottom" : "top";
+}
+
+const isPort = (h: string | null | undefined): h is string => !!h && /^eth\d+$/.test(h);
+
+/** The ports each real router's cables already plug into. */
+function takenPorts(edges: CableEdge[], byId: Map<string, LabNode>): Map<string, Set<string>> {
+  const taken = new Map<string, Set<string>>();
+  for (const e of edges) {
+    for (const [id, h] of [
+      [e.source, e.sourceHandle],
+      [e.target, e.targetHandle],
+    ] as const) {
+      const n = byId.get(id);
+      if (n && isRealRouter(n) && isPort(h)) taken.set(id, (taken.get(id) ?? new Set()).add(h));
+    }
+  }
+  return taken;
+}
+
+/**
+ * Cables saved with the old handles (one on each side of every machine) move onto the current
+ * ones: an appliance's single port, the top or bottom of other machines. LAN handles stay.
+ */
+export function migrateEdges(edges: CableEdge[], nodes: LabNode[]): CableEdge[] {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  // A real router's cables plug into its ports: one that isn't on a port yet takes a free one.
+  const taken = takenPorts(edges, byId);
+  const freePort = (id: string) => {
+    const used = taken.get(id) ?? new Set<string>();
+    for (let i = 0; i < 64; i++) {
+      if (!used.has(routerPort(i))) {
+        used.add(routerPort(i));
+        taken.set(id, used);
+        return routerPort(i);
+      }
+    }
+    return routerPort(0);
+  };
+  const fix = (id: string, h: string | null | undefined) => {
+    const n = byId.get(id);
+    if (n && isRealRouter(n)) return isPort(h) ? h : freePort(id);
+    return n && isMachine(n) ? machineHandle(n, h) : h;
+  };
+  return edges.map((e) => ({ ...e, sourceHandle: fix(e.source, e.sourceHandle), targetHandle: fix(e.target, e.targetHandle) }));
+}
+
+/** The ports a machine's cables already use. */
+function usedPorts(nodeId: string, edges: CableEdge[]): string[] {
+  return edges.flatMap((e) => [...(e.source === nodeId && e.data ? [e.data.aPort] : []), ...(e.target === nodeId && e.data ? [e.data.bPort] : [])]);
+}
+
+/**
+ * The first free `eth<n>` on a machine, from `first`: an appliance on a LAN's edge uses eth0 on
+ * that LAN, so its cables start at eth1.
+ */
+export function nextPort(nodeId: string, edges: CableEdge[], first = 0): string {
+  const used = new Set(usedPorts(nodeId, edges));
+  for (let i = first; ; i++) {
+    if (!used.has(`eth${String(i)}`)) return `eth${String(i)}`;
+  }
+}
+
+/** Whether a cable runs between two named machines: a link of its own in isoloom.yml. */
+function isLink(e: CableEdge, byId: Map<string, LabNode>): boolean {
+  const x = byId.get(e.source);
+  const y = byId.get(e.target);
+  return !!x && !!y && isMachine(x) && isMachine(y) && !!x.data.name && !!y.data.name && !!e.data;
+}
+
+/** The network a cable on a switch port carries: the access port's VLAN (a trunk carries several). */
+function switchNetwork(edge: CableEdge, byId: Map<string, LabNode>): string | null | undefined {
+  for (const [sw, handle] of [
+    [byId.get(edge.source), edge.sourceHandle],
+    [byId.get(edge.target), edge.targetHandle],
+  ] as const) {
+    if (!sw || !isSwitch(sw)) continue;
+    const vlan = accessVlan(sw, handle);
+    return vlan !== null ? vlanName(vlan) : null;
+  }
+  return undefined;
+}
+
+/**
+ * The Isoloom network a cable became (`link-<n>`): cables between two machines are numbered in
+ * the order `toTopology` lists them. A cable to a LAN is that LAN.
+ */
+export function networkOfCable(edgeId: string, nodes: LabNode[], edges: CableEdge[]): string | null {
+  const byId = new Map(nodes.map((n) => [n.id, n]));
+  const edge = edges.find((e) => e.id === edgeId);
+  if (!edge) return null;
+  const a = byId.get(edge.source);
+  const b = byId.get(edge.target);
+  if (a && isLan(a)) return a.data.name;
+  if (b && isLan(b)) return b.data.name;
+  const onSwitch = switchNetwork(edge, byId);
+  if (onSwitch !== undefined) return onSwitch;
+  const i = edges.filter((e) => isLink(e, byId)).findIndex((e) => e.id === edgeId);
+  return i < 0 ? null : `link-${String(i)}`;
+}
+
+/** The names of a cable's ends that are machines (a LAN or a switch has no port to cut). */
+export function machineEnds(edge: CableEdge, nodes: LabNode[]): string[] {
+  return [edge.source, edge.target].flatMap((id) => {
+    const n = nodes.find((x) => x.id === id);
+    return n && isMachine(n) ? [n.data.name] : [];
+  });
+}
+
+/** What a cable's ends can plug into, by node id. */
+export interface LabIndex {
+  lanIds: Set<string>;
+  switchIds: Set<string>;
+  routerIds: Set<string>;
+}
+
+/** Whether a cable end on `node` takes a port: a switch's or a real router's. */
+const ported = (index: LabIndex, node: string) => index.switchIds.has(node) || index.routerIds.has(node);
+
+/** Whether a switch or router port already has a cable (other than `ignore`, the one moving). */
+function portTaken(index: LabIndex, edges: CableEdge[], ignore: string | undefined, node: string, handle: string | null | undefined): boolean {
+  return (
+    ported(index, node) &&
+    edges.some((e) => e.id !== ignore && ((e.source === node && e.sourceHandle === handle) || (e.target === node && e.targetHandle === handle)))
+  );
+}
+
+/** A cable's two ends, as React Flow gives them (a connection being drawn, or a cable). */
+interface Ends {
+  source: string;
+  target: string;
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+}
+
+/**
+ * Machine to machine, LAN or port. Never LAN to LAN or switch to LAN, and a switch or router
+ * port takes one cable, as on real gear. `ignore`: the cable being moved, whose ends don't count.
+ */
+export function canConnect(c: Ends, index: LabIndex, edges: CableEdge[], ignore?: string): boolean {
+  if (c.source === c.target) return false;
+  const area = (id: string) => index.lanIds.has(id) || index.switchIds.has(id);
+  const bothSwitches = index.switchIds.has(c.source) && index.switchIds.has(c.target);
+  if (area(c.source) && area(c.target) && !bothSwitches) return false;
+  return !portTaken(index, edges, ignore, c.source, c.sourceHandle) && !portTaken(index, edges, ignore, c.target, c.targetHandle);
+}
+
+/** An appliance on a LAN's edge already uses eth0 there. */
+export function onLanEdge(id: string, nodes: LabNode[], lans: LanNode[]): boolean {
+  const n = nodes.find((x) => x.id === id);
+  return !!n && isAppliance(n) && sideOnLan(n, lans) !== null;
+}
+
+/**
+ * The label of a cable's end on `node`: the switch port, the router's port, nothing on a LAN,
+ * or else `machinePort()` (the machine's next free port, or the one it keeps).
+ */
+function endLabel(index: LabIndex, node: string, handle: string | null | undefined, machinePort: () => string): string {
+  if (index.lanIds.has(node)) return "";
+  if (index.switchIds.has(node)) return switchPortLabel(handle);
+  if (index.routerIds.has(node)) return handle ?? "";
+  return machinePort();
+}
+
+/** A new cable for a connection, its ends labelled (`first(node)`: the first port to give). */
+export function newCable(c: Connection, index: LabIndex, edges: CableEdge[], first: (node: string) => number): CableEdge {
+  return {
+    id: uid("c"),
+    type: "cable",
+    source: c.source,
+    sourceHandle: c.sourceHandle,
+    target: c.target,
+    targetHandle: c.targetHandle,
+    // A LAN has no ports: the cable's end on it stays unnamed.
+    data: {
+      aPort: endLabel(index, c.source, c.sourceHandle, () => nextPort(c.source, edges, first(c.source))),
+      bPort: endLabel(index, c.target, c.targetHandle, () => nextPort(c.target, edges, first(c.target))),
+    },
+  };
+}
+
+/**
+ * The cables after `old` moved to `c`. A moved end gets the label of where it lands: the switch
+ * port, nothing on a LAN, or the machine's next free port. An end that stays put keeps its label
+ * (same machine: same port; where on its box the cable attaches is only drawing).
+ */
+export function reconnected(edges: CableEdge[], old: CableEdge, c: Connection, index: LabIndex, first: (node: string) => number): CableEdge[] {
+  const others = edges.filter((e) => e.id !== old.id);
+  const label = (node: string, handle: string | null, keep: string, same: boolean) => endLabel(index, node, handle, () => (same ? keep : nextPort(node, others, first(node))));
+  return edges.map((e) =>
+    e.id !== old.id || !e.data
+      ? e
+      : {
+          ...e,
+          source: c.source,
+          sourceHandle: c.sourceHandle,
+          target: c.target,
+          targetHandle: c.targetHandle,
+          data: {
+            aPort: label(c.source, c.sourceHandle, e.data.aPort, c.source === e.source),
+            bPort: label(c.target, c.targetHandle, e.data.bPort, c.target === e.target),
+          },
+        },
+  );
+}

package/src/lib/tool/clone.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, test } from "vitest";
+import { cloneLab } from "./clone";
+import type { LabNode } from "./model";
+import { byId, cable, lan, machine, note, switchNode } from "@/test/lab";
+
+const office = lan("l1", { name: "office", cidr: "10.10.1.0/24" });
+const web = machine("m1", { name: "web1", pins: { office: 20 } }, { x: 10, y: 20 });
+const db = machine("m2", { name: "db1" });
+const sw = switchNode("s1", { name: "sw1" });
+const existing: LabNode[] = [office, web, db, sw];
+const copy = (picked: LabNode[], edges = [cable("c1", "m1", "m2"), cable("c2", "m1", "l1")]) => cloneLab(picked, edges, existing, { x: 40, y: 50 });
+
+describe("cloneLab", () => {
+  test("copies under new ids, moved by the offset, selected", () => {
+    const [c] = copy([web]).nodes;
+    expect(c.id).not.toBe(web.id);
+    expect(c).toMatchObject({ position: { x: 50, y: 70 }, selected: true });
+  });
+
+  test("gives each copy the next free name of its kind", () => {
+    expect(copy([web, db, sw]).nodes.map((n) => (n.type === "note" ? "" : n.data.name))).toEqual(["web2", "db2", "sw2"]);
+  });
+
+  test("names a copy of a nameless machine copy<n>", () => {
+    expect(copy([machine("m9", { name: "" })]).nodes.map((n) => (n.type === "note" ? "" : n.data.name))).toEqual(["copy1"]);
+  });
+
+  test("drops a machine's fixed addresses, which would collide with the original's", () => {
+    const [c] = copy([web]).nodes;
+    expect(c.type === "machine" && c.data.pins).toBeUndefined();
+  });
+
+  test("gives each copied LAN the next block free in the lab, one each", () => {
+    const blocks = copy([office, office]).nodes.map((n) => (n.type === "lan" ? n.data.cidr : ""));
+    expect(blocks).toEqual(["10.10.2.0/24", "10.10.3.0/24"]);
+  });
+
+  test("keeps a switch's VLAN numbers, in lists of its own", () => {
+    const [c] = copy([sw]).nodes;
+    expect(c.type === "switch" && c.data.vlans).toEqual(sw.data.vlans);
+    expect(c.type === "switch" && c.data.vlans !== sw.data.vlans && c.data.ports !== sw.data.ports).toBe(true);
+  });
+
+  test("copies a note as it is", () => {
+    expect(copy([note("n1")]).nodes[0].data).toEqual(note("n1").data);
+  });
+
+  test("copies only the cables between copied nodes, joined to the copies", () => {
+    const { nodes, edges } = copy([web, db]);
+    expect(edges).toHaveLength(1);
+    expect(edges[0]).toMatchObject({ source: nodes[0].id, target: nodes[1].id, selected: false, data: { aPort: "eth0", bPort: "eth0" } });
+    expect(byId(nodes, edges[0].source).id).not.toBe("m1");
+  });
+});

package/src/lib/tool/clone.ts

@@ -0,0 +1,48 @@
+import type { XYPosition } from "@xyflow/react";
+import { usedThirds } from "./create";
+import { freeName, uid, type CableEdge, type LabNode } from "./model";
+
+const idPrefix: Record<LabNode["type"], string> = { lan: "l", switch: "s", note: "n", machine: "m" };
+
+/** The next free 10.10.<n>.0/24 for a copied LAN (and taken from then on). */
+function takeThird(used: Set<number>): number {
+  let third = 1;
+  while (used.has(third)) third++;
+  used.add(third);
+  return third;
+}
+
+/** A copy of `n` with a fresh name (web1 -> web3) at `position`, its LAN block taken from `used`. */
+function copyOf(n: Exclude<LabNode, { type: "note" }>, id: string, position: XYPosition, all: LabNode[], used: Set<number>): LabNode {
+  const name = freeName(n.data.name.replace(/\d+$/, "") || "copy", all);
+  if (n.type === "lan") return { ...n, id, position, selected: true, data: { ...n.data, name, cidr: `10.10.${String(takeThird(used))}.0/24` } };
+  if (n.type === "machine") return { ...n, id, position, selected: true, data: { ...n.data, name, pins: undefined } };
+  return { ...n, id, position, selected: true, data: { ...n.data, name, vlans: n.data.vlans.map((v) => ({ ...v })), ports: [...n.data.ports] } };
+}
+
+/**
+ * Copies of `picked` (and of the cables between them) ready to add to `existing`: new ids,
+ * moved by `offset`, fresh names (web1 -> web3), a LAN with its own free block, no fixed
+ * addresses (they would collide with the originals). VLANs keep their numbers: they are
+ * lab-wide.
+ */
+export function cloneLab(picked: LabNode[], edges: CableEdge[], existing: LabNode[], offset: XYPosition): { nodes: LabNode[]; edges: CableEdge[] } {
+  const ids = new Map<string, string>();
+  const all: LabNode[] = [...existing];
+  const used = usedThirds(all);
+  const nodes = picked.map((n) => {
+    const id = uid(idPrefix[n.type]);
+    ids.set(n.id, id);
+    const position = { x: n.position.x + offset.x, y: n.position.y + offset.y };
+    const copy: LabNode = n.type === "note" ? { ...n, id, position, selected: true, data: { ...n.data } } : copyOf(n, id, position, all, used);
+    all.push(copy);
+    return copy;
+  });
+  const copies = edges.flatMap((e) => {
+    const source = ids.get(e.source);
+    const target = ids.get(e.target);
+    if (source === undefined || target === undefined) return [];
+    return [{ ...e, id: uid("c"), source, target, selected: false, data: e.data ? { ...e.data } : e.data }];
+  });
+  return { nodes, edges: copies };
+}

package/src/lib/tool/conditions.test.ts

@@ -0,0 +1,170 @@
+import fc from "fast-check";
+import { describe, expect, test } from "vitest";
+import { conditionsLabel, conditionsOf, tcOf, tcProblemText, withCondition } from "./conditions";
+import { arbitraryConditions } from "@/test/arbitrary";
+
+describe("tcOf", () => {
+  test("writes delay, jitter, loss and rate as Isoloom's tc takes them", () => {
+    expect(tcOf({ delay: 40, jitter: 5, loss: 0.5, rate: 10 })).toEqual({ delay: "40ms", jitter: "5ms", loss: 0.5, rate: "10mbit" });
+  });
+
+  test("writes a fractional rate in kbit", () => {
+    expect(tcOf({ rate: 2.5 })).toEqual({ rate: "2500kbit" });
+  });
+
+  test("writes a rate that isn't whole kbit/s in bits", () => {
+    expect(tcOf({ rate: 0.0005 })).toEqual({ rate: "500bit" });
+  });
+
+  test("writes a loss above 100% and a jitter without a delay as they are, for Isoloom to report", () => {
+    expect(tcOf({ loss: 150, jitter: 5 })).toEqual({ loss: 150, jitter: "5ms" });
+  });
+
+  test("writes every number it holds, zero and negative ones too, as Isoloom reads them", () => {
+    expect(tcOf({ delay: 0, loss: -1 })).toEqual({ delay: "0ms", loss: -1 });
+  });
+
+  test("is undefined when nothing is set", () => {
+    for (const c of [undefined, {}, { delay: Number.NaN }, { rate: Number.POSITIVE_INFINITY }]) expect(tcOf(c)).toBeUndefined();
+  });
+});
+
+describe("conditionsLabel", () => {
+  test("summarizes the conditions for the canvas", () => {
+    expect(conditionsLabel({ delay: 40, jitter: 5, loss: 0.5, rate: 10 })).toBe("40 ms ±5 · 0.5% · 10 Mbit/s");
+  });
+
+  test("is empty when there are no conditions", () => {
+    expect(conditionsLabel(undefined)).toBe("");
+    expect(conditionsLabel({})).toBe("");
+  });
+
+  test("shows a jitter without a delay, as it is written", () => {
+    expect(conditionsLabel({ jitter: 5 })).toBe("±5 ms");
+  });
+});
+
+describe("conditionsOf", () => {
+  test("reads Isoloom's tc back into the editor's numbers", () => {
+    expect(conditionsOf({ delay: "40ms", jitter: "5ms", loss: 1, rate: "10mbit" })).toEqual({ conditions: { delay: 40, jitter: 5, loss: 1, rate: 10 }, problems: [] });
+  });
+
+  test("reads a time in microseconds or seconds as milliseconds", () => {
+    expect(conditionsOf({ delay: "1s", jitter: "500us" }).conditions).toEqual({ delay: 1000, jitter: 0.5 });
+  });
+
+  test("converts gbit, kbit and bits to Mbit/s", () => {
+    expect(conditionsOf({ rate: "1gbit" }).conditions?.rate).toBe(1000);
+    expect(conditionsOf({ rate: "500kbit" }).conditions?.rate).toBe(0.5);
+    expect(conditionsOf({ rate: "2000000bit" }).conditions?.rate).toBe(2);
+  });
+
+  test("reports a rate without its unit, as Isoloom does", () => {
+    expect(conditionsOf({ rate: "2000000" })).toEqual({ conditions: undefined, problems: [{ field: "rate", value: "2000000" }] });
+  });
+
+  test("reads a number in any spelling Isoloom reads: a sign, a lone point, an exponent", () => {
+    expect(conditionsOf({ delay: "+.5ms", jitter: "5.ms", rate: "1E-3gbit" }).conditions).toEqual({ delay: 0.5, jitter: 5, rate: 1 });
+  });
+
+  test("reads a rate in bytes per second as eight bits a byte", () => {
+    expect(conditionsOf({ rate: "2mbps" }).conditions?.rate).toBe(16);
+  });
+
+  test("reports each value it can't read, and keeps the others", () => {
+    expect(conditionsOf({ delay: "fast", jitter: "5", loss: 1, rate: "10Mbit" })).toEqual({
+      conditions: { loss: 1 },
+      problems: [
+        { field: "delay", value: "fast" },
+        { field: "jitter", value: "5" },
+        { field: "rate", value: "10Mbit" },
+      ],
+    });
+  });
+
+  test("reads a negative time as Isoloom does, and reports one too large to be a number", () => {
+    expect(conditionsOf({ delay: "-5ms", jitter: "1e999ms" })).toEqual({ conditions: { delay: -5 }, problems: [{ field: "jitter", value: "1e999ms" }] });
+  });
+
+  test("is no conditions and no problems when there is no tc, or nothing in it", () => {
+    expect(conditionsOf(undefined)).toEqual({ conditions: undefined, problems: [] });
+    expect(conditionsOf({})).toEqual({ conditions: undefined, problems: [] });
+  });
+
+  test("inverts tcOf", () => {
+    const c = { delay: 40, jitter: 5, loss: 0.5, rate: 2.5 };
+    expect(conditionsOf(tcOf(c))).toEqual({ conditions: c, problems: [] });
+  });
+
+});
+
+describe("conditionsOf, for any value", () => {
+  test("inverts tcOf for any conditions the editor keeps", () => {
+    fc.assert(
+      fc.property(arbitraryConditions, (c) => {
+        expect(conditionsOf(tcOf(c)).conditions).toEqual(c);
+      }),
+    );
+  });
+
+  test("reads a time the same in any of its units", () => {
+    fc.assert(
+      fc.property(fc.integer({ min: 0, max: 1_000_000 }), (s) => {
+        const read = [`${String(s)}s`, `${String(s * 1000)}ms`, `${String(s * 1_000_000)}us`].map((delay) => conditionsOf({ delay }).conditions?.delay);
+        expect(read).toEqual([s * 1000, s * 1000, s * 1000]);
+      }),
+    );
+  });
+
+  test("reads a rate the same in any of its units, in bits or bytes", () => {
+    fc.assert(
+      fc.property(fc.integer({ min: 0, max: 1_000_000 }), (g) => {
+        const bits = [`${String(g)}gbit`, `${String(g * 1000)}mbit`, `${String(g * 1e6)}kbit`, `${String(g * 1e9)}bit`];
+        const bytes = [`${String(g * 125)}mbps`, `${String(g * 125_000)}kbps`, `${String(g * 125e6)}bps`];
+        expect([...bits, ...bytes].map((rate) => conditionsOf({ rate }).conditions?.rate)).toEqual(Array<number>(7).fill(g * 1000));
+      }),
+    );
+  });
+
+  test("reads or reports every value, never dropping one", () => {
+    const value = fc.oneof(fc.string(), fc.tuple(fc.double(), fc.constantFrom("", "us", "ms", "s", "kbit", "mbit", "x")).map(([n, unit]) => `${String(n)}${unit}`));
+    fc.assert(
+      fc.property(fc.record({ delay: value, jitter: value, rate: value }, { requiredKeys: [] }), (tc) => {
+        const { conditions, problems } = conditionsOf(tc);
+        for (const field of ["delay", "jitter", "rate"] as const) {
+          const read = conditions?.[field];
+          const reported = problems.some((p) => p.field === field && p.value === tc[field]);
+          expect(read !== undefined || reported).toBe(tc[field] !== undefined);
+          expect(read !== undefined && reported).toBe(false);
+          expect(Number.isNaN(read)).toBe(false);
+        }
+      }),
+    );
+  });
+});
+
+describe("tcProblemText", () => {
+  test("names the field's path, the value, the form it takes, and what the editor does", () => {
+    expect(tcProblemText("networks.slow.tc", { field: "delay", value: "fast" })).toBe("networks.slow.tc.delay: `fast` isn't a time like 40ms, 500us or 1s; the drawing leaves it out");
+    expect(tcProblemText("links[0].tc", { field: "rate", value: "lots" })).toBe("links[0].tc.rate: `lots` isn't a rate like 10mbit or 512kbit; the drawing leaves it out");
+  });
+});
+
+describe("withCondition", () => {
+  test("sets a field to the positive number typed", () => {
+    expect(withCondition(undefined, "delay", "40")).toEqual({ delay: 40 });
+  });
+
+  test("clears a field typed empty or not positive, keeping the others", () => {
+    expect(withCondition({ delay: 40, loss: 1 }, "delay", "-5")).toEqual({ loss: 1 });
+  });
+
+  test("leaves no conditions once every field is cleared", () => {
+    expect(withCondition({ delay: 40 }, "delay", "")).toBeUndefined();
+  });
+
+  test("keeps a field a stored lab carries that the editor doesn't know", () => {
+    const stored = { delay: 40, mtu: 1400 };
+    expect(withCondition(stored, "delay", "")).toEqual({ mtu: 1400 });
+  });
+});

package/src/lib/tool/conditions.ts

@@ -0,0 +1,132 @@
+import type { LinkConditions } from "./model";
+
+/** Isoloom's `tc` for a slow or lossy link, as the engine's topology takes it. */
+export interface Tc {
+  delay?: string;
+  jitter?: string;
+  loss?: number;
+  rate?: string;
+}
+
+/** Whether a field holds a number: every finite one is written, for Isoloom to judge (it reports a loss above 100%, or a jitter without a delay). */
+const isSet = (n: number | undefined): n is number => typeof n === "number" && Number.isFinite(n);
+
+/** Whether `n` is a whole number, give or take what floating point loses in a multiplication. */
+const whole = (n: number) => Math.abs(n - Math.round(n)) < 1e-9;
+
+/** A rate (Mbit/s) as `tc` writes one: whole Mbit/s, else whole kbit/s, else bits. */
+function rateText(rate: number): string {
+  if (Number.isInteger(rate)) return `${String(rate)}mbit`;
+  if (whole(rate * 1000)) return `${String(Math.round(rate * 1000))}kbit`;
+  return `${String(rate * 1_000_000)}bit`;
+}
+
+/** The conditions as Isoloom's `tc` takes them, or `undefined` when none is set. */
+export function tcOf(c: LinkConditions | undefined): Tc | undefined {
+  if (!c) return undefined;
+  const tc = {
+    ...(isSet(c.delay) ? { delay: `${String(c.delay)}ms` } : {}),
+    ...(isSet(c.jitter) ? { jitter: `${String(c.jitter)}ms` } : {}),
+    ...(isSet(c.loss) ? { loss: c.loss } : {}),
+    ...(isSet(c.rate) ? { rate: rateText(c.rate) } : {}),
+  };
+  return Object.keys(tc).length ? tc : undefined;
+}
+
+/** A short summary for the canvas: `40 ms ±5 · 0.5% · 10 Mbit/s`. */
+export function conditionsLabel(c: LinkConditions | undefined): string {
+  if (!tcOf(c) || !c) return "";
+  const parts: string[] = [];
+  const jitter = isSet(c.jitter) ? ` ±${String(c.jitter)}` : "";
+  if (isSet(c.delay)) parts.push(`${String(c.delay)} ms${jitter}`);
+  else if (jitter) parts.push(`${jitter.trim()} ms`);
+  if (isSet(c.loss)) parts.push(`${String(c.loss)}%`);
+  if (isSet(c.rate)) parts.push(`${String(c.rate)} Mbit/s`);
+  return parts.join(" · ");
+}
+
+/** The `tc` fields written as a number and a unit: two times and a rate. */
+type MeasuredField = "delay" | "jitter" | "rate";
+
+/** A `tc` value the editor can't read: left out of the drawing and reported, never guessed. */
+export interface TcProblem {
+  field: MeasuredField;
+  value: string;
+}
+
+/** A `tc` read back: the editor's numbers (none when nothing is set), and each value it couldn't read. */
+export interface ReadConditions {
+  conditions: LinkConditions | undefined;
+  problems: TcProblem[];
+}
+
+/** A unit as `[times, per]`: a value in it is `value * times / per` in the editor's unit. */
+type Scale = readonly [times: number, per: number];
+
+/** The time units Isoloom's `tc` takes, to milliseconds. */
+const TIME: ReadonlyMap<string, Scale> = new Map([
+  ["us", [1, 1000]],
+  ["ms", [1, 1]],
+  ["s", [1000, 1]],
+]);
+
+/** The rate units Isoloom's `tc` takes, to Mbit/s: `bps` counts bytes. A rate has its unit: Isoloom refuses a bare number. */
+const RATE: ReadonlyMap<string, Scale> = new Map([
+  ["bit", [1, 1_000_000]],
+  ["kbit", [1, 1000]],
+  ["mbit", [1, 1]],
+  ["gbit", [1000, 1]],
+  ["bps", [8, 1_000_000]],
+  ["kbps", [8, 1000]],
+  ["mbps", [8, 1]],
+  ["gbps", [8000, 1]],
+]);
+
+const UNITS: Record<MeasuredField, ReadonlyMap<string, Scale>> = { delay: TIME, jitter: TIME, rate: RATE };
+
+/**
+ * A number and the letters after it, split as Isoloom splits a `tc` value: the letters at the end
+ * are the unit, and what comes before is a number as Rust reads one (a sign, digits with or
+ * without a point, an exponent: `40`, `-0.5`, `.5`, `5.`, `1E-3`).
+ */
+const MEASURE = /^([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)([A-Za-z]*)$/;
+
+/** `40ms` -> 40, `500us` -> 0.5, `1gbit` -> 1000: in the editor's unit, or undefined when `v` isn't a number and one of `units` (Isoloom's, case and all), or too large to be one. */
+function measure(v: string, units: ReadonlyMap<string, Scale>): number | undefined {
+  const m = MEASURE.exec(v);
+  const scale = m ? units.get(m[2]) : undefined;
+  if (!m || !scale) return undefined;
+  const n = (Number(m[1]) * scale[0]) / scale[1];
+  return Number.isFinite(n) ? n : undefined;
+}
+
+/** Isoloom's `tc` back to the editor's numbers: the inverse of `tcOf`, every value it can't read reported. */
+export function conditionsOf(tc: Tc | undefined): ReadConditions {
+  const conditions: LinkConditions = {};
+  const problems: TcProblem[] = [];
+  for (const field of ["delay", "jitter", "rate"] as const) {
+    const value = tc?.[field];
+    if (value === undefined) continue;
+    const n = measure(value, UNITS[field]);
+    if (n === undefined) problems.push({ field, value });
+    else conditions[field] = n;
+  }
+  if (tc?.loss !== undefined) conditions.loss = tc.loss;
+  return { conditions: Object.keys(conditions).length ? conditions : undefined, problems };
+}
+
+/** What each field takes, as the fix a problem names. */
+const EXPECTED: Record<MeasuredField, string> = { delay: "a time like 40ms, 500us or 1s", jitter: "a time like 40ms, 500us or 1s", rate: "a rate like 10mbit or 512kbit" };
+
+/** A problem in words, for the `tc` at path `at` in the topology: where, the value, the form it takes. */
+export function tcProblemText(at: string, p: TcProblem): string {
+  return `${at}.${p.field}: \`${p.value}\` isn't ${EXPECTED[p.field]}; the drawing leaves it out`;
+}
+
+/** The conditions a field edit leaves: a positive number, or the field cleared (none when all are). */
+export function withCondition(value: LinkConditions | undefined, key: keyof LinkConditions, raw: string): LinkConditions | undefined {
+  const n = raw === "" ? undefined : Number(raw);
+  const next = { ...value, [key]: n !== undefined && Number.isFinite(n) && n > 0 ? n : undefined };
+  // Every field it has, even one a stored lab carries that the editor doesn't know.
+  return Object.values(next as Record<string, number | undefined>).some((v) => v !== undefined) ? next : undefined;
+}