@classytic/labs 0.1.0 → 0.2.0

package/dist/build/editor-ops.d.mts

@@ -0,0 +1,65 @@
+import { CircuitDoc, PinRef } from "./contract.mjs";
+import { Vec2 } from "@classytic/stage";
+
+//#region src/build/editor-ops.d.ts
+/** Add a part; each pin starts on its own fresh node (unconnected). The first cell's −
+ *  terminal is tied to ground so the network always has a reference. */
+declare function addPart(doc: CircuitDoc, kind: string, at: Vec2): CircuitDoc;
+declare function movePart(doc: CircuitDoc, id: string, at: Vec2): CircuitDoc;
+declare function updateProps(doc: CircuitDoc, id: string, patch: Record<string, number | string | boolean>): CircuitDoc;
+declare function rotatePart(doc: CircuitDoc, id: string): CircuitDoc;
+/**
+ * Drop junction nodes that have fewer than 2 wire connections AND their dangling wires, to a
+ * fixpoint. This is an EXPLICIT "tidy" the UI can offer; it is NOT run automatically, because a
+ * node a user just placed (or is half-way wiring) legitimately has 0 or 1 connection and must
+ * not vanish under them.
+ */
+declare function pruneJunctions(doc: CircuitDoc): CircuitDoc;
+declare function deletePart(doc: CircuitDoc, id: string): CircuitDoc;
+/** Connect two pins with a NEW wire edge (parts keep their positions). No-op for a
+ *  self-link, a duplicate of an existing wire, or an endpoint whose part/pin
+ *  doesn't exist (an invalid edge that would persist as an invisible no-op). */
+declare function connect(doc: CircuitDoc, a: PinRef, b: PinRef): CircuitDoc;
+/** Add a wire the way a user DRAWS one: it is always created (even between pins already on the
+ *  same net, e.g. a deliberately-routed redundant path) so a drawn wire never silently vanishes.
+ *  Only a self-link or an endpoint that doesn't exist is rejected. Carries optional bend points. */
+declare function addWire(doc: CircuitDoc, a: PinRef, b: PinRef, mids?: Vec2[]): CircuitDoc;
+/** Remove a wire edge. Low-level: callers that may orphan a junction wrap with pruneJunctions. */
+declare function removeWire(doc: CircuitDoc, wireId: string): CircuitDoc;
+/** Re-target ONE end of a wire to a different pin (drag-to-detach / reconnect). Rejects a move
+ *  that would make the wire a self-loop, or that points at a pin which doesn't exist. */
+declare function retargetWire(doc: CircuitDoc, wireId: string, end: 'a' | 'b', to: PinRef): CircuitDoc;
+/** Remove a wire (the editor's delete-wire action). Junctions are left in place, never
+ *  auto-removed, so nothing the user placed disappears unexpectedly. */
+declare function disconnectWire(doc: CircuitDoc, wireId: string): CircuitDoc;
+/** World position of a pin's terminal (via its PartDef), for geometry on the doc. */
+declare function terminalOf(doc: CircuitDoc, ref: PinRef): Vec2 | undefined;
+/** The full polyline a wire draws: through its bend points if it has any, else the default
+ *  Manhattan elbow. The renderer, hit-test, and tap all route through this one function. */
+declare function wirePolyline(ta: Vec2, mids: Vec2[], tb: Vec2): Vec2[];
+/** Set (or clear, when empty) a wire's bend points. */
+declare function setWireWaypoints(doc: CircuitDoc, wireId: string, mids: Vec2[]): CircuitDoc;
+/** Place a free junction (a 'node' part) at a point; returns its pin for wiring. */
+declare function addJunction(doc: CircuitDoc, at: Vec2): {
+  doc: CircuitDoc;
+  pin: PinRef;
+};
+/**
+ * Tap an existing wire at a point: drop a junction ON the wire (projected onto its route)
+ * and SPLIT the wire into two that meet there, so a new lead can branch off mid-span. The
+ * junction is a `node` part (no element), so the three wires share one net and the solver
+ * needs no special mid-wire case. Returns the junction pin to wire the new lead to.
+ */
+declare function tapWire(doc: CircuitDoc, wireId: string, at: Vec2): {
+  doc: CircuitDoc;
+  pin: PinRef;
+};
+/** Drop a part ONTO a wire: insert it in series. The wire is removed and the part's two
+ *  ends are wired to the wire's two original endpoints (a → pin0, pin1 → b). */
+declare function spliceIntoWire(doc: CircuitDoc, wireId: string, kind: string, at: Vec2): CircuitDoc;
+/** Toggle a pin's connection to ground. Grounding ties the pin's net to the reference;
+ *  toggling again gives the pin a fresh independent node (un-grounds it), so a short made
+ *  by grounding both terminals of a source can always be undone. */
+declare function setGround(doc: CircuitDoc, ref: PinRef): CircuitDoc;
+//#endregion
+export { addJunction, addPart, addWire, connect, deletePart, disconnectWire, movePart, pruneJunctions, removeWire, retargetWire, rotatePart, setGround, setWireWaypoints, spliceIntoWire, tapWire, terminalOf, updateProps, wirePolyline };

