@classytic/labs 0.1.0 → 0.3.0

package/dist/networking/VpnScene.mjs

@@ -0,0 +1,193 @@
+'use client';
+
+import { Figure, HUE, STROKE, alpha, tint } from "../kit/figure/figure.mjs";
+import { FigText } from "../kit/figure/text.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/networking/VpnScene.tsx
+const W = 680;
+const H = 288;
+const CELL = {
+	y: 52,
+	h: 44,
+	gap: 14
+};
+const NODE = {
+	w: 108,
+	h: 34,
+	y: 186
+};
+const SLEEVE = {
+	y: 168,
+	h: 74
+};
+const EYE_Y = 158;
+/**
+* The colour states a fact, not a preference: amber means this watcher is reading it, green means
+* they are not. Two arbitrary hues would have made the reader look each cell up; a pair everyone
+* already knows lets the whole row be taken in at once, which is what the four-way comparison in
+* this lab depends on.
+*/
+const OPEN_INK = HUE.warn;
+const LOCKED_INK = HUE.good;
+function VpnScene({ sighting, chain, tunnelEndsAt, selected, onSelect, label }) {
+	const cells = [
+		{
+			key: "from",
+			title: "who is sending",
+			field: sighting.from
+		},
+		{
+			key: "to",
+			title: "where it is going",
+			field: sighting.to
+		},
+		{
+			key: "contents",
+			title: "what it says",
+			field: sighting.contents
+		}
+	];
+	const cellW = (600 - CELL.gap * 2) / 3;
+	const nodeX = (index) => 40 + 600 / chain.length * (index + .5) - NODE.w / 2;
+	return /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [W, H],
+		domain: "math",
+		label,
+		children: [
+			/* @__PURE__ */ jsxs(FigText, {
+				x: 40,
+				y: 38,
+				size: "note",
+				tone: "soft",
+				children: [sighting.observer.name, " can see"]
+			}),
+			cells.map((cell, index) => {
+				const x = 40 + index * (cellW + CELL.gap);
+				const ink = cell.field.hidden ? LOCKED_INK : OPEN_INK;
+				return /* @__PURE__ */ jsxs("g", { children: [
+					/* @__PURE__ */ jsx("rect", {
+						x,
+						y: CELL.y,
+						width: cellW,
+						height: CELL.h,
+						rx: 5,
+						fill: cell.field.hidden ? tint(ink, 78) : tint(ink, 66),
+						stroke: alpha(ink, cell.field.hidden ? 45 : 80),
+						strokeWidth: STROKE.line,
+						strokeDasharray: cell.field.hidden ? "5 3" : void 0
+					}),
+					cell.field.hidden && /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("rect", {
+						x: x + 12,
+						y: CELL.y + 19,
+						width: 13,
+						height: 11,
+						rx: 2,
+						fill: alpha(ink, 85)
+					}), /* @__PURE__ */ jsx("path", {
+						d: `M${x + 15},${CELL.y + 19} v-4 a3.5,3.5 0 0 1 7,0 v4`,
+						fill: "none",
+						stroke: alpha(ink, 85),
+						strokeWidth: STROKE.line
+					})] }),
+					/* @__PURE__ */ jsx(FigText, {
+						x: x + (cell.field.hidden ? 34 : 12),
+						y: CELL.y + 27,
+						size: "note",
+						tone: cell.field.hidden ? "soft" : "ink",
+						halo: false,
+						children: cell.field.value
+					}),
+					/* @__PURE__ */ jsx(FigText, {
+						x: x + 12,
+						y: CELL.y + CELL.h + 16,
+						size: "note",
+						tone: "soft",
+						children: cell.title
+					})
+				] }, cell.key);
+			}),
+			tunnelEndsAt != null && /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("rect", {
+				x: nodeX(0) - 10,
+				y: SLEEVE.y,
+				width: nodeX(tunnelEndsAt) + NODE.w + 10 - (nodeX(0) - 10),
+				height: SLEEVE.h,
+				rx: 16,
+				fill: alpha(LOCKED_INK, 8),
+				stroke: alpha(LOCKED_INK, 55),
+				strokeWidth: STROKE.line
+			}), /* @__PURE__ */ jsx(FigText, {
+				x: (nodeX(0) + nodeX(tunnelEndsAt) + NODE.w) / 2,
+				y: SLEEVE.y + SLEEVE.h + 15,
+				size: "note",
+				anchor: "middle",
+				tone: "ink",
+				children: "encrypted tunnel: the wrapping only comes off at the far end"
+			})] }),
+			chain.slice(0, -1).map((node, index) => /* @__PURE__ */ jsx("line", {
+				x1: nodeX(index) + NODE.w,
+				y1: NODE.y + NODE.h / 2,
+				x2: nodeX(index + 1),
+				y2: NODE.y + NODE.h / 2,
+				stroke: alpha(HUE.soft, 55),
+				strokeWidth: STROKE.line
+			}, `wire-${node.id}`)),
+			chain.map((node, index) => {
+				const x = nodeX(index);
+				const active = node.id === selected;
+				const ink = node.watcher ? active ? HUE[1] : HUE.soft : HUE[3];
+				return /* @__PURE__ */ jsxs("g", {
+					className: "network-scene-target",
+					"data-interactive": node.watcher && Boolean(onSelect) || void 0,
+					role: node.watcher && onSelect ? "button" : void 0,
+					tabIndex: node.watcher && onSelect ? 0 : void 0,
+					"aria-label": node.watcher ? `Watch from ${node.name}` : node.name,
+					onClick: () => node.watcher && onSelect?.(node.id),
+					onKeyDown: (event) => {
+						if (node.watcher && (event.key === "Enter" || event.key === " ")) {
+							event.preventDefault();
+							onSelect?.(node.id);
+						}
+					},
+					children: [
+						node.watcher && /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("circle", {
+							cx: x + NODE.w / 2,
+							cy: EYE_Y,
+							r: 8,
+							fill: active ? tint(HUE[1], 55) : "none",
+							stroke: active ? HUE[1] : alpha(HUE.soft, 60),
+							strokeWidth: active ? STROKE.edge : STROKE.hair
+						}), /* @__PURE__ */ jsx("circle", {
+							cx: x + NODE.w / 2,
+							cy: EYE_Y,
+							r: 2.6,
+							fill: active ? HUE[1] : alpha(HUE.soft, 70)
+						})] }),
+						/* @__PURE__ */ jsx("rect", {
+							x,
+							y: NODE.y,
+							width: NODE.w,
+							height: NODE.h,
+							rx: 5,
+							fill: tint(ink, active ? 58 : 70),
+							stroke: alpha(ink, active ? 90 : 60),
+							strokeWidth: active ? STROKE.edge : STROKE.hair
+						}),
+						/* @__PURE__ */ jsx(FigText, {
+							x: x + NODE.w / 2,
+							y: NODE.y + 22,
+							size: "note",
+							anchor: "middle",
+							tone: "ink",
+							halo: false,
+							children: node.name
+						})
+					]
+				}, node.id);
+			})
+		]
+	});
+}
+
+//#endregion
+export { VpnScene };

