@classytic/labs 0.1.0

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

@@ -0,0 +1,271 @@
+'use client';
+
+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 { CapacitorGlyph, CellGlyph, ResistorGlyph } from "../../kit/electronics.mjs";
+import { useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { useInView } from "@classytic/stage";
+import { RateCore } from "@classytic/stage/sim";
+
+//#region src/circuits/capacitor-leak/preset.tsx
+/**
+* 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
+* 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,
+* 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.
+*/
+const W = 440, H = 250;
+const xL = 60, xR = 380, yT = 80, yB = 172;
+const CELL_X = 130, R_X = 230, CAP_X = 330, DEV_HALF = 30;
+const GRAPH = {
+	x: xL,
+	y: 196,
+	w: xR - xL,
+	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 = [] }) {
+	const [V, setV] = useState(emf);
+	const [R, setR] = useState(rK);
+	const [C, setC] = useState(capU);
+	const [leak, setLeak] = useState(leakK);
+	const [mode, setMode] = useState("charge");
+	const rate = useRef(RateCore.reset({
+		value0: startCharged ? emf : 0,
+		trace: 160
+	}));
+	const leakPhase = useRef(0);
+	const reduce = useReducedMotion();
+	const { ref: viewRef, inView } = useInView();
+	const tauCharge = R * C / 1e3;
+	const tauLeak = leak * C / 1e3;
+	const target = mode === "charge" ? V : 0;
+	const tau = Math.max(.001, mode === "charge" ? tauCharge : tauLeak);
+	useFrameTick(!reduce && inView, (f) => {
+		const dt = Math.min(.05, f.dtMs / 1e3);
+		rate.current = RateCore.step({
+			...rate.current,
+			target,
+			tau
+		}, dt);
+		if (mode === "leak" && rate.current.value > .01) leakPhase.current = (leakPhase.current + dt * .7) % 1;
+	});
+	const vc = rate.current.value;
+	const q = V > 0 ? clamp01(vc / V) : 0;
+	const charging = mode === "charge" && q < .995;
+	const leaking = mode === "leak" && q > .01;
+	const hint = useHints(hints);
+	const sampleArr = rate.current.samples;
+	const trace = sampleArr.length > 1 ? sampleArr.map((s, i) => {
+		const x = GRAPH.x + i / (sampleArr.length - 1) * GRAPH.w;
+		const y = GRAPH.y + GRAPH.h - (V > 0 ? s / V : 0) * (GRAPH.h - 8) - 4;
+		return `${x.toFixed(1)},${y.toFixed(1)}`;
+	}).join(" ") : "";
+	const wire = (x1, y1, x2, y2, live) => /* @__PURE__ */ jsx("line", {
+		x1,
+		y1,
+		x2,
+		y2,
+		stroke: live ? "var(--stage-live)" : "var(--stage-wire)",
+		strokeWidth: 2.5,
+		strokeLinecap: "round"
+	});
+	const figure = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("div", {
+		ref: viewRef,
+		className: "lab-playwrap",
+		style: {
+			borderRadius: 14,
+			overflow: "hidden",
+			background: "var(--stage-bg)",
+			border: "1px solid var(--stage-grid)"
+		},
+		children: /* @__PURE__ */ jsxs("svg", {
+			viewBox: `0 0 ${W} ${H}`,
+			width: "100%",
+			role: "img",
+			"aria-label": `RC circuit, capacitor at ${Math.round(q * 100)} percent, ${mode === "charge" ? "charging" : "leaking"}`,
+			children: [
+				wire(xL, yT, CELL_X - DEV_HALF, yT, charging),
+				wire(160, yT, R_X - DEV_HALF, yT, charging),
+				wire(260, yT, CAP_X - DEV_HALF, yT, charging),
+				wire(360, yT, xR, yT, charging),
+				wire(xR, yT, xR, yB, charging),
+				wire(xR, yB, xL, yB, charging),
+				mode === "charge" ? wire(xL, yB, xL, yT, charging) : /* @__PURE__ */ jsxs("g", { children: [
+					wire(xL, yB, xL, yT - 26, false),
+					/* @__PURE__ */ jsx("line", {
+						x1: xL,
+						y1: yT - 26,
+						x2: 76,
+						y2: yT - 40,
+						stroke: "var(--stage-warn)",
+						strokeWidth: 3,
+						strokeLinecap: "round"
+					}),
+					/* @__PURE__ */ jsx("circle", {
+						cx: xL,
+						cy: yT - 26,
+						r: 3,
+						fill: "var(--stage-metal)"
+					}),
+					/* @__PURE__ */ jsx("circle", {
+						cx: xL,
+						cy: yT,
+						r: 3,
+						fill: "var(--stage-metal)"
+					})
+				] }),
+				/* @__PURE__ */ jsx(CellGlyph, {
+					cx: CELL_X,
+					cy: yT,
+					half: DEV_HALF,
+					live: charging,
+					label: `${V} V`
+				}),
+				/* @__PURE__ */ jsx(ResistorGlyph, {
+					cx: R_X,
+					cy: yT,
+					half: DEV_HALF,
+					live: charging,
+					label: `${R} kΩ`
+				}),
+				/* @__PURE__ */ jsx(CapacitorGlyph, {
+					cx: CAP_X,
+					cy: yT,
+					half: DEV_HALF,
+					charge: q,
+					leaking,
+					leakPhase: leakPhase.current,
+					live: charging,
+					label: `${C} µF`
+				}),
+				/* @__PURE__ */ jsx("rect", {
+					x: GRAPH.x,
+					y: GRAPH.y,
+					width: GRAPH.w,
+					height: GRAPH.h,
+					rx: 4,
+					fill: "none",
+					stroke: "var(--stage-grid)",
+					strokeWidth: 1
+				}),
+				/* @__PURE__ */ jsx("text", {
+					x: GRAPH.x + 4,
+					y: GRAPH.y + 12,
+					fill: "var(--stage-muted)",
+					fontSize: 10,
+					children: "Vc vs t"
+				}),
+				trace && /* @__PURE__ */ jsx("polyline", {
+					points: trace,
+					fill: "none",
+					stroke: "var(--stage-charge)",
+					strokeWidth: 2,
+					strokeLinejoin: "round"
+				})
+			]
+		})
+	}), /* @__PURE__ */ jsx(LiveRegion, { children: `Capacitor ${Math.round(q * 100)} percent, ${mode}. Vc ${vc.toFixed(1)} volts.` })] });
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [
+			/* @__PURE__ */ jsx(Field, {
+				label: "mode",
+				value: /* @__PURE__ */ jsxs("span", {
+					style: { fontVariantNumeric: "tabular-nums" },
+					children: [
+						"Vc ",
+						vc.toFixed(2),
+						" V · ",
+						Math.round(q * 100),
+						"% · τ ",
+						tau.toFixed(2),
+						" s"
+					]
+				}),
+				children: /* @__PURE__ */ jsxs("span", {
+					style: {
+						display: "flex",
+						gap: 10
+					},
+					children: [/* @__PURE__ */ jsx(Chip, {
+						selected: mode === "charge",
+						onClick: () => setMode("charge"),
+						children: "⚡ Charge"
+					}), /* @__PURE__ */ jsx(Chip, {
+						selected: mode === "leak",
+						onClick: () => setMode("leak"),
+						children: "💧 Leak"
+					})]
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "EMF",
+				value: `${V} V`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: V,
+					min: 1,
+					max: 12,
+					step: 1,
+					onChange: setV,
+					ariaLabel: "EMF (volts)"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "R",
+				value: `${R} kΩ`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: R,
+					min: 1,
+					max: 100,
+					step: 1,
+					onChange: setR,
+					ariaLabel: "charging resistance (kilohm)"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "C",
+				value: `${C} µF`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: C,
+					min: 10,
+					max: 1e3,
+					step: 10,
+					onChange: setC,
+					ariaLabel: "capacitance (microfarad)"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "leak R",
+				value: `${leak} kΩ`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: leak,
+					min: 20,
+					max: 1e3,
+					step: 10,
+					onChange: setLeak,
+					ariaLabel: "leakage resistance (kilohm)"
+				})
+			})
+		] }),
+		footer: /* @__PURE__ */ jsx(HintLadder, { hints: hint }),
+		children: figure
+	});
+}
+
+//#endregion
+export { CapacitorLeakLab };