package/dist/build/editor-ops.mjs

@@ -0,0 +1,306 @@
+import { getPart } from "./registry.mjs";
+
+//#region src/build/editor-ops.ts
+const freshId = (prefix, taken) => {
+	let i = 1;
+	while (taken.has(`${prefix}${i}`)) i++;
+	return `${prefix}${i}`;
+};
+const nodeIdsOf = (doc) => new Set([...doc.nodes.map((n) => n.id), ...doc.parts.flatMap((p) => Object.values(p.pins))]);
+/** Add a part; each pin starts on its own fresh node (unconnected). The first cell's −
+*  terminal is tied to ground so the network always has a reference. */
+function addPart(doc, kind, at) {
+	const def = getPart(kind);
+	if (!def) return doc;
+	const id = freshId(kind, new Set(doc.parts.map((p) => p.id)));
+	const taken = nodeIdsOf(doc);
+	const grounded = [...taken].includes("gnd");
+	const pins = {};
+	for (const pin of def.pins) {
+		if (kind === "cell" && !grounded && pin === "b") {
+			pins[pin] = "gnd";
+			continue;
+		}
+		const nid = freshId("nd", taken);
+		taken.add(nid);
+		pins[pin] = nid;
+	}
+	const part = {
+		id,
+		kind,
+		at,
+		orient: "h",
+		props: { ...def.defaultProps },
+		pins
+	};
+	return {
+		...doc,
+		parts: [...doc.parts, part]
+	};
+}
+function movePart(doc, id, at) {
+	return {
+		...doc,
+		parts: doc.parts.map((p) => p.id === id ? {
+			...p,
+			at
+		} : p)
+	};
+}
+function updateProps(doc, id, patch) {
+	return {
+		...doc,
+		parts: doc.parts.map((p) => p.id === id ? {
+			...p,
+			props: {
+				...p.props,
+				...patch
+			}
+		} : p)
+	};
+}
+function rotatePart(doc, id) {
+	return {
+		...doc,
+		parts: doc.parts.map((p) => p.id === id ? {
+			...p,
+			orient: p.orient === "v" ? "h" : "v"
+		} : p)
+	};
+}
+/**
+* Drop junction nodes that have fewer than 2 wire connections AND their dangling wires, to a
+* fixpoint. This is an EXPLICIT "tidy" the UI can offer; it is NOT run automatically, because a
+* node a user just placed (or is half-way wiring) legitimately has 0 or 1 connection and must
+* not vanish under them.
+*/
+function pruneJunctions(doc) {
+	let parts = doc.parts;
+	let wires = doc.wires ?? [];
+	for (;;) {
+		const count = /* @__PURE__ */ new Map();
+		for (const w of wires) for (const e of [w.a, w.b]) count.set(e.partId, (count.get(e.partId) ?? 0) + 1);
+		const orphans = new Set(parts.filter((p) => p.kind === "node" && (count.get(p.id) ?? 0) < 2).map((p) => p.id));
+		if (orphans.size === 0) break;
+		parts = parts.filter((p) => !orphans.has(p.id));
+		wires = wires.filter((w) => !orphans.has(w.a.partId) && !orphans.has(w.b.partId));
+	}
+	return {
+		...doc,
+		parts,
+		wires
+	};
+}
+function deletePart(doc, id) {
+	return {
+		...doc,
+		parts: doc.parts.filter((p) => p.id !== id),
+		wires: (doc.wires ?? []).filter((w) => w.a.partId !== id && w.b.partId !== id)
+	};
+}
+const samePin = (x, y) => x.partId === y.partId && x.pin === y.pin;
+const sameWire = (a, b, x, y) => samePin(a, x) && samePin(b, y) || samePin(a, y) && samePin(b, x);
+/** True when the ref names a real part AND a pin that part's definition declares.
+*  Keeps invalid (invisible no-op) wires out of persisted, authored docs. */
+const pinExists = (doc, ref) => {
+	const part = doc.parts.find((p) => p.id === ref.partId);
+	if (!part) return false;
+	return getPart(part.kind)?.pins.includes(ref.pin) ?? false;
+};
+/** Connect two pins with a NEW wire edge (parts keep their positions). No-op for a
+*  self-link, a duplicate of an existing wire, or an endpoint whose part/pin
+*  doesn't exist (an invalid edge that would persist as an invisible no-op). */
+function connect(doc, a, b) {
+	if (samePin(a, b)) return doc;
+	if (!pinExists(doc, a) || !pinExists(doc, b)) return doc;
+	const wires = doc.wires ?? [];
+	if (wires.some((w) => sameWire(w.a, w.b, a, b))) return doc;
+	const id = freshId("w", new Set(wires.map((w) => w.id)));
+	return {
+		...doc,
+		wires: [...wires, {
+			id,
+			a,
+			b
+		}]
+	};
+}
+/** Add a wire the way a user DRAWS one: it is always created (even between pins already on the
+*  same net, e.g. a deliberately-routed redundant path) so a drawn wire never silently vanishes.
+*  Only a self-link or an endpoint that doesn't exist is rejected. Carries optional bend points. */
+function addWire(doc, a, b, mids) {
+	if (samePin(a, b) || !pinExists(doc, a) || !pinExists(doc, b)) return doc;
+	const wires = doc.wires ?? [];
+	const id = freshId("w", new Set(wires.map((w) => w.id)));
+	return {
+		...doc,
+		wires: [...wires, mids?.length ? {
+			id,
+			a,
+			b,
+			mid: mids
+		} : {
+			id,
+			a,
+			b
+		}]
+	};
+}
+/** Remove a wire edge. Low-level: callers that may orphan a junction wrap with pruneJunctions. */
+function removeWire(doc, wireId) {
+	return {
+		...doc,
+		wires: (doc.wires ?? []).filter((w) => w.id !== wireId)
+	};
+}
+/** Re-target ONE end of a wire to a different pin (drag-to-detach / reconnect). Rejects a move
+*  that would make the wire a self-loop, or that points at a pin which doesn't exist. */
+function retargetWire(doc, wireId, end, to) {
+	return {
+		...doc,
+		wires: (doc.wires ?? []).map((w) => {
+			if (w.id !== wireId) return w;
+			if (samePin(to, end === "a" ? w.b : w.a) || !pinExists(doc, to)) return w;
+			return end === "a" ? {
+				...w,
+				a: to
+			} : {
+				...w,
+				b: to
+			};
+		})
+	};
+}
+/** Remove a wire (the editor's delete-wire action). Junctions are left in place, never
+*  auto-removed, so nothing the user placed disappears unexpectedly. */
+function disconnectWire(doc, wireId) {
+	return removeWire(doc, wireId);
+}
+/** World position of a pin's terminal (via its PartDef), for geometry on the doc. */
+function terminalOf(doc, ref) {
+	const p = doc.parts.find((x) => x.id === ref.partId);
+	const def = p && getPart(p.kind);
+	return def ? def.terminalAt(p, ref.pin) : void 0;
+}
+/** Manhattan route a pin→pin wire takes (straight if aligned, else a single elbow). */
+function route(a, b) {
+	return a.x === b.x || a.y === b.y ? [a, b] : [
+		a,
+		{
+			x: a.x,
+			y: b.y
+		},
+		b
+	];
+}
+/** The full polyline a wire draws: through its bend points if it has any, else the default
+*  Manhattan elbow. The renderer, hit-test, and tap all route through this one function. */
+function wirePolyline(ta, mids, tb) {
+	return mids.length ? [
+		ta,
+		...mids,
+		tb
+	] : route(ta, tb);
+}
+/** Set (or clear, when empty) a wire's bend points. */
+function setWireWaypoints(doc, wireId, mids) {
+	return {
+		...doc,
+		wires: (doc.wires ?? []).map((w) => w.id === wireId ? {
+			...w,
+			mid: mids.length ? mids : void 0
+		} : w)
+	};
+}
+/** Closest point on a polyline to p (so a tapped junction sits exactly on the wire). */
+function projectOnPolyline(p, pts) {
+	let best = pts[0] ?? p, bd = Infinity;
+	for (let i = 0; i < pts.length - 1; i++) {
+		const a = pts[i], b = pts[i + 1];
+		const dx = b.x - a.x, dy = b.y - a.y, len2 = dx * dx + dy * dy;
+		const t = len2 ? Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2)) : 0;
+		const pt = {
+			x: a.x + t * dx,
+			y: a.y + t * dy
+		};
+		const d = Math.hypot(p.x - pt.x, p.y - pt.y);
+		if (d < bd) {
+			bd = d;
+			best = pt;
+		}
+	}
+	return best;
+}
+/** Place a free junction (a 'node' part) at a point; returns its pin for wiring. */
+function addJunction(doc, at) {
+	const d = addPart(doc, "node", at);
+	return {
+		doc: d,
+		pin: {
+			partId: d.parts[d.parts.length - 1].id,
+			pin: "j"
+		}
+	};
+}
+/**
+* Tap an existing wire at a point: drop a junction ON the wire (projected onto its route)
+* and SPLIT the wire into two that meet there, so a new lead can branch off mid-span. The
+* junction is a `node` part (no element), so the three wires share one net and the solver
+* needs no special mid-wire case. Returns the junction pin to wire the new lead to.
+*/
+function tapWire(doc, wireId, at) {
+	const wire = (doc.wires ?? []).find((w) => w.id === wireId);
+	const ta = wire && terminalOf(doc, wire.a);
+	const tb = wire && terminalOf(doc, wire.b);
+	if (!wire || !ta || !tb) return addJunction(doc, at);
+	const { doc: withNode, pin } = addJunction(doc, projectOnPolyline(at, wirePolyline(ta, wire.mid ?? [], tb)));
+	let d = connect(withNode, wire.a, pin);
+	d = connect(d, pin, wire.b);
+	d = removeWire(d, wireId);
+	return {
+		doc: d,
+		pin
+	};
+}
+/** Drop a part ONTO a wire: insert it in series. The wire is removed and the part's two
+*  ends are wired to the wire's two original endpoints (a → pin0, pin1 → b). */
+function spliceIntoWire(doc, wireId, kind, at) {
+	const wire = (doc.wires ?? []).find((w) => w.id === wireId);
+	const def = getPart(kind);
+	if (!wire || !def || def.pins.length < 2) return addPart(doc, kind, at);
+	let d = addPart(doc, kind, at);
+	const part = d.parts[d.parts.length - 1];
+	if (!part) return d;
+	const [p0, p1] = def.pins;
+	d = removeWire(d, wireId);
+	d = connect(d, wire.a, {
+		partId: part.id,
+		pin: p0
+	});
+	d = connect(d, {
+		partId: part.id,
+		pin: p1
+	}, wire.b);
+	return d;
+}
+/** Toggle a pin's connection to ground. Grounding ties the pin's net to the reference;
+*  toggling again gives the pin a fresh independent node (un-grounds it), so a short made
+*  by grounding both terminals of a source can always be undone. */
+function setGround(doc, ref) {
+	const part = doc.parts.find((p) => p.id === ref.partId);
+	if (!part) return doc;
+	const next = part.pins[ref.pin] === "gnd" ? freshId("nd", nodeIdsOf(doc)) : "gnd";
+	return {
+		...doc,
+		parts: doc.parts.map((p) => p.id === ref.partId ? {
+			...p,
+			pins: {
+				...p.pins,
+				[ref.pin]: next
+			}
+		} : p)
+	};
+}
+
+//#endregion
+export { addJunction, addPart, addWire, connect, deletePart, disconnectWire, movePart, pruneJunctions, removeWire, retargetWire, rotatePart, setGround, setWireWaypoints, spliceIntoWire, tapWire, terminalOf, updateProps, wirePolyline };