package/dist/networking/contract.d.mts

@@ -0,0 +1,136 @@
+import { ReactNode } from "react";
+
+//#region src/networking/contract.d.ts
+type NetworkDeviceKind = 'client' | 'server' | 'switch' | 'router' | 'access-point' | 'firewall' | 'load-balancer' | 'dns' | 'broker' | 'cloud';
+interface NetworkInterface {
+  id: string;
+  label?: string;
+  mac?: string;
+  addresses?: string[];
+}
+interface NetworkDevice {
+  id: string;
+  kind: NetworkDeviceKind;
+  label: string;
+  at: {
+    x: number;
+    y: number;
+  };
+  interfaces: NetworkInterface[];
+  services?: {
+    kind: 'dhcp' | 'dns' | 'http' | 'https' | 'ftp' | 'websocket';
+    port?: number;
+    label?: string;
+  }[];
+}
+interface NetworkEndpoint {
+  deviceId: string;
+  interfaceId: string;
+}
+interface NetworkLink {
+  id: string;
+  a: NetworkEndpoint;
+  b: NetworkEndpoint;
+  label?: string;
+  cost?: number;
+  latencyMs?: number;
+  bandwidthMbps?: number;
+  loss?: number;
+  mtu?: number;
+  state?: 'up' | 'down';
+}
+interface NetworkRoute {
+  id: string;
+  deviceId: string;
+  prefix: string;
+  via?: string;
+  interfaceId: string;
+  metric?: number;
+}
+interface NetworkDoc {
+  schemaVersion: 1;
+  type: 'network';
+  devices: NetworkDevice[];
+  links: NetworkLink[];
+  routes?: NetworkRoute[];
+  title?: string;
+}
+type PacketLayerKind = 'application' | 'transport' | 'network' | 'data-link' | 'physical';
+interface PacketLayer {
+  kind: PacketLayerKind;
+  protocol: string;
+  summary: string;
+  fields?: Record<string, string | number>;
+}
+interface NetworkPacket {
+  id: string;
+  from: string;
+  to: string;
+  bytes: number;
+  layers: PacketLayer[];
+}
+type NetworkEvent = {
+  type: 'packet-created';
+  at: string;
+  packet: NetworkPacket;
+  message: string;
+} | {
+  type: 'arp-requested';
+  at: string;
+  target: string;
+  message: string;
+} | {
+  type: 'arp-resolved';
+  at: string;
+  target: string;
+  message: string;
+} | {
+  type: 'route-selected';
+  at: string;
+  next: string;
+  prefix?: string;
+  message: string;
+} | {
+  type: 'frame-sent';
+  at: string;
+  linkId: string;
+  next: string;
+  packet: NetworkPacket;
+  message: string;
+} | {
+  type: 'frame-received';
+  at: string;
+  linkId: string;
+  from: string;
+  packet: NetworkPacket;
+  message: string;
+} | {
+  type: 'packet-dropped';
+  at: string;
+  reason: 'unreachable' | 'link-down' | 'loss' | 'mtu';
+  message: string;
+} | {
+  type: 'packet-delivered';
+  at: string;
+  packet: NetworkPacket;
+  message: string;
+};
+interface NetworkTrace {
+  delivered: boolean;
+  path: string[];
+  totalLatencyMs: number;
+  events: NetworkEvent[];
+}
+interface NetworkDeviceGlyphProps {
+  device: NetworkDevice;
+  active?: boolean;
+  selected?: boolean;
+  onSelect?: () => void;
+}
+interface NetworkDeviceDef {
+  kind: NetworkDeviceKind;
+  label: string;
+  render: (props: NetworkDeviceGlyphProps) => ReactNode;
+}
+//#endregion
+export { NetworkDevice, NetworkDeviceDef, NetworkDeviceKind, NetworkDoc, NetworkEndpoint, NetworkEvent, NetworkInterface, NetworkLink, NetworkPacket, NetworkRoute, NetworkTrace, PacketLayer, PacketLayerKind };

