@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/diagrams/LogicCircuitLayout.js

@@ -0,0 +1,600 @@
+import { DiagramText } from "./DiagramText.js";
+import { LogicGateSymbol } from "./LogicGateSymbol.js";
+import { LogicGateKind, LogicLayering, LogicState } from "./logicEnums.js";
+// src/charts/diagrams/LogicCircuitLayout.ts
+var GAP = 10;
+var TERMINAL = 22;
+var THROUGH = 12;
+var MAX_SCALE = 1.25;
+var MIN_CHANNEL = 10;
+/** Below this a gate is too small to read, so shrinking stops and the finished drawing is scaled to fit instead. */
+var MIN_SCALE = .2;
+var LABEL = 11;
+var NARROW = 6.2 / LABEL;
+var LABEL_GAP = 5;
+var STUB = 10;
+var MAX_STRETCH = 1.6;
+var STRAIGHTEN = 3;
+var JOG = 16;
+/** Trunks are at least this far apart, so a junction dot never touches a neighbouring wire. */
+var TRACK = 6;
+var SWEEPS = 8;
+var NUDGES = 6;
+var CLEAR = 5;
+var ALIGN = 3;
+var key = (x, y) => `${x},${y}`;
+/** Internal vertex and net ids start with a NUL, so no gate id can collide with them. */
+var through = (net, way, column) => `\0${net}${way}${column}`;
+var floating = (node, pin) => `\0floating:${node}:${pin}`;
+var fix = (value) => +value.toFixed(2);
+var mean = (values) => values.reduce((sum, value) => sum + value, 0) / values.length;
+/**
+* Layered drawing of a netlist after Sugiyama, Tagawa and Toda (1981): feedback edges are found by
+* depth-first search and routed backwards, gates take the longest-path layer (or its as-late-as-
+* possible mirror), long wires get a through-vertex in each layer they cross, and barycentre sweeps
+* reduce crossings. Wires between layers are routed as a channel with left-edge track assignment
+* (Hashimoto and Stevens, 1971), one vertical trunk per net, so a net's branches share copper.
+*/
+var LogicCircuitLayout = class LogicCircuitLayout {
+	gates = [];
+	terminals = [];
+	nets = [];
+	junctions = [];
+	stateMarks = [];
+	scale = 1;
+	/** Transform that fits the drawing to the plot. It is the identity unless the circuit is too long or dense for the plot at the smallest scale. */
+	view = {
+		x: 0,
+		y: 0,
+		scale: 1
+	};
+	#columns = [];
+	#vertices = /* @__PURE__ */ new Map();
+	#nets = /* @__PURE__ */ new Map();
+	#places = /* @__PURE__ */ new Map();
+	#circuit;
+	#size;
+	#style;
+	constructor(circuit, size, style, layering) {
+		this.#circuit = circuit;
+		this.#size = size;
+		this.#style = style;
+		if (!circuit.nodes.size) return;
+		this.#assignLayers(layering);
+		this.#buildVertices();
+		this.#order();
+		this.#draw();
+	}
+	/** The layer of each node. Edges that close a cycle are left out, so feedback does not stretch the layering. */
+	#assignLayers(layering) {
+		const { nodes } = this.#circuit;
+		const drivenBy = /* @__PURE__ */ new Map();
+		const finished = [];
+		const active = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set();
+		const loads = /* @__PURE__ */ new Map();
+		for (const node of nodes.values()) for (const id of node.inputs) if (id !== null) loads.set(id, [...loads.get(id) ?? [], node.id]);
+		const visit = (id) => {
+			seen.add(id);
+			active.add(id);
+			for (const load of loads.get(id) ?? []) {
+				if (active.has(load)) continue;
+				drivenBy.set(load, [...drivenBy.get(load) ?? [], id]);
+				if (!seen.has(load)) visit(load);
+			}
+			active.delete(id);
+			finished.push(id);
+		};
+		const all = [...nodes.values()];
+		for (const node of all) if (node.kind === LogicGateKind.Input) visit(node.id);
+		for (const node of all) if (!seen.has(node.id)) visit(node.id);
+		const isGate = (id) => !this.#isTerminal(nodes.get(id));
+		const order = finished.slice().reverse();
+		for (const id of order) if (nodes.get(id).kind === LogicGateKind.Input) this.#places.set(id, 0);
+		for (const id of order) {
+			if (!isGate(id)) continue;
+			this.#places.set(id, Math.max(0, ...(drivenBy.get(id) ?? []).map((driver) => this.#places.get(driver) ?? 0)) + 1);
+		}
+		const last = Math.max(0, ...this.#places.values());
+		if (layering === LogicLayering.Outputs) {
+			const forward = /* @__PURE__ */ new Map();
+			for (const [to, from] of drivenBy) for (const id of from) forward.set(id, [...forward.get(id) ?? [], to]);
+			for (const id of finished) {
+				if (!isGate(id)) continue;
+				const later = (forward.get(id) ?? []).filter(isGate).map((load) => this.#places.get(load) - 1);
+				this.#places.set(id, Math.min(last, ...later));
+			}
+		}
+		for (const node of all) if (node.kind === LogicGateKind.Output) this.#places.set(node.id, last + 1);
+		for (let column = 0; column <= last + 1; column++) this.#columns.push([]);
+	}
+	#isTerminal(node) {
+		return node.kind === LogicGateKind.Input || node.kind === LogicGateKind.Output;
+	}
+	#buildVertices() {
+		const { nodes } = this.#circuit;
+		const vertices = this.#vertices;
+		const add = (id, column, height, fields) => {
+			const vertex = {
+				key: id,
+				column,
+				height,
+				y: 0,
+				previous: [],
+				next: [],
+				...fields
+			};
+			vertices.set(id, vertex);
+			this.#columns[column].push(vertex);
+			return vertex;
+		};
+		for (const node of nodes.values()) {
+			const height = this.#isTerminal(node) ? TERMINAL : LogicGateSymbol.height(node.inputs.length);
+			add(node.id, this.#places.get(node.id), height, { node });
+		}
+		const link = (from, to) => {
+			from.next.push(to);
+			to.previous.push(from);
+		};
+		for (const node of nodes.values()) node.inputs.forEach((id, pin) => {
+			const netId = id ?? floating(node.id, pin);
+			const driver = id === null ? null : nodes.get(id);
+			const net = this.#nets.get(netId) ?? {
+				id: netId,
+				driver,
+				sinks: [],
+				column: driver ? this.#places.get(driver.id) : -1
+			};
+			net.sinks.push(node);
+			this.#nets.set(netId, net);
+		});
+		for (const node of nodes.values()) if (node.kind !== LogicGateKind.Output && !this.#nets.has(node.id)) this.#nets.set(node.id, {
+			id: node.id,
+			driver: node,
+			sinks: [],
+			column: this.#places.get(node.id)
+		});
+		for (const net of this.#nets.values()) {
+			if (!net.driver) continue;
+			const home = vertices.get(net.driver.id);
+			const columns = net.sinks.map((sink) => this.#places.get(sink.id));
+			const far = Math.max(net.column, ...columns);
+			const ahead = /* @__PURE__ */ new Map([[net.column, home]]);
+			for (let column = net.column + 1; column < far; column++) {
+				const vertex = add(through(net.id, ">", column), column, THROUGH, { net });
+				link(ahead.get(column - 1), vertex);
+				ahead.set(column, vertex);
+			}
+			let behind = null;
+			const returning = columns.filter((column) => column <= net.column);
+			for (let column = Math.min(...returning); returning.length && column <= net.column; column++) {
+				const vertex = add(through(net.id, "<", column), column, THROUGH, { net });
+				if (behind) link(behind, vertex);
+				behind = vertex;
+			}
+			for (const sink of net.sinks) {
+				const column = this.#places.get(sink.id);
+				if (column > net.column) link(ahead.get(column - 1), vertices.get(sink.id));
+			}
+		}
+	}
+	/** Barycentre sweeps, keeping the arrangement with the fewest crossings. */
+	#order() {
+		const columns = this.#columns;
+		const position = /* @__PURE__ */ new Map();
+		const index = () => {
+			for (const column of columns) column.forEach((vertex, i) => position.set(vertex, i));
+		};
+		const crossings = () => {
+			index();
+			let total = 0;
+			for (let c = 0; c + 1 < columns.length; c++) {
+				const edges = columns[c].flatMap((vertex) => vertex.next.map((next) => [position.get(vertex), position.get(next)]));
+				for (let i = 0; i < edges.length; i++) for (let j = i + 1; j < edges.length; j++) if ((edges[i][0] - edges[j][0]) * (edges[i][1] - edges[j][1]) < 0) total++;
+			}
+			return total;
+		};
+		const sortBy = (column, side) => {
+			const weight = new Map(column.map((vertex, i) => [vertex, vertex[side].length ? mean(vertex[side].map((other) => position.get(other))) : i]));
+			column.sort((a, b) => weight.get(a) - weight.get(b));
+			column.forEach((vertex, i) => position.set(vertex, i));
+		};
+		let best = columns.map((column) => column.slice()), fewest = crossings();
+		for (let sweep = 0; sweep < SWEEPS && fewest; sweep++) {
+			index();
+			for (let c = 1; c < columns.length; c++) sortBy(columns[c], "previous");
+			for (let c = columns.length - 2; c >= 0; c--) sortBy(columns[c], "next");
+			const count = crossings();
+			if (count < fewest) {
+				fewest = count;
+				best = columns.map((column) => column.slice());
+			}
+		}
+		best.forEach((column, c) => {
+			columns[c] = column;
+		});
+	}
+	#fitScale() {
+		const tallest = Math.max(...this.#columns.map((column) => column.reduce((sum, vertex) => sum + vertex.height + GAP, 0)));
+		return Math.min(MAX_SCALE, this.#size.height / Math.max(1, tallest));
+	}
+	#place(scale) {
+		const { height } = this.#size;
+		const columns = this.#columns;
+		const settle = (column, want) => {
+			column.forEach((vertex, i) => {
+				const above = column[i - 1];
+				const least = above ? above.y + ((above.height + vertex.height) / 2 + GAP) * scale : vertex.height / 2 * scale;
+				vertex.y = Math.max(want(vertex), least);
+			});
+			for (let i = column.length - 1; i >= 0; i--) {
+				const vertex = column[i], below = column[i + 1];
+				vertex.y = Math.min(vertex.y, below ? below.y - ((below.height + vertex.height) / 2 + GAP) * scale : height - vertex.height / 2 * scale);
+			}
+		};
+		for (const column of columns) {
+			let at = (height - column.reduce((sum, vertex) => sum + (vertex.height + GAP) * scale, -10 * scale)) / 2;
+			for (const vertex of column) {
+				vertex.y = at + vertex.height / 2 * scale;
+				at += (vertex.height + GAP) * scale;
+			}
+		}
+		const toward = (others, vertex) => others.length ? mean(others.map((other) => other.y)) : vertex.y;
+		for (let round = 0; round < NUDGES; round++) {
+			for (let c = 1; c < columns.length; c++) settle(columns[c], (vertex) => toward(vertex.previous, vertex));
+			for (let c = columns.length - 2; c >= 0; c--) settle(columns[c], (vertex) => toward(vertex.next, vertex));
+		}
+		for (const column of columns) settle(column, (vertex) => toward([...vertex.previous, ...vertex.next], vertex));
+		this.#fillHeight(scale);
+	}
+	/** The sweeps let columns drift together, so spread what they left about the middle of the plot. */
+	#fillHeight(scale) {
+		const { height } = this.#size;
+		const all = this.#columns.flat();
+		const top = Math.min(...all.map((vertex) => vertex.y - vertex.height / 2 * scale));
+		const bottom = Math.max(...all.map((vertex) => vertex.y + vertex.height / 2 * scale));
+		const stretch = Math.min(MAX_STRETCH, height / Math.max(1, bottom - top));
+		const middle = (top + bottom) / 2;
+		for (const vertex of all) vertex.y = fix(height / 2 + (vertex.y - middle) * stretch);
+	}
+	/** Removes small jogs from point-to-point wires by sliding the end that is free to move, where its column has room. */
+	#straighten(scale, widths) {
+		const free = (vertex) => !vertex.node || this.#isTerminal(vertex.node) || vertex.node.inputs.length === 1;
+		const slide = (vertex, y) => {
+			const column = this.#columns[vertex.column], i = column.indexOf(vertex);
+			const clear = (other) => !other || Math.abs(other.y - y) >= ((other.height + vertex.height) / 2 + GAP) * scale;
+			const inside = y >= vertex.height / 2 * scale && y <= this.#size.height - vertex.height / 2 * scale;
+			if (!clear(column[i - 1]) || !clear(column[i + 1]) || !inside) return false;
+			vertex.y = y;
+			return true;
+		};
+		for (let round = 0; round < STRAIGHTEN; round++) for (const channel of this.#pins(scale, widths)) for (const pin of channel.left) {
+			const across = channel.right.filter((other) => other.net === pin.net);
+			if (channel.left.filter((other) => other.net === pin.net).length !== 1 || across.length !== 1) continue;
+			const jog = across[0].y - pin.y;
+			if (!jog || Math.abs(jog) > JOG * scale) continue;
+			if (!(free(pin.vertex) && slide(pin.vertex, fix(pin.vertex.y + jog))) && free(across[0].vertex)) slide(across[0].vertex, fix(across[0].vertex.y - jog));
+		}
+	}
+	/** Inputs of a gate are interchangeable, so wires take pins in the order they arrive, which avoids a crossing at the gate. */
+	#wireOrder(vertex) {
+		const node = vertex.node, place = this.#places.get(node.id);
+		const height = (id) => {
+			if (id === null) return vertex.y;
+			const near = this.#nets.get(id).column < place ? through(id, ">", place - 1) : through(id, "<", place);
+			return (this.#vertices.get(near) ?? this.#vertices.get(id))?.y ?? vertex.y;
+		};
+		return node.inputs.map((id, pin) => ({
+			net: this.#nets.get(id ?? floating(node.id, pin)),
+			y: height(id)
+		})).sort((a, b) => a.y - b.y).map((entry) => entry.net);
+	}
+	/** Largest scale at which the channels hold their tracks. Lowers it step by step; past `MIN_SCALE` the channels keep their room and `view` shrinks the result. */
+	#draw() {
+		let scale = this.#fitScale();
+		const room = this.#labelRoom();
+		for (;;) {
+			const widths = this.#columns.map((column, c) => this.#columnWidth(column, c, scale));
+			const spare = this.#size.width - room.left - room.right - widths.reduce((sum, width) => sum + width, 0);
+			this.#place(scale);
+			this.#straighten(scale, widths);
+			const channels = this.#pins(scale, widths);
+			for (const channel of channels) this.#assignTracks(channel);
+			const need = channels.reduce((sum, channel) => sum + Math.max(MIN_CHANNEL, (channel.tracks + 1) * TRACK), 0);
+			if (spare >= need || scale * .84 < MIN_SCALE) {
+				this.scale = scale;
+				this.#emit(channels, scale, widths, room, Math.max(need, spare));
+				return;
+			}
+			scale *= .84;
+		}
+	}
+	#labelRoom() {
+		const widest = (kind) => {
+			const lengths = [...this.#circuit.nodes.values()].filter((node) => node.kind === kind).map((node) => DiagramText.width(node.label, LABEL, NARROW));
+			return lengths.length ? Math.min(this.#size.width * .2, Math.ceil(lengths.reduce((most, length) => Math.max(most, length), 0)) + LABEL_GAP) : 0;
+		};
+		return {
+			left: widest(LogicGateKind.Input),
+			right: widest(LogicGateKind.Output)
+		};
+	}
+	#chip(scale) {
+		return Math.min(18, Math.max(8, 16 * scale));
+	}
+	#columnWidth(column, c, scale) {
+		if (!column.some((vertex) => vertex.node)) return 0;
+		return c === 0 || c === this.#columns.length - 1 ? this.#chip(scale) : LogicGateSymbol.width * scale;
+	}
+	/** Every pin on either side of each channel. Columns are placed later, so x here is relative to the column's left edge. */
+	#pins(scale, widths) {
+		const channels = this.#columns.slice(1).map(() => ({
+			left: [],
+			right: [],
+			routes: [],
+			tracks: 0
+		}));
+		this.#columns.forEach((column, c) => {
+			for (const vertex of column) {
+				const right = channels[c], left = channels[c - 1], width = widths[c];
+				if (vertex.net) {
+					right?.left.push({
+						x: width,
+						y: vertex.y,
+						net: vertex.net,
+						vertex
+					});
+					left?.right.push({
+						x: 0,
+						y: vertex.y,
+						net: vertex.net,
+						vertex
+					});
+					continue;
+				}
+				const node = vertex.node;
+				if (node.kind !== LogicGateKind.Output) right?.left.push({
+					x: width,
+					y: vertex.y,
+					net: this.#nets.get(node.id),
+					vertex
+				});
+				if (node.kind === LogicGateKind.Input) continue;
+				const wires = this.#wireOrder(vertex);
+				if (node.kind === LogicGateKind.Output) {
+					if (wires[0]) left?.right.push({
+						x: 0,
+						y: vertex.y,
+						net: wires[0],
+						vertex
+					});
+					continue;
+				}
+				const { pins } = LogicGateSymbol.shape(node.kind, node.inputs.length, this.#style, scale);
+				wires.forEach((net, i) => left?.right.push({
+					x: pins[i].x,
+					y: fix(vertex.y + pins[i].y),
+					net,
+					vertex
+				}));
+			}
+		});
+		return channels;
+	}
+	#assignTracks(channel) {
+		const byNet = /* @__PURE__ */ new Map();
+		const entry = (net) => {
+			let route = byNet.get(net);
+			if (!route) byNet.set(net, route = {
+				net,
+				left: [],
+				right: [],
+				low: Infinity,
+				high: -Infinity,
+				track: -1
+			});
+			return route;
+		};
+		for (const pin of channel.left) entry(pin.net).left.push(pin);
+		for (const pin of channel.right) entry(pin.net).right.push(pin);
+		const routed = [...byNet.values()].filter((route) => {
+			const ys = [...route.left, ...route.right].map((pin) => pin.y);
+			route.low = Math.min(...ys);
+			route.high = Math.max(...ys);
+			return ys.length > 1 && route.high > route.low;
+		});
+		channel.routes = [...byNet.values()];
+		const side = (route, pins) => mean((pins.length ? pins : [...route.left, ...route.right]).map((pin) => pin.y));
+		const falling = (route) => side(route, route.right) >= side(route, route.left);
+		const rank = (route) => falling(route) ? -side(route, route.left) : 1e6 + side(route, route.left);
+		routed.sort((a, b) => rank(a) - rank(b));
+		const shares = (a, b) => a.some((one) => b.some((two) => Math.abs(one.y - two.y) < ALIGN));
+		const waiting = new Set(routed);
+		const placed = [];
+		const mustFollow = (route, other) => other === route.after || shares(other.left, route.right);
+		const taken = [...channel.left, ...channel.right].map((pin) => pin.y);
+		while (waiting.size) {
+			const list = [...waiting];
+			const route = list.find((candidate) => !list.some((other) => other !== candidate && mustFollow(candidate, other)));
+			if (!route) {
+				const tail = LogicCircuitLayout.#dogleg(list[0], taken, this.#size.height);
+				taken.push(tail.bend);
+				channel.routes.push(tail);
+				waiting.add(tail);
+				continue;
+			}
+			let track = 1 + Math.max(-1, ...placed.filter((other) => mustFollow(route, other)).map((other) => other.track));
+			while (placed.some((other) => other.track === track && !(route.high + CLEAR < other.low || other.high + CLEAR < route.low))) track++;
+			route.track = track;
+			channel.tracks = Math.max(channel.tracks, track + 1);
+			placed.push(route);
+			waiting.delete(route);
+		}
+	}
+	/**
+	* Two nets can each block the other: A's left stub lines up with B's right stub and the reverse,
+	* so no order of trunks works. Cuts `route` in two across a clear row and returns the right half.
+	*/
+	static #dogleg(route, taken, height) {
+		const rows = [...taken].sort((a, b) => a - b);
+		const middle = (route.low + route.high) / 2;
+		const clear = rows.slice(1).map((row, i) => (row + rows[i]) / 2).filter((row, i) => rows[i + 1] - rows[i] >= 6);
+		const above = rows[0] - 6, below = rows.at(-1) + 6;
+		const bend = fix(clear.sort((a, b) => Math.abs(a - middle) - Math.abs(b - middle))[0] ?? (above >= 0 ? above : below <= height ? below : middle));
+		const tail = {
+			...route,
+			left: [],
+			bend,
+			after: route,
+			low: Math.min(bend, ...route.right.map((pin) => pin.y)),
+			high: Math.max(bend, ...route.right.map((pin) => pin.y))
+		};
+		route.right = [];
+		route.bend = bend;
+		route.low = Math.min(bend, ...route.left.map((pin) => pin.y));
+		route.high = Math.max(bend, ...route.left.map((pin) => pin.y));
+		return tail;
+	}
+	#emit(channels, scale, widths, room, spare) {
+		const weight = channels.reduce((sum, channel) => sum + channel.tracks + 1, 0);
+		const gaps = channels.map((channel) => spare * (channel.tracks + 1) / weight);
+		const starts = [];
+		let at = room.left;
+		this.#columns.forEach((_, c) => {
+			starts.push(at);
+			at += widths[c] + (gaps[c] ?? 0);
+		});
+		const segments = /* @__PURE__ */ new Map();
+		const add = (net, x1, y1, x2, y2) => {
+			if (x1 === x2 && y1 === y2) return;
+			const list = segments.get(net.id) ?? [];
+			list.push({
+				x1: fix(x1),
+				y1: fix(y1),
+				x2: fix(x2),
+				y2: fix(y2)
+			});
+			segments.set(net.id, list);
+		};
+		channels.forEach((channel, c) => {
+			const start = starts[c], inner = start + widths[c], next = starts[c + 1], gap = gaps[c];
+			const stub = Math.min(STUB, gap * .4);
+			const trunk = (route) => inner + (route.track + 1) * gap / (channel.tracks + 1);
+			/** A lone stub stops short of a trunk whose wire runs the other way along the same row. */
+			const stops = (y, side) => channel.routes.filter((route) => route.track >= 0 && route[side].some((pin) => Math.abs(pin.y - y) < ALIGN)).map(trunk);
+			for (const route of channel.routes) {
+				const left = route.left.map((pin) => start + pin.x), right = route.right.map((pin) => next + pin.x);
+				if (route.bend === void 0 && route.left.length + route.right.length === 1) {
+					const single = route.left[0] ?? route.right[0];
+					if (route.left.length) add(route.net, left[0], single.y, Math.min(left[0] + stub, ...stops(single.y, "right").map((x) => x - ALIGN)), single.y);
+					else add(route.net, Math.max(right[0] - stub, ...stops(single.y, "left").map((x) => x + ALIGN)), single.y, right[0], single.y);
+					continue;
+				}
+				if (route.track < 0) {
+					add(route.net, left[0], route.low, right[0], route.low);
+					continue;
+				}
+				const x = trunk(route);
+				route.left.forEach((pin, i) => add(route.net, left[i], pin.y, x, pin.y));
+				route.right.forEach((pin, i) => add(route.net, x, pin.y, right[i], pin.y));
+				add(route.net, x, route.low, x, route.high);
+				if (route.after) add(route.net, trunk(route.after), route.bend, x, route.bend);
+			}
+		});
+		const chip = this.#chip(scale);
+		this.#columns.forEach((column, c) => {
+			for (const vertex of column) {
+				const x = starts[c], node = vertex.node;
+				if (vertex.net) {
+					add(vertex.net, x, vertex.y, x + widths[c], vertex.y);
+					continue;
+				}
+				if (this.#isTerminal(node)) {
+					this.terminals.push({
+						node,
+						x: fix(x + chip / 2),
+						y: vertex.y,
+						size: chip,
+						text: this.#clip(node.label, node.kind === LogicGateKind.Input ? room.left : room.right)
+					});
+					continue;
+				}
+				this.gates.push({
+					node,
+					x: fix(x),
+					y: vertex.y,
+					shape: LogicGateSymbol.shape(node.kind, node.inputs.length, this.#style, scale)
+				});
+				if (segments.has(node.id)) this.stateMarks.push({
+					key: node.id,
+					x: fix(x + widths[c] + 3),
+					y: vertex.y,
+					state: node.state
+				});
+			}
+		});
+		this.#fit(segments, at + room.right, scale);
+		for (const net of this.#nets.values()) {
+			const list = segments.get(net.id) ?? [];
+			if (!list.length) continue;
+			const state = net.driver?.state ?? LogicState.Unknown;
+			this.nets.push({
+				id: net.id,
+				state,
+				driver: net.driver,
+				fanout: net.sinks.length,
+				segments: list,
+				path: list.map((s) => `M${s.x1},${s.y1}L${s.x2},${s.y2}`).join("")
+			});
+			for (const point of LogicCircuitLayout.junctions(list)) this.junctions.push({
+				key: `${net.id}@${key(point.x, point.y)}`,
+				...point,
+				state
+			});
+		}
+	}
+	/** Everything is routed by now, so a drawing wider or taller than the plot can be scaled whole. */
+	#fit(segments, right, scale) {
+		const { width, height } = this.#size;
+		let left = 0, top = 0, wide = Math.max(width, right), low = height;
+		const take = (x1, y1, x2, y2) => {
+			left = Math.min(left, x1);
+			wide = Math.max(wide, x2);
+			top = Math.min(top, y1);
+			low = Math.max(low, y2);
+		};
+		for (const list of segments.values()) for (const s of list) take(Math.min(s.x1, s.x2), Math.min(s.y1, s.y2), Math.max(s.x1, s.x2), Math.max(s.y1, s.y2));
+		for (const gate of this.gates) take(gate.x, gate.y - gate.shape.height / 2, gate.x + gate.shape.width, gate.y + gate.shape.height / 2);
+		const chip = this.#chip(scale) / 2;
+		for (const terminal of this.terminals) take(terminal.x - chip, terminal.y - chip, terminal.x + chip, terminal.y + chip);
+		const ratio = Math.min(1, width / (wide - left), height / (low - top));
+		this.view = {
+			x: fix((width - (wide - left) * ratio) / 2 - left * ratio),
+			y: fix((height - (low - top) * ratio) / 2 - top * ratio),
+			scale: ratio
+		};
+	}
+	#clip(label, room) {
+		return DiagramText.fit(label, room - LABEL_GAP, LABEL, NARROW);
+	}
+	/** Points where one net's copper leaves in three or more directions: these are the connections a dot must mark. */
+	static junctions(segments) {
+		const points = /* @__PURE__ */ new Map();
+		for (const s of segments) for (const [x, y] of [[s.x1, s.y1], [s.x2, s.y2]]) points.set(key(x, y), {
+			x,
+			y
+		});
+		return [...points.values()].filter(({ x, y }) => {
+			const ways = /* @__PURE__ */ new Set();
+			for (const s of segments) {
+				const [x1, x2] = [Math.min(s.x1, s.x2), Math.max(s.x1, s.x2)], [y1, y2] = [Math.min(s.y1, s.y2), Math.max(s.y1, s.y2)];
+				if (x < x1 || x > x2 || y < y1 || y > y2) continue;
+				if (x > x1) ways.add("west");
+				if (x < x2) ways.add("east");
+				if (y > y1) ways.add("north");
+				if (y < y2) ways.add("south");
+			}
+			return ways.size >= 3;
+		});
+	}
+};
+export { LogicCircuitLayout };