package/dist/build/editor-ui.mjs

@@ -0,0 +1,121 @@
+'use client';
+
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/build/editor-ui.tsx
+const R = "var(--radius, 0.625rem)";
+const BORDER = "var(--border, oklch(0.92 0.004 286))";
+const MUTED = "var(--muted-foreground, oklch(0.55 0.01 286))";
+const FG = "var(--foreground, oklch(0.21 0.006 286))";
+function Panel({ title, children, style }) {
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			background: "var(--card, #fff)",
+			color: FG,
+			border: `1px solid ${BORDER}`,
+			borderRadius: R,
+			padding: 12,
+			display: "flex",
+			flexDirection: "column",
+			gap: 10,
+			...style
+		},
+		children: [title && /* @__PURE__ */ jsx("div", {
+			style: {
+				fontSize: 11,
+				fontWeight: 700,
+				letterSpacing: "0.04em",
+				textTransform: "uppercase",
+				color: MUTED
+			},
+			children: title
+		}), children]
+	});
+}
+function EBtn({ children, onClick, active, variant = "default", title, disabled }) {
+	return /* @__PURE__ */ jsx("button", {
+		type: "button",
+		onClick,
+		title,
+		disabled,
+		style: {
+			display: "inline-flex",
+			alignItems: "center",
+			justifyContent: "center",
+			gap: 6,
+			padding: "7px 11px",
+			fontSize: 13,
+			fontWeight: 600,
+			lineHeight: 1,
+			background: variant === "primary" || active ? "var(--primary, oklch(0.21 0.006 286))" : variant === "danger" ? "var(--destructive, oklch(0.58 0.22 27))" : variant === "ghost" ? "transparent" : "var(--secondary, oklch(0.97 0.001 286))",
+			color: variant === "primary" || active ? "var(--primary-foreground, oklch(0.98 0 0))" : variant === "danger" ? "var(--destructive-foreground, #fff)" : FG,
+			border: `1px solid ${variant === "ghost" ? BORDER : "transparent"}`,
+			borderRadius: `calc(${R} - 2px)`,
+			cursor: disabled ? "not-allowed" : "pointer",
+			opacity: disabled ? .5 : 1,
+			transition: "background 120ms, opacity 120ms",
+			whiteSpace: "nowrap"
+		},
+		children
+	});
+}
+function Field({ label, children }) {
+	return /* @__PURE__ */ jsxs("label", {
+		style: {
+			display: "grid",
+			gridTemplateColumns: "1fr auto",
+			alignItems: "center",
+			gap: 8,
+			fontSize: 13,
+			color: FG
+		},
+		children: [/* @__PURE__ */ jsx("span", {
+			style: { color: MUTED },
+			children: label
+		}), children]
+	});
+}
+function NumInput({ value, onChange, step = 1, min, ariaLabel }) {
+	return /* @__PURE__ */ jsx("input", {
+		type: "number",
+		value,
+		step,
+		min,
+		"aria-label": ariaLabel,
+		onChange: (e) => {
+			const v = Number(e.target.value);
+			if (Number.isFinite(v)) onChange(v);
+		},
+		style: {
+			width: 92,
+			padding: "5px 8px",
+			fontSize: 13,
+			textAlign: "right",
+			fontVariantNumeric: "tabular-nums",
+			color: FG,
+			background: "var(--background, #fff)",
+			border: `1px solid ${BORDER}`,
+			borderRadius: `calc(${R} - 3px)`
+		}
+	});
+}
+function TextInput({ value, onChange, ariaLabel }) {
+	return /* @__PURE__ */ jsx("input", {
+		type: "text",
+		value,
+		"aria-label": ariaLabel,
+		onChange: (e) => onChange(e.target.value),
+		style: {
+			width: 120,
+			padding: "5px 8px",
+			fontSize: 13,
+			color: FG,
+			background: "var(--background, #fff)",
+			border: `1px solid ${BORDER}`,
+			borderRadius: `calc(${R} - 3px)`
+		}
+	});
+}
+
+//#endregion
+export { EBtn, Field, NumInput, Panel, TextInput };

