@classytic/labs 0.1.0 → 0.2.0

package/dist/circuits/brownout/preset.mjs

@@ -0,0 +1,399 @@
+'use client';
+
+import { Chip, Slider } from "../../kit/controls.mjs";
+import { Callout, ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
+import { ChallengeCard, useChallenge, useCheckpoint } from "../../kit/pedagogy.mjs";
+import { Tag, Wire } from "../../kit/electronics.mjs";
+import { LabAsk } from "../../kit/ask.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { solveDC } from "@classytic/stage/circuit";
+
+//#region src/circuits/brownout/preset.tsx
+/**
+* BrownoutLab — what a falling supply voltage does to digital logic. A CMOS gate only switches
+* when its transistors can turn on, and that needs the supply rail VDD to stay above the
+* threshold Vth. Drag the battery EMF down (a draining cell, a sagging rail) and the engine solves
+* the gate's output: with a healthy supply it swings rail to rail (valid 1 / 0); as VDD falls
+* toward Vth the swing collapses and the output can no longer follow the input, so it is no longer
+* a valid 1 or 0. That is a brown-out: the chip is not broken, it is simply starved of voltage, and
+* this is the bridge from EMF and
+* the battery to whether a logic circuit works at all.
+*/
+const K = .5;
+const C_HEALTHY = "var(--stage-good)";
+const C_MARGINAL = "var(--stage-warn, oklch(0.78 0.15 80))";
+const C_DEAD = "var(--stage-danger)";
+const W = 460, H = 250;
+function BrownoutLab({ vth = 2, vmax = 6, title = "Brown-out: when the supply is too low to think", prompt = "Drag the battery EMF down. The CMOS gate only switches while the supply rail VDD stays above the transistor threshold. As VDD falls toward Vth the output, solved by the engine, loses its swing and can no longer follow the input: a brown-out, where the logic is no longer a valid 1 or 0.", ask, activity = "brownout" } = {}) {
+	const [vdd, setVdd] = useState(5);
+	const [A, setA] = useState(1);
+	const ch = useChallenge(BROWNOUT_Q);
+	useCheckpoint({
+		solved: ch.allCorrect,
+		activity: "brownout:predict"
+	});
+	const inv = (vddV, aV) => [
+		{
+			kind: "V",
+			n1: 1,
+			n2: 0,
+			value: vddV
+		},
+		{
+			kind: "V",
+			n1: 3,
+			n2: 0,
+			value: aV
+		},
+		{
+			kind: "M",
+			pmos: true,
+			n1: 2,
+			n2: 1,
+			n3: 3,
+			value: 0,
+			vth,
+			k: K
+		},
+		{
+			kind: "M",
+			n1: 2,
+			n2: 0,
+			n3: 3,
+			value: 0,
+			vth,
+			k: K
+		}
+	];
+	const yAt = (aV) => solveDC(inv(vdd, aV)).nodeV[2] ?? 0;
+	const Yhigh = yAt(0);
+	const Ylow = yAt(vdd);
+	const Y = yAt(A ? vdd : 0);
+	const swing = Yhigh - Ylow;
+	const swingFrac = vdd > .05 ? swing / vdd : 0;
+	const SAFE = 1.5 * vth;
+	const collapsed = swingFrac <= .5;
+	const zone = collapsed ? "dead" : vdd < SAFE ? "marginal" : "healthy";
+	const zoneColor = zone === "healthy" ? C_HEALTHY : zone === "marginal" ? C_MARGINAL : C_DEAD;
+	const valid = !collapsed;
+	const level = collapsed ? "invalid" : Y > vdd / 2 ? "1" : "0";
+	const GX = 70, GTOP = 40, GBOT = 210, GW = 26;
+	const y = (v) => GBOT - Math.min(v, vmax) / vmax * (GBOT - GTOP);
+	const band = (lo, hi, color) => /* @__PURE__ */ jsx("rect", {
+		x: GX,
+		y: y(hi),
+		width: GW,
+		height: Math.max(0, y(lo) - y(hi)),
+		fill: color,
+		opacity: .32
+	});
+	const gx = 250, gy = 125;
+	const scene = /* @__PURE__ */ jsx("div", {
+		style: {
+			borderRadius: 12,
+			overflow: "hidden",
+			background: "var(--stage-bg)",
+			border: "1px solid var(--stage-grid)",
+			maxWidth: W,
+			margin: "0 auto"
+		},
+		children: /* @__PURE__ */ jsxs("svg", {
+			viewBox: `0 0 ${W} ${H}`,
+			width: "100%",
+			role: "img",
+			"aria-label": `Brown-out demo, supply ${vdd.toFixed(1)} volts, logic ${zone === "healthy" ? "valid" : zone === "marginal" ? "marginal" : "invalid"}`,
+			children: [
+				band(0, vth, C_DEAD),
+				band(vth, SAFE, C_MARGINAL),
+				band(SAFE, vmax, C_HEALTHY),
+				/* @__PURE__ */ jsx("rect", {
+					x: GX,
+					y: GTOP,
+					width: GW,
+					height: GBOT - GTOP,
+					fill: "none",
+					stroke: "var(--stage-grid)",
+					strokeWidth: 1,
+					rx: 4
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: GX - 4,
+					y1: y(vth),
+					x2: 100,
+					y2: y(vth),
+					stroke: C_DEAD,
+					strokeWidth: 1,
+					strokeDasharray: "3 3"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: GX - 4,
+					y1: y(SAFE),
+					x2: 100,
+					y2: y(SAFE),
+					stroke: C_HEALTHY,
+					strokeWidth: 1,
+					strokeDasharray: "3 3"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 104,
+					y: y(vth) + 4,
+					text: `Vth ${vth}V`,
+					color: "var(--stage-muted)",
+					size: 10,
+					weight: 700,
+					anchor: "start"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 104,
+					y: y(SAFE) + 4,
+					text: "safe",
+					color: "var(--stage-muted)",
+					size: 10,
+					weight: 700,
+					anchor: "start"
+				}),
+				/* @__PURE__ */ jsx("rect", {
+					x: GX,
+					y: y(vdd),
+					width: GW,
+					height: GBOT - y(vdd),
+					fill: zoneColor,
+					opacity: .85
+				}),
+				/* @__PURE__ */ jsx("polygon", {
+					points: `${GX - 12},${y(vdd) - 6} ${GX - 12},${y(vdd) + 6} ${GX - 2},${y(vdd)}`,
+					fill: zoneColor
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 83,
+					y: GTOP - 8,
+					text: "VDD",
+					color: "var(--stage-fg)",
+					size: 12,
+					weight: 800,
+					anchor: "middle"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 83,
+					y: 226,
+					text: `${vdd.toFixed(1)} V`,
+					color: zoneColor,
+					size: 13,
+					weight: 800,
+					anchor: "middle"
+				}),
+				/* @__PURE__ */ jsx(Wire, {
+					points: [
+						[96, y(vdd)],
+						[gx, y(vdd)],
+						[gx, gy - 34]
+					],
+					live: vdd > .05
+				}),
+				/* @__PURE__ */ jsx("polygon", {
+					points: `${gx},${gy - 26} ${gx},151 290,${gy}`,
+					fill: "color-mix(in oklab, var(--stage-metal, gray) 18%, var(--stage-bg))",
+					stroke: "var(--stage-fg)",
+					strokeWidth: 1.5
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx: 296,
+					cy: gy,
+					r: 5,
+					fill: "var(--stage-bg)",
+					stroke: "var(--stage-fg)",
+					strokeWidth: 1.5
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 270,
+					y: 129,
+					text: "NOT",
+					color: "var(--stage-fg)",
+					size: 10,
+					weight: 700,
+					anchor: "middle"
+				}),
+				/* @__PURE__ */ jsx(Wire, {
+					points: [[gx - 36, gy], [gx, gy]],
+					live: !!A
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx: gx - 40,
+					cy: gy,
+					r: 4.5,
+					fill: A ? C_HEALTHY : "var(--stage-muted)"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: gx - 40,
+					y: gy - 10,
+					text: `A=${A}`,
+					color: "var(--stage-fg)",
+					size: 11,
+					weight: 700,
+					anchor: "middle"
+				}),
+				/* @__PURE__ */ jsx(Wire, {
+					points: [[301, gy], [346, gy]],
+					live: valid && level === "1"
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx: 350,
+					cy: gy,
+					r: 5,
+					fill: level === "invalid" ? C_DEAD : level === "1" ? C_HEALTHY : "var(--stage-muted)"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 358,
+					y: gy - 8,
+					text: "Y",
+					color: "var(--stage-fg)",
+					size: 12,
+					weight: 700,
+					anchor: "start"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 358,
+					y: 137,
+					text: level === "invalid" ? "?" : level,
+					color: level === "invalid" ? C_DEAD : level === "1" ? C_HEALTHY : "var(--stage-fg)",
+					size: 14,
+					weight: 800,
+					anchor: "start"
+				}),
+				/* @__PURE__ */ jsx(Tag, {
+					x: 270,
+					y: H - 14,
+					text: `output = ${Y.toFixed(2)} V`,
+					color: "var(--stage-muted)",
+					size: 11,
+					weight: 700,
+					anchor: "middle"
+				})
+			]
+		})
+	});
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [/* @__PURE__ */ jsx(Field, {
+			label: `battery EMF = ${vdd.toFixed(1)} V`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				min: 0,
+				max: vmax,
+				step: .1,
+				value: vdd,
+				onChange: setVdd,
+				ariaLabel: "battery EMF in volts"
+			})
+		}), /* @__PURE__ */ jsx(Field, {
+			label: "input A",
+			children: /* @__PURE__ */ jsxs("span", {
+				className: "lab-field-row",
+				children: [/* @__PURE__ */ jsx(Chip, {
+					selected: A === 0,
+					onClick: () => setA(0),
+					children: "0"
+				}), /* @__PURE__ */ jsx(Chip, {
+					selected: A === 1,
+					onClick: () => setA(1),
+					children: "1"
+				})]
+			})
+		})] }),
+		aside: /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				gap: 10
+			},
+			children: [
+				/* @__PURE__ */ jsx("div", {
+					className: "lab-pill",
+					"data-state": valid ? "ok" : "no",
+					role: "status",
+					style: { alignSelf: "flex-start" },
+					children: zone === "healthy" ? "✓ supply healthy: logic valid, good noise margin" : zone === "marginal" ? "⚠ low rail: logic still valid but the noise margin is thin" : "✗ supply below threshold: output invalid (no swing)"
+				}),
+				/* @__PURE__ */ jsx(Callout, {
+					tone: "result",
+					children: /* @__PURE__ */ jsxs("div", {
+						style: {
+							fontSize: 13,
+							lineHeight: 1.6
+						},
+						children: [
+							"supply VDD = ",
+							/* @__PURE__ */ jsxs("strong", { children: [vdd.toFixed(1), " V"] }),
+							" (threshold Vth = ",
+							vth,
+							" V)",
+							/* @__PURE__ */ jsx("br", {}),
+							"output swing = ",
+							/* @__PURE__ */ jsxs("strong", { children: [Math.max(0, swing).toFixed(2), " V"] }),
+							" (",
+							Math.round(Math.max(0, swingFrac) * 100),
+							"% of rail)",
+							/* @__PURE__ */ jsx("br", {}),
+							"this output = ",
+							Y.toFixed(2),
+							" V → ",
+							level === "invalid" ? /* @__PURE__ */ jsx("span", {
+								style: {
+									color: C_DEAD,
+									fontWeight: 700
+								},
+								children: "invalid (neither 1 nor 0)"
+							}) : /* @__PURE__ */ jsxs("span", {
+								style: { fontWeight: 700 },
+								children: ["logic ", level]
+							})
+						]
+					})
+				}),
+				/* @__PURE__ */ jsx(Callout, {
+					tone: "info",
+					children: /* @__PURE__ */ jsx("div", {
+						style: {
+							fontSize: 12.5,
+							lineHeight: 1.5
+						},
+						children: "A transistor needs gate-to-source above Vth to conduct. Once the whole rail drops near Vth, neither the pull-up nor the pull-down can fully turn on, so the output can no longer be driven to a valid level and the swing collapses. Real systems brown out when a battery drains or a heavy load makes the supply sag (EMF minus the internal-resistance drop). The cure is a minimum supply voltage, not a faster chip."
+					})
+				})
+			]
+		}),
+		footer: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(ChallengeCard, {
+			questions: BROWNOUT_Q,
+			state: ch,
+			title: "Predict first"
+		}), ask ? /* @__PURE__ */ jsx(LabAsk, {
+			ask,
+			activity
+		}) : null] }),
+		children: scene
+	});
+}
+const BROWNOUT_Q = [{
+	id: "brownout-low",
+	prompt: "The battery drains until the supply VDD falls below the transistor threshold Vth. What happens to the gate output?",
+	choices: [
+		{
+			value: "a",
+			label: "it becomes invalid: neither a clean 1 nor 0"
+		},
+		{
+			value: "b",
+			label: "it stays a perfect 1 and 0, just slower"
+		},
+		{
+			value: "c",
+			label: "the gate burns out"
+		}
+	],
+	answer: "a",
+	explain: "Below Vth neither transistor can fully turn on, so the output cannot reach the rails and the swing collapses (it stops following the input). Nothing is damaged: the chip is simply starved of voltage. That is a brown-out, and it is why every chip has a minimum supply voltage."
+}];
+
+//#endregion
+export { BrownoutLab };