package/dist/networking/encapsulation.mjs

@@ -0,0 +1,130 @@
+//#region src/networking/encapsulation.ts
+/** Outermost last: this is the order the headers are ADDED going down the stack. */
+const HEADERS = [
+	{
+		kind: "application",
+		protocol: "HTTP",
+		bytes: 0,
+		addressing: null,
+		answers: "What is being asked for. This is the message itself, not a wrapper."
+	},
+	{
+		kind: "transport",
+		protocol: "TCP",
+		bytes: 20,
+		addressing: "port",
+		answers: "Which program on the machine, and where this piece fits in the stream."
+	},
+	{
+		kind: "network",
+		protocol: "IPv4",
+		bytes: 20,
+		addressing: "IP address",
+		answers: "Which machine, anywhere. Set once by the sender and carried the whole way."
+	},
+	{
+		kind: "data-link",
+		protocol: "Ethernet",
+		bytes: 18,
+		trailerBytes: 4,
+		addressing: "MAC address",
+		answers: "Which box on THIS wire takes it next. Replaced at every routed hop."
+	}
+];
+const OVERHEAD_BYTES = HEADERS.reduce((sum, header) => sum + header.bytes, 0);
+/** Wrap a payload in the first `depth` headers. Full depth is the frame that goes on the wire. */
+function encapsulate(payloadBytes, depth = HEADERS.length) {
+	const applied = HEADERS.slice(0, Math.max(0, Math.min(depth, HEADERS.length)));
+	const overheadBytes = applied.reduce((sum, header) => sum + header.bytes, 0);
+	const onWireBytes = payloadBytes + overheadBytes;
+	return {
+		payloadBytes,
+		headers: applied,
+		depth: applied.length,
+		onWireBytes,
+		overheadBytes,
+		overheadShare: onWireBytes === 0 ? 0 : overheadBytes / onWireBytes
+	};
+}
+/** How deep a device opens the frame before it can do its job. */
+const opensTo = (kind) => kind === "switch" ? "data-link" : kind === "router" ? "network" : "application";
+/**
+* Split a path at its layer-3 boundaries. A switch forwards a frame without terminating it, so it
+* does not start a new segment. A router does, because it builds a brand new frame for the next
+* wire. The number of segments is therefore routers + 1, however many switches are in the way.
+*/
+function segmentsOf(path) {
+	const boundaries = path.filter((node) => node.kind !== "switch");
+	const segments = [];
+	for (let index = 0; index < boundaries.length - 1; index++) {
+		const from = boundaries[index];
+		const to = boundaries[index + 1];
+		const through = path.slice(path.indexOf(from) + 1, path.indexOf(to)).filter((n) => n.kind === "switch");
+		segments.push({
+			from,
+			to,
+			fromMac: from.mac,
+			toMac: to.mac,
+			through
+		});
+	}
+	return segments;
+}
+function frameOn(segment, source, destination) {
+	const rebuilt = segment.from.kind === "router";
+	return {
+		segment,
+		mac: {
+			from: segment.fromMac,
+			to: segment.toMac
+		},
+		ip: {
+			from: source.ip ?? "",
+			to: destination.ip ?? ""
+		},
+		note: rebuilt ? `${segment.from.name} threw away the frame it received and built a new one for this wire. Same packet inside, new MAC addresses outside.` : `${segment.from.name} addresses the frame to ${segment.to.name}, the next box on this wire, not to the far end.`
+	};
+}
+/** Every frame the message travels in, end to end. */
+const journey = (path) => {
+	const source = path[0];
+	const destination = path[path.length - 1];
+	return segmentsOf(path).map((segment) => frameOn(segment, source, destination));
+};
+const DEFAULT_PATH = [
+	{
+		id: "laptop",
+		name: "Laptop",
+		kind: "host",
+		mac: "AA:01",
+		ip: "10.1.0.20"
+	},
+	{
+		id: "switch",
+		name: "Switch",
+		kind: "switch",
+		mac: "SW:00"
+	},
+	{
+		id: "r1",
+		name: "Router 1",
+		kind: "router",
+		mac: "BB:11"
+	},
+	{
+		id: "r2",
+		name: "Router 2",
+		kind: "router",
+		mac: "CC:22"
+	},
+	{
+		id: "server",
+		name: "Server",
+		kind: "host",
+		mac: "DD:33",
+		ip: "10.9.0.7"
+	}
+];
+
+//#endregion
+export { DEFAULT_PATH, HEADERS, encapsulate, journey, opensTo };