package/dist/build/flow.d.mts

@@ -0,0 +1,14 @@
+import { CircuitDoc, CircuitSolution } from "./contract.mjs";
+
+//#region src/build/flow.d.ts
+declare const pinKey: (id: string, pin: string) => string;
+declare const nodeKey: (nid: string) => string;
+interface WireFlow {
+  /** signed current from pin/node `u` to pin/node `v` (amps); positive = u→v. */
+  current: (u: string, v: string) => number;
+}
+/** Threshold below which a wire is treated as carrying no current (float-noise / open branch). */
+declare const FLOW_EPS = 0.000001;
+declare function wireCurrents(doc: CircuitDoc, sol: CircuitSolution): WireFlow;
+//#endregion
+export { FLOW_EPS, WireFlow, nodeKey, pinKey, wireCurrents };

package/dist/build/flow.mjs

@@ -0,0 +1,119 @@
+import { getPart } from "./registry.mjs";
+
+//#region src/build/flow.ts
+/**
+* Per-wire current for the flow animation. The MNA solve (`solveCircuit`) yields node
+* voltages and COMPONENT branch currents, but a net is one equipotential region, so it
+* cannot say how much current each individual WIRE carries. Without that, the renderer
+* animated every wire in an energised net, even dead-end stubs and bypassed branches, so
+* a learner saw "current flowing through every path" regardless of the real circuit.
+*
+* We recover honest per-wire current with a small resistor-network solve: build the graph
+* of pins/nodes joined by wires, give each wire a unit conductance, inject each component's
+* KNOWN terminal current at its pins, and solve the graph Laplacian L·v = b for node
+* potentials. A wire's current is then v_u − v_v. This is exact on a series path (it carries
+* the full loop current), splits evenly across parallel wires, and is ZERO on a dead branch,
+* so the animation flows only where current actually flows. When a wire shorts past a
+* component, that wire carries the current while the component (v ≈ 0 across it) goes dark.
+*/
+const fnum = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+const pinKey = (id, pin) => `${id} ${pin}`;
+const nodeKey = (nid) => `node:${nid}`;
+/** current the part drives a→b internally (n1→n2), reused from the part state convention. */
+const branchAB = (p, sol) => p.kind === "resistor" || p.kind === "bulb" ? (sol.pinV(p.id, "a") - sol.pinV(p.id, "b")) / fnum(p.props?.ohms, p.kind === "bulb" ? 100 : 1e3) : sol.current[p.id] ?? 0;
+/** Dense linear solve A·x = b via Gaussian elimination with partial pivoting; null if singular. */
+function solveDense(A, b) {
+	const n = b.length;
+	const M = A.map((r, i) => [...r, b[i]]);
+	for (let c = 0; c < n; c++) {
+		let piv = c;
+		for (let r = c + 1; r < n; r++) if (Math.abs(M[r][c]) > Math.abs(M[piv][c])) piv = r;
+		if (Math.abs(M[piv][c]) < 1e-12) return null;
+		[M[c], M[piv]] = [M[piv], M[c]];
+		const pv = M[c][c];
+		for (let r = 0; r < n; r++) {
+			if (r === c) continue;
+			const f = M[r][c] / pv;
+			if (f === 0) continue;
+			for (let k = c; k <= n; k++) M[r][k] -= f * M[c][k];
+		}
+	}
+	return M.map((r, i) => r[n] / r[i]);
+}
+/** Threshold below which a wire is treated as carrying no current (float-noise / open branch). */
+const FLOW_EPS = 1e-6;
+function wireCurrents(doc, sol) {
+	if (!sol.ok) return { current: () => 0 };
+	const edges = [];
+	const nodePins = /* @__PURE__ */ new Map();
+	for (const p of doc.parts) {
+		const def = getPart(p.kind);
+		if (!def) continue;
+		for (const pin of def.pins) {
+			const nid = p.pins?.[pin];
+			if (nid) (nodePins.get(nid) ?? nodePins.set(nid, []).get(nid)).push(pinKey(p.id, pin));
+		}
+	}
+	for (const [nid, pins] of nodePins) if (pins.length >= 2) for (const pk of pins) edges.push([pk, nodeKey(nid)]);
+	for (const w of doc.wires ?? []) edges.push([pinKey(w.a.partId, w.a.pin), pinKey(w.b.partId, w.b.pin)]);
+	const idx = /* @__PURE__ */ new Map();
+	const vid = (k) => {
+		let n = idx.get(k);
+		if (n === void 0) {
+			n = idx.size;
+			idx.set(k, n);
+		}
+		return n;
+	};
+	for (const [u, v] of edges) {
+		vid(u);
+		vid(v);
+	}
+	const N = idx.size;
+	if (N === 0) return { current: () => 0 };
+	const b = new Array(N).fill(0);
+	for (const p of doc.parts) {
+		const def = getPart(p.kind);
+		if (!def) continue;
+		const Ib = branchAB(p, sol);
+		const p0 = def.pins[0] ? idx.get(pinKey(p.id, def.pins[0])) : void 0;
+		const p1 = def.pins[1] ? idx.get(pinKey(p.id, def.pins[1])) : void 0;
+		if (p0 !== void 0) b[p0] -= Ib;
+		if (p1 !== void 0) b[p1] += Ib;
+	}
+	const parent = Array.from({ length: N }, (_, i) => i);
+	const find = (x) => {
+		while (parent[x] !== x) {
+			parent[x] = parent[parent[x]];
+			x = parent[x];
+		}
+		return x;
+	};
+	const L = Array.from({ length: N }, () => new Array(N).fill(0));
+	for (const [u, v] of edges) {
+		const a = idx.get(u), c = idx.get(v);
+		L[a][a] += 1;
+		L[c][c] += 1;
+		L[a][c] -= 1;
+		L[c][a] -= 1;
+		parent[find(a)] = find(c);
+	}
+	const pots = new Array(N).fill(0);
+	const comps = /* @__PURE__ */ new Map();
+	for (let i = 0; i < N; i++) (comps.get(find(i)) ?? comps.set(find(i), []).get(find(i))).push(i);
+	for (const verts of comps.values()) {
+		if (verts.length < 2) continue;
+		const unknown = verts.slice(1);
+		const x = solveDense(unknown.map((ri) => unknown.map((cj) => L[ri][cj])), unknown.map((ri) => b[ri]));
+		if (x) unknown.forEach((vi, i) => {
+			pots[vi] = x[i];
+		});
+	}
+	return { current: (u, v) => {
+		const iu = idx.get(u), iv = idx.get(v);
+		return iu === void 0 || iv === void 0 ? 0 : pots[iu] - pots[iv];
+	} };
+}
+
+//#endregion
+export { FLOW_EPS, nodeKey, pinKey, wireCurrents };