package/dist/circuits/circuit/asset.d.mts

@@ -0,0 +1,6 @@
+import { AssetSpec } from "@classytic/stage";
+
+//#region src/circuits/circuit/asset.d.ts
+declare const CIRCUIT_NETWORK_ASSET: AssetSpec;
+//#endregion
+export { CIRCUIT_NETWORK_ASSET };

package/dist/circuits/circuit/asset.mjs

@@ -0,0 +1,367 @@
+'use client';
+
+import { num } from "../../core/util.mjs";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { StageAssetDefs, registerAsset, useCoords } from "@classytic/stage";
+
+//#region src/circuits/circuit/asset.tsx
+const TYPE = {
+	1: "resistor",
+	2: "bulb",
+	3: "switch"
+};
+const REF_V = 6;
+const XL = -3.2;
+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;
+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)));
+	const internalR = Math.max(0, num(params.internalR, 0));
+	const emf = Math.max(0, numOr(bound.emf, num(params.emf, 6)));
+	const goalType = Math.round(num(params.goalType, 0));
+	const goalComp = Math.round(num(params.goalComp, -1));
+	const goalVal = num(params.goalVal, .1);
+	const goalTol = num(params.goalTol, .05);
+	const raw = [];
+	for (let i = 0; i < nComp; i++) {
+		const type = TYPE[Math.round(num(params[`t${i}`], 1))] ?? "resistor";
+		const swIdx = Math.round(num(params[`sw${i}`], -1));
+		const closed = type !== "switch" ? true : numOr(bound[`k${swIdx}`], 1) >= .5;
+		raw.push({
+			i,
+			type,
+			ohms: Math.max(0, num(params[`o${i}`], type === "switch" ? 0 : 1)),
+			branch: Math.round(num(params[`b${i}`], 0)),
+			pos: num(params[`p${i}`], i),
+			closed
+		});
+	}
+	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 loopH = (nBranch - 1) * ROW_GAP + RETURN_DROP;
+	const yTop = loopH / 2;
+	const yReturn = -loopH / 2;
+	const PADX = 1.1;
+	const comps = [];
+	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 m = chain.length;
+		chain.forEach((r, idx) => {
+			const x = m === 1 ? 0 : -2.1 + (XR - PADX - -2.1) * (idx / (m - 1));
+			const R = r.ohms;
+			const vDrop = Ib * R;
+			const brightness = r.type === "bulb" ? Math.max(0, Math.min(1, vDrop / REF_V)) : 0;
+			comps.push({
+				type: r.type,
+				at: {
+					x,
+					y: yb
+				},
+				ohms: R,
+				branch: b,
+				current: Ib,
+				brightness,
+				closed: r.closed,
+				label: r.type === "switch" ? "" : `${R}Ω`
+			});
+		});
+	}
+	const railEnergized = Itotal > 1e-6;
+	const wires = [
+		{
+			pts: [{
+				x: XL,
+				y: yReturn
+			}, {
+				x: XL,
+				y: yTop
+			}],
+			energized: railEnergized
+		},
+		{
+			pts: [{
+				x: XR,
+				y: yReturn
+			}, {
+				x: XR,
+				y: yTop
+			}],
+			energized: railEnergized
+		},
+		{
+			pts: [{
+				x: XL,
+				y: yReturn
+			}, {
+				x: XR,
+				y: yReturn
+			}],
+			energized: railEnergized
+		}
+	];
+	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,
+				y: yb
+			}, {
+				x: XR,
+				y: yb
+			}],
+			energized: Ib > 1e-6
+		});
+	}
+	const bulbs = comps.filter((c) => c.type === "bulb");
+	let solved = false;
+	if (goalType === 0) {
+		const t = goalComp >= 0 ? comps[goalComp] : bulbs[0];
+		solved = !!t && t.type === "bulb" && t.brightness >= goalVal;
+	} else if (goalType === 1) {
+		const I = goalComp >= 0 ? comps[goalComp]?.current ?? 0 : Itotal;
+		solved = Math.abs(I - goalVal) <= goalTol;
+	} else if (goalType === 2) solved = bulbs.length > 0 && bulbs.every((c) => c.brightness >= .1);
+	const flowDur = Itotal > 1e-6 ? Math.max(.45, Math.min(3, 1.2 / Itotal)) : 0;
+	return {
+		kind: "asset-geom",
+		parts: { battery: {
+			x: 0,
+			y: yReturn
+		} },
+		meta: {
+			comps,
+			wires,
+			emf,
+			Itotal,
+			Rtot: Number.isFinite(Rtot) ? Rtot : -1,
+			solved,
+			flowDur,
+			energized: railEnergized
+		}
+	};
+}
+function Component({ geom }) {
+	const c = useCoords();
+	const p = geom.parts;
+	const m = geom.meta ?? {};
+	const P = (v) => c.toPx(v.x, v.y);
+	const HALF = 22;
+	const wirePath = (w) => w.pts.map((v) => P(v).join(",")).join(" ");
+	const renderComp = (comp, i) => {
+		const [cx, cy] = P(comp.at);
+		if (comp.type === "resistor") {
+			const h = 11;
+			return /* @__PURE__ */ jsxs("g", { children: [
+				/* @__PURE__ */ jsx("rect", {
+					x: cx - HALF,
+					y: cy - h,
+					width: HALF * 2,
+					height: h * 2,
+					rx: 3,
+					fill: "var(--stage-bg)",
+					stroke: "var(--stage-accent)",
+					strokeWidth: 2
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx: cx - HALF,
+					cy,
+					r: 2.5,
+					fill: "var(--stage-metal)"
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx: cx + HALF,
+					cy,
+					r: 2.5,
+					fill: "var(--stage-metal)"
+				}),
+				/* @__PURE__ */ jsx("text", {
+					x: cx,
+					y: cy - h - 6,
+					fill: "var(--stage-fg)",
+					fontSize: 11,
+					fontWeight: 600,
+					textAnchor: "middle",
+					children: comp.label
+				})
+			] }, i);
+		}
+		if (comp.type === "bulb") {
+			const r = 15;
+			const glow = comp.brightness;
+			const lit = glow > .02;
+			const fill = lit ? `color-mix(in oklab, var(--stage-warn) ${Math.round(glow * 90)}%, var(--stage-bg))` : "var(--stage-bg)";
+			const d = r * .72;
+			const cross = lit ? "var(--stage-sheen)" : "var(--stage-metal)";
+			const crossOp = lit ? .95 : .65;
+			return /* @__PURE__ */ jsxs("g", { children: [
+				lit && /* @__PURE__ */ jsx("circle", {
+					cx,
+					cy,
+					r: 22 + 8 * glow,
+					fill: "var(--stage-warn)",
+					opacity: .22 * glow
+				}),
+				/* @__PURE__ */ jsx("circle", {
+					cx,
+					cy,
+					r,
+					fill,
+					stroke: "var(--stage-metal)",
+					strokeWidth: 1.75
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: cx - d,
+					y1: cy - d,
+					x2: cx + d,
+					y2: cy + d,
+					stroke: cross,
+					strokeWidth: 1.5,
+					opacity: crossOp
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: cx - d,
+					y1: cy + d,
+					x2: cx + d,
+					y2: cy - d,
+					stroke: cross,
+					strokeWidth: 1.5,
+					opacity: crossOp
+				}),
+				/* @__PURE__ */ jsx("text", {
+					x: cx,
+					y: cy + r + 15,
+					fill: "var(--stage-fg)",
+					fontSize: 11,
+					fontWeight: 600,
+					textAnchor: "middle",
+					children: comp.label
+				})
+			] }, i);
+		}
+		const lev = comp.closed ? {
+			x: cx + HALF,
+			y: cy
+		} : {
+			x: cx + HALF * .5,
+			y: cy - HALF * .9
+		};
+		return /* @__PURE__ */ jsxs("g", { children: [
+			/* @__PURE__ */ jsx("line", {
+				x1: cx - HALF,
+				y1: cy,
+				x2: cx + HALF,
+				y2: cy,
+				stroke: "var(--stage-metal)",
+				strokeWidth: 0
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				cx: cx - HALF,
+				cy,
+				r: 3.5,
+				fill: "var(--stage-metal)"
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				cx: cx + HALF,
+				cy,
+				r: 3.5,
+				fill: "var(--stage-metal)"
+			}),
+			/* @__PURE__ */ jsx("line", {
+				x1: cx - HALF,
+				y1: cy,
+				x2: lev.x,
+				y2: lev.y,
+				stroke: comp.closed ? "var(--stage-good)" : "var(--stage-warn)",
+				strokeWidth: 3,
+				strokeLinecap: "round"
+			}),
+			/* @__PURE__ */ jsx("text", {
+				x: cx,
+				y: cy + 22,
+				fill: "var(--stage-fg)",
+				fontSize: 11,
+				textAnchor: "middle",
+				children: comp.closed ? "closed" : "open"
+			})
+		] }, i);
+	};
+	const [batx, baty] = P(p.battery ?? {
+		x: 0,
+		y: 0
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(StageAssetDefs, {}),
+		/* @__PURE__ */ jsx("style", { children: `@keyframes stage-current-flow{to{stroke-dashoffset:-16}}@media (prefers-reduced-motion:reduce){.stage-current{animation:none!important}}` }),
+		/* @__PURE__ */ jsxs("g", { children: [
+			m.wires.map((w, i) => /* @__PURE__ */ jsx("polyline", {
+				points: wirePath(w),
+				fill: "none",
+				stroke: "var(--stage-metal)",
+				strokeWidth: 2.5,
+				strokeLinejoin: "round",
+				strokeLinecap: "round"
+			}, `w${i}`)),
+			m.flowDur > 0 && m.wires.filter((w) => w.energized).map((w, i) => /* @__PURE__ */ jsx("polyline", {
+				className: "stage-current",
+				points: wirePath(w),
+				fill: "none",
+				stroke: "var(--stage-good)",
+				strokeWidth: 2.5,
+				strokeDasharray: "6 10",
+				strokeLinecap: "round",
+				style: { animation: `stage-current-flow ${m.flowDur}s linear infinite` }
+			}, `f${i}`)),
+			/* @__PURE__ */ jsxs("g", { children: [
+				/* @__PURE__ */ jsx("line", {
+					x1: batx - 4,
+					y1: baty - 11,
+					x2: batx - 4,
+					y2: baty + 11,
+					stroke: "var(--stage-metal)",
+					strokeWidth: 3
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: batx + 4,
+					y1: baty - 6,
+					x2: batx + 4,
+					y2: baty + 6,
+					stroke: "var(--stage-metal)",
+					strokeWidth: 3
+				}),
+				/* @__PURE__ */ jsxs("text", {
+					x: batx,
+					y: baty + 24,
+					fill: "var(--stage-fg)",
+					fontSize: 13,
+					fontWeight: 700,
+					textAnchor: "middle",
+					children: [m.emf, "V"]
+				})
+			] }),
+			m.comps.map(renderComp)
+		] })
+	] });
+}
+const CIRCUIT_NETWORK_ASSET = {
+	resolver,
+	Component
+};
+registerAsset("circuit-network", CIRCUIT_NETWORK_ASSET);
+
+//#endregion
+export { CIRCUIT_NETWORK_ASSET };