package/dist/networking/index.d.mts

@@ -0,0 +1,8 @@
+import { NetworkDevice, NetworkDeviceDef, NetworkDeviceKind, NetworkDoc, NetworkEndpoint, NetworkEvent, NetworkInterface, NetworkLink, NetworkPacket, NetworkRoute, NetworkTrace, PacketLayer, PacketLayerKind } from "./contract.mjs";
+import { cidrContains, ipv4ToInt, longestPrefixMatch, parseCidr } from "./ip.mjs";
+import { createPacket, simulatePacket } from "./simulation.mjs";
+import { COMPANY_NETWORK, HOME_NETWORK } from "./presets.mjs";
+import { NetworkScene, NetworkSceneProps } from "./NetworkScene.mjs";
+import { PacketInspector } from "./PacketInspector.mjs";
+import { PacketJourneyLab, PacketJourneyLabProps } from "../domains/networking/packet-journey/runtime.mjs";
+export { COMPANY_NETWORK, HOME_NETWORK, type NetworkDevice, type NetworkDeviceDef, type NetworkDeviceKind, type NetworkDoc, type NetworkEndpoint, type NetworkEvent, type NetworkInterface, type NetworkLink, type NetworkPacket, type NetworkRoute, NetworkScene, type NetworkSceneProps, type NetworkTrace, PacketInspector, PacketJourneyLab, type PacketJourneyLabProps, type PacketLayer, type PacketLayerKind, cidrContains, createPacket, ipv4ToInt, longestPrefixMatch, parseCidr, simulatePacket };

package/dist/networking/index.mjs

@@ -0,0 +1,8 @@
+import { cidrContains, ipv4ToInt, longestPrefixMatch, parseCidr } from "./ip.mjs";
+import { createPacket, simulatePacket } from "./simulation.mjs";
+import { COMPANY_NETWORK, HOME_NETWORK } from "./presets.mjs";
+import { NetworkScene } from "./NetworkScene.mjs";
+import { PacketInspector } from "./PacketInspector.mjs";
+import { PacketJourneyLab } from "../domains/networking/packet-journey/runtime.mjs";
+
+export { COMPANY_NETWORK, HOME_NETWORK, NetworkScene, PacketInspector, PacketJourneyLab, cidrContains, createPacket, ipv4ToInt, longestPrefixMatch, parseCidr, simulatePacket };