package/dist/build/index.d.mts

@@ -0,0 +1,10 @@
+import { CNode, CircuitDoc, CircuitSolution, PartDef, PartInstance, PartKind, PartState, PinRef, Wire } from "./contract.mjs";
+import { getPart, listParts, registerPart } from "./registry.mjs";
+import { partState, solveCircuit } from "./solve.mjs";
+import { FLOW_EPS, WireFlow, nodeKey, pinKey, wireCurrents } from "./flow.mjs";
+import { registerBuiltinParts } from "./parts/index.mjs";
+import { CircuitEditorBag, CircuitScene, CircuitSceneProps } from "./CircuitScene.mjs";
+import { CircuitPlayer, CircuitPlayerProps } from "./CircuitPlayer.mjs";
+import { CircuitEditor, CircuitEditorProps } from "./CircuitEditor.mjs";
+import { addJunction, addPart, addWire, connect, deletePart, disconnectWire, movePart, pruneJunctions, removeWire, retargetWire, rotatePart, setGround, setWireWaypoints, spliceIntoWire, tapWire, terminalOf, updateProps, wirePolyline } from "./editor-ops.mjs";
+export { type CNode, type CircuitDoc, CircuitEditor, type CircuitEditorBag, type CircuitEditorProps, CircuitPlayer, type CircuitPlayerProps, CircuitScene, type CircuitSceneProps, type CircuitSolution, FLOW_EPS, type PartDef, type PartInstance, type PartKind, type PartState, type PinRef, type Wire, type WireFlow, addJunction, addPart, addWire, connect, deletePart, disconnectWire, getPart, listParts, movePart, nodeKey, partState, pinKey, pruneJunctions, registerBuiltinParts, registerPart, removeWire, retargetWire, rotatePart, setGround, setWireWaypoints, solveCircuit, spliceIntoWire, tapWire, terminalOf, updateProps, wireCurrents, wirePolyline };