package/dist/circuits/circuit/index.d.mts

@@ -0,0 +1,2 @@
+import { CIRCUIT_NETWORK_ASSET } from "./asset.mjs";
+import { CircuitComponentSpec, CircuitGoal, CircuitNetworkLab, CircuitNetworkProps, circuitDoc } from "./preset.mjs";

package/dist/circuits/circuit/preset.d.mts

@@ -0,0 +1,46 @@
+import { CIRCUIT_NETWORK_ASSET } from "./asset.mjs";
+import { ReactNode } from "react";
+import { SceneDoc } from "@classytic/stage";
+
+//#region src/circuits/circuit/preset.d.ts
+type CircuitComponentSpec = {
+  type: 'resistor';
+  ohms: number;
+  label?: string;
+} | {
+  type: 'bulb';
+  ohms: number;
+  label?: string;
+} | {
+  type: 'switch';
+  closed?: boolean;
+  label?: string;
+};
+interface CircuitGoal {
+  kind: 'lightBulb' | 'targetCurrent' | 'allLit';
+  /** flat component index (across all branches in declaration order); omit for "total"/first bulb */
+  comp?: number;
+  value?: number;
+  tol?: number;
+}
+interface CircuitNetworkProps {
+  emf?: number;
+  emfRange?: [number, number, number];
+  internalR?: number;
+  /** each inner array is a series chain; multiple arrays are in PARALLEL */
+  branches?: CircuitComponentSpec[][];
+  goal?: CircuitGoal;
+  prompt?: string;
+  controlId?: string;
+  height?: number;
+}
+declare function circuitDoc({
+  emf,
+  emfRange,
+  internalR,
+  branches,
+  goal
+}: CircuitNetworkProps): SceneDoc;
+declare function CircuitNetworkLab(props: CircuitNetworkProps): ReactNode;
+//#endregion
+export { CircuitComponentSpec, CircuitGoal, CircuitNetworkLab, CircuitNetworkProps, circuitDoc };