package/dist/networking/ip.d.mts

@@ -0,0 +1,12 @@
+import { NetworkRoute } from "./contract.mjs";
+
+//#region src/networking/ip.d.ts
+declare function ipv4ToInt(ip: string): number | undefined;
+declare function parseCidr(cidr: string): {
+  network: number;
+  prefix: number;
+} | undefined;
+declare function cidrContains(cidr: string, ip: string): boolean;
+declare function longestPrefixMatch(routes: readonly NetworkRoute[], destinationIp: string): NetworkRoute | undefined;
+//#endregion
+export { cidrContains, ipv4ToInt, longestPrefixMatch, parseCidr };

package/dist/networking/ip.mjs

@@ -0,0 +1,30 @@
+//#region src/networking/ip.ts
+function ipv4ToInt(ip) {
+	const parts = ip.split(".");
+	if (parts.length !== 4) return void 0;
+	const nums = parts.map(Number);
+	if (nums.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) return void 0;
+	return nums.reduce((acc, n) => acc * 256 + n >>> 0, 0);
+}
+function parseCidr(cidr) {
+	const [ip, rawPrefix] = cidr.split("/");
+	const value = ipv4ToInt(ip ?? "");
+	const prefix = Number(rawPrefix);
+	if (value == null || !Number.isInteger(prefix) || prefix < 0 || prefix > 32) return void 0;
+	return {
+		network: value & (prefix === 0 ? 0 : 4294967295 << 32 - prefix >>> 0),
+		prefix
+	};
+}
+function cidrContains(cidr, ip) {
+	const parsed = parseCidr(cidr);
+	const value = ipv4ToInt(ip);
+	if (!parsed || value == null) return false;
+	return (value & (parsed.prefix === 0 ? 0 : 4294967295 << 32 - parsed.prefix >>> 0)) === parsed.network;
+}
+function longestPrefixMatch(routes, destinationIp) {
+	return routes.filter((route) => cidrContains(route.prefix, destinationIp)).sort((a, b) => (parseCidr(b.prefix)?.prefix ?? -1) - (parseCidr(a.prefix)?.prefix ?? -1) || (a.metric ?? 0) - (b.metric ?? 0))[0];
+}
+
+//#endregion
+export { cidrContains, ipv4ToInt, longestPrefixMatch, parseCidr };

package/dist/networking/media.mjs