package/dist/build/index.mjs

@@ -0,0 +1,10 @@
+import { getPart, listParts, registerPart } from "./registry.mjs";
+import { registerBuiltinParts } from "./parts/index.mjs";
+import { partState, solveCircuit } from "./solve.mjs";
+import { FLOW_EPS, nodeKey, pinKey, wireCurrents } from "./flow.mjs";
+import { addJunction, addPart, addWire, connect, deletePart, disconnectWire, movePart, pruneJunctions, removeWire, retargetWire, rotatePart, setGround, setWireWaypoints, spliceIntoWire, tapWire, terminalOf, updateProps, wirePolyline } from "./editor-ops.mjs";
+import { CircuitScene } from "./CircuitScene.mjs";
+import { CircuitPlayer } from "./CircuitPlayer.mjs";
+import { CircuitEditor } from "./CircuitEditor.mjs";
+
+export { CircuitEditor, CircuitPlayer, CircuitScene, FLOW_EPS, addJunction, addPart, addWire, connect, deletePart, disconnectWire, getPart, listParts, movePart, nodeKey, partState, pinKey, pruneJunctions, registerBuiltinParts, registerPart, removeWire, retargetWire, rotatePart, setGround, setWireWaypoints, solveCircuit, spliceIntoWire, tapWire, terminalOf, updateProps, wireCurrents, wirePolyline };

package/dist/build/parts/ammeter.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/build/parts/ammeter.mjs

@@ -0,0 +1,32 @@
+'use client';
+
+import { AmmeterGlyph } from "../../kit/electronics.mjs";
+import { render2, term2 } from "./shared.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/build/parts/ammeter.tsx
+/** Ammeter: an ideal 0 V branch that reads the current through it (mA). Drop it in series. */
+const AMMETER = {
+	kind: "ammeter",
+	label: "Ammeter",
+	pins: ["a", "b"],
+	defaultProps: {},
+	terminalAt: term2,
+	toElems: (i, n) => [{
+		kind: "V",
+		n1: n("a"),
+		n2: n("b"),
+		value: 0,
+		id: i.id
+	}],
+	render: (i, s) => render2(i, void 0, (cx, cy, h) => /* @__PURE__ */ jsx(AmmeterGlyph, {
+		cx,
+		cy,
+		half: h,
+		live: s.live,
+		reading: `${(Math.abs(s.i) * 1e3).toFixed(Math.abs(s.i) >= .0995 ? 0 : 1)} mA`
+	}))
+};
+
+//#endregion
+export { AMMETER };

package/dist/build/parts/bulb.d.mts

@@ -0,0 +1 @@
+export { };