package/dist/charts/diagrams/LogicCircuitSamples.js

@@ -0,0 +1,66 @@
+// src/charts/diagrams/LogicCircuitSamples.ts
+var WIRES = [
+	["A", "U1"],
+	["B", "U1"],
+	["B", "U2"],
+	["C", "U2"],
+	["C", "U3"],
+	["A", "U4"],
+	["U1", "U5"],
+	["U2", "U5"],
+	["U2", "U6"],
+	["U3", "U6"],
+	["U5", "U7"],
+	["U6", "U7"],
+	["U6", "U8"],
+	["U4", "U8"],
+	["U7", "Y"],
+	["U8", "Z"]
+];
+/** Synthetic netlists for samples: invented for illustration, not taken from a real design. */
+var LogicCircuitSamples = class {
+	/** A made-up three-input circuit using every primitive once. Bits of the seed set the inputs. */
+	static everyGate(seed) {
+		const inputs = [
+			"A",
+			"B",
+			"C"
+		].map((id, bit) => ({
+			id,
+			type: "input",
+			value: seed >> bit & 1
+		}));
+		const gates = [
+			"nand",
+			"nor",
+			"not",
+			"buffer",
+			"xor",
+			"xnor",
+			"and",
+			"or"
+		].map((type, i) => ({
+			id: `U${i + 1}`,
+			type
+		}));
+		return {
+			gates: [
+				...inputs,
+				...gates,
+				{
+					id: "Y",
+					type: "output"
+				},
+				{
+					id: "Z",
+					type: "output"
+				}
+			],
+			wires: WIRES.map(([from, to]) => ({
+				from,
+				to
+			}))
+		};
+	}
+};
+export { LogicCircuitSamples };