@@ -0,0 +1,183 @@
+//#region src/networking/media.ts
+/**
+* Real wire colours, so they are fixed rather than themed. A green wire is green in both themes
+* for the same reason the link LED is green: the colour IS the information, and a student matching
+* this against a cable in their hand needs it to agree.
+*/
+const WIRE_INK = {
+	"white-orange": "oklch(0.72 0.16 55)",
+	orange: "oklch(0.68 0.19 48)",
+	"white-green": "oklch(0.70 0.15 150)",
+	green: "oklch(0.58 0.17 148)",
+	"white-blue": "oklch(0.70 0.13 250)",
+	blue: "oklch(0.55 0.18 255)",
+	"white-brown": "oklch(0.62 0.07 60)",
+	brown: "oklch(0.45 0.08 55)"
+};
+/** A striped wire is the pale half of its pair. */
+const isStriped = (wire) => wire.startsWith("white-");
+const WIRE_LABEL = {
+	"white-orange": "white / orange",
+	orange: "orange",
+	"white-green": "white / green",
+	green: "green",
+	"white-blue": "white / blue",
+	blue: "blue",
+	"white-brown": "white / brown",
+	brown: "brown"
+};
+/** Pin 1 to pin 8, left to right with the clip facing away from you. */
+const PINOUTS = {
+	T568B: [
+		"white-orange",
+		"orange",
+		"white-green",
+		"blue",
+		"white-blue",
+		"green",
+		"white-brown",
+		"brown"
+	],
+	T568A: [
+		"white-green",
+		"green",
+		"white-orange",
+		"blue",
+		"white-blue",
+		"orange",
+		"white-brown",
+		"brown"
+	]
+};
+/** The four twisted pairs, by the colour they are named after. */
+const PAIRS = [
+	{
+		name: "orange",
+		wires: ["white-orange", "orange"]
+	},
+	{
+		name: "green",
+		wires: ["white-green", "green"]
+	},
+	{
+		name: "blue",
+		wires: ["white-blue", "blue"]
+	},
+	{
+		name: "brown",
+		wires: ["white-brown", "brown"]
+	}
+];
+/** Which pair a wire belongs to, 0-based, or -1 if the colour is not a pair member. */
+const pairOf = (wire) => PAIRS.findIndex((pair) => pair.wires.includes(wire));
+/** The pin positions (1-based) each pair occupies under a standard. */
+function pairPins(standard, pairName) {
+	const order = PINOUTS[standard];
+	const pair = PAIRS.find((item) => item.name === pairName);
+	if (!pair) return [];
+	return order.map((wire, index) => pair.wires.includes(wire) ? index + 1 : 0).filter((pin) => pin > 0);
+}
+/** Compare an attempt against a standard. Empty slots count as not yet placed, not as wrong. */
+function checkPinout(attempt, standard) {
+	const target = PINOUTS[standard];
+	const wrong = [];
+	let placed = 0;
+	target.forEach((wire, index) => {
+		const got = attempt[index];
+		if (!got) return;
+		placed++;
+		if (got !== wire) wrong.push(index + 1);
+	});
+	return {
+		correct: placed === 8 && wrong.length === 0,
+		wrong,
+		placed
+	};
+}
+/**
+* A cable with the same standard at both ends is straight-through; different ends make a crossover.
+* Modern gear auto-detects, which is worth saying, because it is why crossover cables have
+* essentially disappeared and why the distinction still appears in every exam.
+*/
+const cableKind = (endA, endB) => endA === endB ? "straight-through" : "crossover";
+const MEDIA = [
+	{
+		id: "copper",
+		label: "Twisted pair copper",
+		carrier: "a changing voltage along a wire",
+		maxMetres: 100,
+		typicalGbps: 1,
+		emiImmune: false,
+		broadcast: false,
+		note: "Cheap, and every device already has the socket. The 100 m limit is the reason wiring closets exist."
+	},
+	{
+		id: "fibre",
+		label: "Optical fibre",
+		carrier: "pulses of light in a glass core",
+		maxMetres: 4e4,
+		typicalGbps: 10,
+		emiImmune: true,
+		broadcast: false,
+		note: "Light carries no current, so it ignores electrical noise entirely and can cross a city."
+	},
+	{
+		id: "radio",
+		label: "Radio (Wi-Fi)",
+		carrier: "radio waves through open air",
+		maxMetres: 40,
+		typicalGbps: 1,
+		emiImmune: false,
+		broadcast: true,
+		note: "No cable at all, and the medium is shared: everyone in range competes for it and can hear it."
+	}
+];
+const SCENARIOS = [
+	{
+		id: "desk",
+		need: "A desktop to the switch in the same room",
+		metres: 15,
+		noisy: false,
+		mustMove: false,
+		best: "copper",
+		why: "Short, fixed and cheap. Copper is already on both ends and there is nothing to gain by paying for anything else."
+	},
+	{
+		id: "buildings",
+		need: "Between two buildings 800 m apart",
+		metres: 800,
+		noisy: false,
+		mustMove: false,
+		best: "fibre",
+		why: "Copper stops working at about 100 m. Distance alone rules it out before any other argument."
+	},
+	{
+		id: "factory",
+		need: "Across a factory floor beside large motors",
+		metres: 60,
+		noisy: true,
+		mustMove: false,
+		best: "fibre",
+		why: "The distance suits copper, but motors throw electrical noise into it. Light carries no current, so the interference cannot reach the signal."
+	},
+	{
+		id: "phone",
+		need: "A phone carried around a café",
+		metres: 20,
+		noisy: false,
+		mustMove: true,
+		best: "radio",
+		why: "Nothing that moves can stay plugged in. That decides it before speed or cost are even considered."
+	}
+];
+/** Is a medium usable for a scenario at all, and if not, why not. */
+function ruleOut(medium, scenario) {
+	if (scenario.mustMove && !scenario.metres) return null;
+	if (scenario.mustMove && medium.id !== "radio") return "a moving device cannot stay plugged into a cable";
+	if (scenario.metres > medium.maxMetres) return `the run is longer than ${medium.maxMetres} m`;
+	if (scenario.noisy && !medium.emiImmune) return "electrical noise from the machinery would corrupt the signal";
+	return null;
+}
+
+//#endregion
+export { MEDIA, PAIRS, PINOUTS, SCENARIOS, WIRE_INK, WIRE_LABEL, cableKind, checkPinout, isStriped, pairOf, pairPins, ruleOut };