package/dist/circuits/capacitor-leak/preset.mjs

@@ -2,9 +2,9 @@
 
 import { Chip, Slider } from "../../kit/controls.mjs";
 import { ControlBar, Field, LabFrame, LiveRegion } from "../../kit/frame.mjs";
-import { HintLadder, useHints } from "../../kit/pedagogy.mjs";
-import { useFrameTick, useReducedMotion } from "../../kit/anim.mjs";
+import { HintLadder, useCheckpoint, useHints } from "../../kit/pedagogy.mjs";
 import { CapacitorGlyph, CellGlyph, ResistorGlyph } from "../../kit/electronics.mjs";
+import { useFrameTick, useReducedMotion } from "../../kit/anim.mjs";
 import { useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { useInView } from "@classytic/stage";
@@ -12,19 +12,19 @@ import { RateCore } from "@classytic/stage/sim";
 
 //#region src/circuits/capacitor-leak/preset.tsx
 /**
-* CapacitorLeakLab — why a capacitor charges, holds, and (slowly) LEAKS.
+* CapacitorLeakLab, why a capacitor charges, holds, and (slowly) LEAKS.
 *
 * A textbook RC loop: a cell charges a capacitor C through a resistor R. Flip
-* the switch to "leak" and the cell is disconnected — the capacitor discharges
+* the switch to "leak" and the cell is disconnected, the capacitor discharges
 * through its own leakage resistance, the field between the plates thins, drips
-* fall off the lower plate, and Vc decays exponentially. One source of truth —
-* Vc(t), integrated by the shared `useFrameLoop` clock — drives the plate field,
+* fall off the lower plate, and Vc decays exponentially. One source of truth , 
+* Vc(t), integrated by the shared `useFrameLoop` clock, drives the plate field,
 * the drips, the live readout, and the Vc–t trace, so they can never disagree.
 *
 * Time-dependent physics lives in the COMPONENT (the pure scene resolver runs
 * once per resolve and can't integrate an ODE); the symbols are the tokenized
 * @classytic/stage electronics glyphs, so the schematic stays exam-standard and
-* rethemes with `--stage-*`. SVG only — honours prefers-reduced-motion.
+* rethemes with `--stage-*`. SVG only, honours prefers-reduced-motion.
 */
 const W = 440, H = 250;
 const xL = 60, xR = 380, yT = 80, yB = 172;
@@ -36,7 +36,7 @@ const GRAPH = {
 	h: 44
 };
 const clamp01 = (v) => Math.max(0, Math.min(1, v));
-function CapacitorLeakLab({ emf = 6, rK = 10, capU = 100, leakK = 200, startCharged = false, title = "Charging & leaking a capacitor", prompt = "Charge it up, then flip to “leak” — watch the field thin and Vc decay.", objectives, hints = [] }) {
+function CapacitorLeakLab({ emf = 6, rK = 10, capU = 100, leakK = 200, startCharged = false, title = "Charging & leaking a capacitor", prompt = "Charge it up, then flip to “leak”, watch the field thin and Vc decay.", objectives, hints = [] }) {
 	const [V, setV] = useState(emf);
 	const [R, setR] = useState(rK);
 	const [C, setC] = useState(capU);
@@ -67,6 +67,11 @@ function CapacitorLeakLab({ emf = 6, rK = 10, capU = 100, leakK = 200, startChar
 	const charging = mode === "charge" && q < .995;
 	const leaking = mode === "leak" && q > .01;
 	const hint = useHints(hints);
+	useCheckpoint({
+		solved: mode === "leak" && q <= .05,
+		activity: `capacitor-leak:${title}`,
+		hintsUsed: hint.count
+	});
 	const sampleArr = rate.current.samples;
 	const trace = sampleArr.length > 1 ? sampleArr.map((s, i) => {
 		const x = GRAPH.x + i / (sampleArr.length - 1) * GRAPH.w;

package/dist/circuits/circuit/asset.mjs

@@ -3,6 +3,7 @@
 import { num } from "../../core/util.mjs";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { StageAssetDefs, registerAsset, useCoords } from "@classytic/stage";
+import { solveDC } from "@classytic/stage/circuit";
 
 //#region src/circuits/circuit/asset.tsx
 const TYPE = {
@@ -16,6 +17,72 @@ const XR = 3.2;
 const ROW_GAP = 1.5;
 const RETURN_DROP = 2.2;
 const numOr = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : typeof v === "boolean" ? v ? 1 : 0 : d;
+/**
+* Solve the branch-list network through the ONE circuit engine (@classytic/stage/circuit
+* MNA): parallel branches between the left bus (node 1) and the ground return (node 0),
+* each a series chain with its own internal nodes; closed switch = near-zero R, open
+* branch = omitted. Returns the totals + per-branch current read back from node voltages.
+*/
+function solveNetwork(raw, nBranch, emf, internalR) {
+	const elems = [];
+	let node = 2;
+	if (internalR > 1e-9) {
+		const bn = node++;
+		elems.push({
+			kind: "V",
+			n1: bn,
+			n2: 0,
+			value: emf,
+			id: "batt"
+		});
+		elems.push({
+			kind: "R",
+			n1: bn,
+			n2: 1,
+			value: internalR
+		});
+	} else elems.push({
+		kind: "V",
+		n1: 1,
+		n2: 0,
+		value: emf,
+		id: "batt"
+	});
+	const branchOf = (b) => raw.filter((r) => r.branch === b).sort((a, c) => a.pos - c.pos);
+	const first = [];
+	for (let b = 0; b < nBranch; b++) {
+		const chain = branchOf(b);
+		if (chain.length === 0 || chain.some((r) => r.type === "switch" && !r.closed)) {
+			first[b] = null;
+			continue;
+		}
+		let prev = 1;
+		let f = null;
+		chain.forEach((r, idx) => {
+			const nb = idx === chain.length - 1 ? 0 : node++;
+			const R = r.type === "switch" ? 1e-6 : Math.max(1e-9, r.ohms);
+			elems.push({
+				kind: "R",
+				n1: prev,
+				n2: nb,
+				value: R
+			});
+			if (!f) f = {
+				a: prev,
+				b: nb,
+				R
+			};
+			prev = nb;
+		});
+		first[b] = f;
+	}
+	const sol = solveDC(elems);
+	const V = sol.nodeV;
+	return {
+		Itotal: Math.abs(sol.current["batt"] ?? 0),
+		branchI: first.map((f) => f ? Math.abs(((V[f.a] ?? 0) - (V[f.b] ?? 0)) / f.R) : 0)
+	};
+}
 function resolver({ params, bound }) {
 	const nComp = Math.max(0, Math.round(num(params.nComp, 0)));
 	const nBranch = Math.max(1, Math.round(num(params.nBranch, 1)));
@@ -40,16 +107,7 @@ function resolver({ params, bound }) {
 		});
 	}
 	const branchOf = (b) => raw.filter((r) => r.branch === b).sort((a, c) => a.pos - c.pos);
-	const branchR = [];
-	for (let b = 0; b < nBranch; b++) {
-		const comps = branchOf(b);
-		branchR[b] = comps.some((r) => r.type === "switch" && !r.closed) ? Infinity : comps.reduce((s, r) => s + (r.type === "switch" ? 0 : r.ohms), 0);
-	}
-	const invSum = branchR.reduce((s, R) => s + (Number.isFinite(R) && R > 0 ? 1 / R : Number.isFinite(R) ? 1e9 : 0), 0);
-	const Rpar = invSum > 0 ? 1 / invSum : Infinity;
-	const Rtot = Number.isFinite(Rpar) ? Rpar + internalR : Infinity;
-	const Itotal = Number.isFinite(Rtot) && Rtot > 1e-9 ? emf / Rtot : 0;
-	const Vbranch = emf - Itotal * internalR;
+	const { Itotal, branchI } = solveNetwork(raw, nBranch, emf, internalR);
 	const loopH = (nBranch - 1) * ROW_GAP + RETURN_DROP;
 	const yTop = loopH / 2;
 	const yReturn = -loopH / 2;
@@ -58,7 +116,7 @@ function resolver({ params, bound }) {
 	for (let b = 0; b < nBranch; b++) {
 		const yb = yTop - b * ROW_GAP;
 		const chain = branchOf(b);
-		const Ib = Number.isFinite(branchR[b]) && branchR[b] > 0 ? Vbranch / branchR[b] : Number.isFinite(branchR[b]) ? Itotal : 0;
+		const Ib = branchI[b] ?? 0;
 		const m = chain.length;
 		chain.forEach((r, idx) => {
 			const x = m === 1 ? 0 : -2.1 + (XR - PADX - -2.1) * (idx / (m - 1));
@@ -115,7 +173,6 @@ function resolver({ params, bound }) {
 	];
 	for (let b = 0; b < nBranch; b++) {
 		const yb = yTop - b * ROW_GAP;
-		const Ib = Number.isFinite(branchR[b]) && branchR[b] > 0 ? Vbranch / branchR[b] : 0;
 		wires.push({
 			pts: [{
 				x: XL,
@@ -124,7 +181,7 @@ function resolver({ params, bound }) {
 				x: XR,
 				y: yb
 			}],
-			energized: Ib > 1e-6
+			energized: (branchI[b] ?? 0) > 1e-6
 		});
 	}
 	const bulbs = comps.filter((c) => c.type === "bulb");
@@ -148,7 +205,7 @@ function resolver({ params, bound }) {
 			wires,
 			emf,
 			Itotal,
-			Rtot: Number.isFinite(Rtot) ? Rtot : -1,
+			Rtot: Itotal > 1e-12 ? emf / Itotal : -1,
 			solved,
 			flowDur,
 			energized: railEnergized

package/dist/circuits/circuit/preset.mjs

@@ -10,7 +10,7 @@ import { Scene, controlsFromScene, isAssetGeom, registerAsset, resolve, useContr
 
 //#region src/circuits/circuit/preset.tsx
 /**
-* Circuit network — a SceneDoc FACTORY on @classytic/stage. A creator declares a
+* Circuit network, a SceneDoc FACTORY on @classytic/stage. A creator declares a
 * battery + parallel BRANCHES (each a series chain of resistor/bulb/switch); the
 * learner closes switches and tunes the battery to hit a goal (light a bulb /
 * reach a target current / light them all). EMF + each switch are FREE scalars
@@ -134,7 +134,12 @@ function CircuitNetworkLab(props) {
 		12,
 		1
 	], controlId, height = 360, prompt = "Close the switch and power the circuit." } = props;
-	const { editor, doc } = useEditor(useMemo(() => circuitDoc(props), [JSON.stringify(props)]));
+	const { editor, doc } = useEditor(useMemo(() => circuitDoc(props), [JSON.stringify({
+		emf: props.emf,
+		internalR: props.internalR,
+		branches: props.branches,
+		goal: props.goal
+	})]));
 	const resolved = resolve(doc);
 	const { switches } = useMemo(() => flatten(branches), [branches]);
 	const geom = resolved.values.get("circuit");
@@ -176,6 +181,8 @@ function CircuitNetworkLab(props) {
 		solved: meta.solved,
 		activity: "circuit-network"
 	});
+	const switchSummary = switches.length ? switches.map((s) => `${s.label} ${Number(resolved.values.get(s.id) ?? 0) >= .5 ? "closed" : "open"}`).join(", ") : "no switches";
+	const figureLabel = `Circuit diagram. ${meta.solved ? "Powered, goal reached" : "Not yet powered"}. Battery ${emf} volts. ${switchSummary}. ${prompt}`;
 	const figure = /* @__PURE__ */ jsxs(Fragment$1, { children: [
 		/* @__PURE__ */ jsx(LabStyles, {}),
 		/* @__PURE__ */ jsx(Scene, {
@@ -184,15 +191,26 @@ function CircuitNetworkLab(props) {
 			showGrid: false,
 			showAxes: false,
 			height,
-			ariaLabel: prompt
+			ariaLabel: figureLabel
 		}),
 		/* @__PURE__ */ jsx(LiveRegion, { children: meta.solved ? "Circuit powered, goal reached." : `Current ${(meta.Itotal * 1e3).toFixed(0)} milliamps.` })
 	] });
 	const controlsUi = /* @__PURE__ */ jsxs(ControlBar, { children: [switches.map((s) => {
 		const closed = Number(resolved.values.get(s.id) ?? 0) >= .5;
+		const flip = () => toggle(s.id);
 		return /* @__PURE__ */ jsxs(Chip, {
 			selected: closed,
-			onClick: () => toggle(s.id),
+			onClick: flip,
+			role: "button",
+			tabIndex: 0,
+			"aria-pressed": closed,
+			"aria-label": `toggle ${s.label} (currently ${closed ? "closed" : "open"})`,
+			onKeyDown: (e) => {
+				if (e.key === "Enter" || e.key === " ") {
+					e.preventDefault();
+					flip();
+				}
+			},
 			children: [
 				s.label,
 				": ",
@@ -208,7 +226,7 @@ function CircuitNetworkLab(props) {
 			max: emfMax,
 			step: emfStep,
 			onChange: setEmf,
-			ariaLabel: "battery voltage",
+			ariaLabel: `battery voltage, ${emf} volts`,
 			style: { width: 120 }
 		})
 	})] });