@classytic/labs 0.6.0 → 0.7.0

package/dist/domains/circuits/potential-hill/model.mjs

@@ -0,0 +1,207 @@
+import { defineLabModel } from "../../../model/define.mjs";
+import { refuse as refuse$1 } from "../../../model/index.mjs";
+import { isRefusal } from "@classytic/stage/result";
+import { z } from "zod";
+import { solveDC } from "@classytic/stage/circuit";
+
+//#region src/domains/circuits/potential-hill/model.ts
+/**
+* Potential hill: one series loop, drawn twice. Above, the circuit; below, the same loop unrolled as a
+* height profile where height is electric potential. The cell lifts by its e.m.f. (a pump), each part
+* drops I·R (a slope), every wire is level. The learner walks a dot round the loop, turns a part's
+* dial and moves the earthed point, and sees three things the book states in words: the same current
+* flows through every part of one loop, the drops share the e.m.f. in proportion to resistance and
+* always add back to it, and 0 V is a chosen reference, so moving it slides the hill without
+* changing one drop.
+*
+* The node potentials are stage's own DC solve (`solveDC`, Modified Nodal Analysis) over the loop, as
+* `potential-divider` does. Node 1 is the cell's + terminal, nodes 2..n sit between parts, node 0 the
+* cell's − terminal; the earth option re-references them.
+*/
+const partSchema = z.object({
+	name: z.string().trim().min(1).max(24).describe("what the part is in the lesson: \"bulb\", \"heater\", \"R₁\""),
+	ohm: z.number().int().min(1).max(12).describe("its resistance, whole ohms")
+});
+/** The fraction of the lap each kind of stretch takes, so the profile reads at a glance. */
+const CELL = .14;
+const WIRE = .06;
+const fmt = (v) => Math.abs(v - Math.round(v)) < .005 ? String(Math.round(v)) : v.toFixed(2);
+const potentialHillModel = defineLabModel({
+	id: "potential-hill",
+	params: z.object({
+		emf: z.number().finite().min(1.5).max(24).default(6).describe("the cell e.m.f., volts: the lift of the pump"),
+		parts: z.array(partSchema).min(2).max(3).default([{
+			name: "R₁",
+			ohm: 2
+		}, {
+			name: "R₂",
+			ohm: 4
+		}]).describe("the parts in series, in order round the loop from the cell’s + terminal"),
+		earthAt: z.number().int().min(0).max(3).default(0).describe("where 0 V starts: 0 is the cell’s − terminal, k is the node after part k")
+	}),
+	resolve(p) {
+		if (p.earthAt > p.parts.length - 1 && p.earthAt !== 0) return refuse$1("earth-outside-loop", "Earth at the cell’s − terminal (0) or after one of the parts but the last.", { prop: "earthAt" });
+		return { ...p };
+	},
+	initial: (s) => ({
+		ohms: s.parts.map((part) => part.ohm),
+		walker: 0,
+		earth: s.earthAt,
+		tuned: false,
+		rezeroed: false,
+		walked: 0
+	}),
+	controls: (c) => ({
+		walker: c.number({
+			label: "walk round the loop",
+			step: .02,
+			bigStep: .1,
+			range: () => [0, 1],
+			get: (st) => st.walker,
+			set: (st, walker) => ({
+				...st,
+				walker,
+				walked: Math.max(st.walked, walker)
+			}),
+			format: (v) => `${Math.round(v * 100)}% of the lap`
+		}),
+		r1: c.number({
+			label: (s) => `${s.parts[0].name} resistance`,
+			unit: "Ω",
+			step: 1,
+			range: () => [1, 12],
+			get: (st) => st.ohms[0],
+			set: (st, v) => ({
+				...st,
+				ohms: st.ohms.map((o, i) => i === 0 ? v : o),
+				tuned: true
+			}),
+			format: (v) => `${v} Ω`
+		}),
+		r2: c.number({
+			label: (s) => `${s.parts[1].name} resistance`,
+			unit: "Ω",
+			step: 1,
+			range: () => [1, 12],
+			get: (st) => st.ohms[1],
+			set: (st, v) => ({
+				...st,
+				ohms: st.ohms.map((o, i) => i === 1 ? v : o),
+				tuned: true
+			}),
+			format: (v) => `${v} Ω`
+		}),
+		r3: c.number({
+			label: (s) => `${s.parts[2]?.name ?? "R₃"} resistance`,
+			unit: "Ω",
+			when: (s) => s.parts.length > 2,
+			step: 1,
+			range: () => [1, 12],
+			get: (st) => st.ohms[2] ?? 1,
+			set: (st, v) => ({
+				...st,
+				ohms: st.ohms.map((o, i) => i === 2 ? v : o),
+				tuned: true
+			}),
+			format: (v) => `${v} Ω`
+		}),
+		earth: c.choice({
+			label: "earthed point (0 V)",
+			options: (s) => [{
+				value: "0",
+				label: "cell − terminal"
+			}, ...s.parts.slice(0, -1).map((part, i) => ({
+				value: String(i + 1),
+				label: `after ${part.name}`
+			}))],
+			get: (st) => String(st.earth),
+			set: (st, v) => ({
+				...st,
+				earth: Number(v),
+				rezeroed: st.rezeroed || Number(v) !== st.earth
+			})
+		})
+	}),
+	read(s, st) {
+		const n = st.ohms.length;
+		const elems = [{
+			kind: "V",
+			n1: 1,
+			n2: 0,
+			value: s.emf,
+			id: "cell"
+		}, ...st.ohms.map((ohm, i) => ({
+			kind: "R",
+			n1: i + 1,
+			n2: i + 2 > n ? 0 : i + 2,
+			value: ohm,
+			id: `p${i}`
+		}))];
+		const solved = solveDC(elems);
+		if (isRefusal(solved)) throw new Error(`potential-hill: ${solved.code}: ${solved.message}`);
+		const abs = (node) => solved.nodeV[node] ?? 0;
+		const after = (k) => k >= n ? 0 : abs(k + 1);
+		const ref = st.earth === 0 ? 0 : after(st.earth);
+		const drops = st.ohms.map((_, i) => abs(i + 1) - after(i + 1));
+		const current = drops[0] / st.ohms[0];
+		const partSpan = (1 - CELL - WIRE * (n + 1)) / n;
+		const points = [];
+		let at = 0;
+		const push = (v, kind, part) => {
+			points.push({
+				at,
+				v: v - ref,
+				kind,
+				...part !== undefined ? { part } : {}
+			});
+		};
+		push(0, "wire");
+		at += WIRE / 2;
+		push(0, "cell");
+		at += CELL;
+		push(s.emf, "wire");
+		for (let i = 0; i < n; i++) {
+			at += WIRE;
+			push(abs(i + 1), "part", i);
+			at += partSpan;
+			push(after(i + 1), "wire");
+		}
+		at = 1;
+		push(0, "wire");
+		const potentialAt = (x) => {
+			for (let i = 1; i < points.length; i++) {
+				const a = points[i - 1];
+				const b = points[i];
+				if (x <= b.at) return a.v + (x - a.at) / Math.max(b.at - a.at, 1e-9) * (b.v - a.v);
+			}
+			return points[points.length - 1].v;
+		};
+		return {
+			current,
+			drops,
+			total: st.ohms.reduce((a, b) => a + b, 0),
+			points,
+			walkerV: potentialAt(st.walker),
+			lowest: Math.min(...points.map((p) => p.v)),
+			highest: Math.max(...points.map((p) => p.v)),
+			closes: Math.abs(drops.reduce((a, b) => a + b, 0) - s.emf) < 1e-9
+		};
+	},
+	goals: {
+		walked: (_r, st) => st.walked >= .98,
+		tuned: (_r, st) => st.tuned,
+		rezeroed: (_r, st) => st.rezeroed
+	},
+	witness: (s) => ({
+		ohms: s.parts.map((part) => part.ohm),
+		walker: 1,
+		earth: s.parts.length > 1 ? 1 : 0,
+		tuned: true,
+		rezeroed: true,
+		walked: 1
+	}),
+	describe: (s, st, r) => `A ${fmt(s.emf)} V cell drives ${fmt(r.current)} A through ${s.parts.map((part, i) => `${part.name} (${st.ohms[i]} Ω, drop ${fmt(r.drops[i])} V)`).join(", ")}. The drops add to ${fmt(r.drops.reduce((a, b) => a + b, 0))} V. The walker is at ${fmt(r.walkerV)} V measured from ${st.earth === 0 ? "the cell’s − terminal" : `the point after ${s.parts[st.earth - 1].name}`}.`
+});
+
+//#endregion
+export { potentialHillModel };

package/dist/domains/circuits/potential-hill/runtime.mjs

@@ -0,0 +1,24 @@
+'use client';
+
+import { useLab } from "../../../runtime/use-lab.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { potentialHillModel } from "./model.mjs";
+import { potentialHillActivity } from "./activity.mjs";
+import { PotentialHillScene } from "./scene.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/circuits/potential-hill/runtime.tsx
+function PotentialHill(props) {
+	const lab = useLab(potentialHillModel, props);
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		lab,
+		activity: potentialHillActivity,
+		className: "circuits-potential-hill",
+		layout: "stack",
+		sceneLabel: "A series loop and its potential hill",
+		children: /* @__PURE__ */ jsx(PotentialHillScene, {})
+	});
+}
+
+//#endregion
+export { PotentialHill as default };

package/dist/domains/circuits/potential-hill/scene.mjs

@@ -0,0 +1,267 @@
+'use client';
+
+import { FigText } from "../../../kit/figure/text.mjs";
+import { Figure, HUE, STROKE } from "../../../kit/figure/figure.mjs";
+import { GripSlider } from "../../../kit/figure/grip.mjs";
+import { useControl } from "../../../runtime/use-control.mjs";
+import { useLabView } from "../../../runtime/use-lab-view.mjs";
+import { Wire } from "../../../kit/electronics/wire.mjs";
+import { CellGlyph, ResistorGlyph } from "../../../kit/electronics/basics.mjs";
+import { potentialHillModel } from "./model.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/domains/circuits/potential-hill/scene.tsx
+const W = 360;
+const H = 300;
+const LX = 36;
+const RX = 324;
+const TY = 40;
+const BY = 112;
+const GX0 = 36;
+const GX1 = 324;
+const GTOP = 158;
+const GBOT = 272;
+const PART_HUES = [
+	HUE[1],
+	HUE[2],
+	HUE[3]
+];
+const PART_TONES = [
+	"hue-1",
+	"hue-2",
+	"hue-3"
+];
+const fmt = (v) => Math.abs(v - Math.round(v)) < .005 ? String(Math.round(v)) : v.toFixed(2);
+const upright = (cx, cy, glyph) => /* @__PURE__ */ jsx("g", {
+	transform: `rotate(-90 ${cx} ${cy})`,
+	children: glyph
+});
+function PotentialHillScene() {
+	const { scenario: s, state: st, reading: r } = useLabView(potentialHillModel);
+	const walker = useControl(potentialHillModel, "walker");
+	const pts = r.points;
+	const cellEnd = pts.find((p, i) => i > 0 && pts[i - 1].kind === "cell").at;
+	const lastPartEnd = pts[pts.length - 2].at;
+	const topX = (at) => LX + 24 + (at - cellEnd) / (lastPartEnd - cellEnd) * (RX - LX - 48);
+	const cellStart = pts.find((p) => p.kind === "cell").at;
+	/** The walker's place on the drawn loop, from its fraction of the lap. */
+	const onLoop = (at) => {
+		if (at <= cellStart) return [LX, BY];
+		if (at <= cellEnd) return [LX, BY - (at - cellStart) / (cellEnd - cellStart) * (BY - TY)];
+		if (at <= lastPartEnd) return [topX(at), TY];
+		const f = (at - lastPartEnd) / (1 - lastPartEnd);
+		const side = BY - TY;
+		const run = RX - LX;
+		const d = f * (side + run);
+		return d <= side ? [RX, TY + d] : [RX - (d - side), BY];
+	};
+	const lo = Math.min(r.lowest, 0);
+	const hi = Math.max(r.highest, .5);
+	const gx = (at) => GX0 + at * (GX1 - GX0);
+	const gy = (v) => GBOT - (v - lo) / (hi - lo || 1) * (GBOT - GTOP);
+	const [wx, wy] = onLoop(st.walker);
+	const hillY = gy(r.walkerV);
+	const parts = pts.map((p, i) => p.kind === "part" ? {
+		i: p.part,
+		a: p,
+		b: pts[i + 1]
+	} : null).filter((x) => x !== null);
+	const cellA = pts.find((p) => p.kind === "cell");
+	const cellB = pts[pts.indexOf(cellA) + 1];
+	const earthAt = st.earth === 0 ? cellStart : parts[st.earth - 1].b.at;
+	const [ex, ey] = onLoop(earthAt);
+	return /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [W, H],
+		domain: "physics",
+		label: potentialHillModel.describe(s, st, r),
+		children: [
+			/* @__PURE__ */ jsx(Wire, {
+				points: [
+					[LX, BY],
+					[LX, TY],
+					[RX, TY],
+					[RX, BY],
+					[LX, BY]
+				],
+				live: true
+			}),
+			upright(LX, (TY + BY) / 2, /* @__PURE__ */ jsx(CellGlyph, {
+				cx: LX,
+				cy: (TY + BY) / 2,
+				half: 22,
+				live: true
+			})),
+			/* @__PURE__ */ jsx(FigText, {
+				x: LX + 20,
+				y: (TY + BY) / 2 + 4,
+				anchor: "start",
+				tone: "ink",
+				size: "measure",
+				children: `${fmt(s.emf)} V`
+			}),
+			parts.map(({ i, a, b }) => {
+				const cx = (topX(a.at) + topX(b.at)) / 2;
+				return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx(ResistorGlyph, {
+					cx,
+					cy: TY,
+					half: 26,
+					live: true
+				}), /* @__PURE__ */ jsx(FigText, {
+					x: cx,
+					y: TY - 16,
+					anchor: "middle",
+					tone: PART_TONES[i],
+					size: "label",
+					weight: "semibold",
+					children: `${s.parts[i].name} ${st.ohms[i]} Ω`
+				})] }, i);
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: (LX + RX) / 2,
+				y: BY + 16,
+				anchor: "middle",
+				tone: "soft",
+				size: "label",
+				children: `I = ${fmt(r.current)} A everywhere in the loop`
+			}),
+			/* @__PURE__ */ jsxs("g", { children: [
+				/* @__PURE__ */ jsx("line", {
+					x1: ex,
+					y1: ey,
+					x2: ex,
+					y2: ey + 8,
+					stroke: HUE.ink,
+					strokeWidth: STROKE.line
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: ex - 7,
+					y1: ey + 8,
+					x2: ex + 7,
+					y2: ey + 8,
+					stroke: HUE.ink,
+					strokeWidth: STROKE.line
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: ex - 4,
+					y1: ey + 11,
+					x2: ex + 4,
+					y2: ey + 11,
+					stroke: HUE.ink,
+					strokeWidth: STROKE.line
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: ex - 1.5,
+					y1: ey + 14,
+					x2: ex + 1.5,
+					y2: ey + 14,
+					stroke: HUE.ink,
+					strokeWidth: STROKE.line
+				})
+			] }),
+			/* @__PURE__ */ jsx("circle", {
+				cx: wx,
+				cy: wy,
+				r: 5,
+				fill: HUE.warn,
+				stroke: HUE.paper,
+				strokeWidth: STROKE.line
+			}),
+			/* @__PURE__ */ jsx("line", {
+				x1: GX0,
+				y1: gy(0),
+				x2: GX1,
+				y2: gy(0),
+				stroke: HUE.soft,
+				strokeWidth: STROKE.hair,
+				strokeDasharray: "4 3"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: GX1 + 4,
+				y: gy(0),
+				anchor: "start",
+				baseline: "middle",
+				tone: "soft",
+				size: "label",
+				children: "0 V"
+			}),
+			/* @__PURE__ */ jsx("polyline", {
+				points: pts.map((p) => `${gx(p.at)},${gy(p.v)}`).join(" "),
+				fill: "none",
+				stroke: HUE.soft,
+				strokeWidth: STROKE.line,
+				strokeLinejoin: "round"
+			}),
+			/* @__PURE__ */ jsx("line", {
+				x1: gx(cellA.at),
+				y1: gy(cellA.v),
+				x2: gx(cellB.at),
+				y2: gy(cellB.v),
+				stroke: HUE.good,
+				strokeWidth: STROKE.bold,
+				strokeLinecap: "round"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: gx(cellB.at) + 4,
+				y: (gy(cellA.v) + gy(cellB.v)) / 2,
+				anchor: "start",
+				tone: "good",
+				size: "label",
+				children: `+${fmt(s.emf)} V`
+			}),
+			parts.map(({ i, a, b }) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("line", {
+				x1: gx(a.at),
+				y1: gy(a.v),
+				x2: gx(b.at),
+				y2: gy(b.v),
+				stroke: PART_HUES[i],
+				strokeWidth: STROKE.bold,
+				strokeLinecap: "round"
+			}), /* @__PURE__ */ jsx(FigText, {
+				x: (gx(a.at) + gx(b.at)) / 2 + 6,
+				y: (gy(a.v) + gy(b.v)) / 2 - 8,
+				anchor: "start",
+				tone: PART_TONES[i],
+				size: "label",
+				children: `−${fmt(r.drops[i])} V`
+			})] }, i)),
+			/* @__PURE__ */ jsx("line", {
+				x1: gx(st.walker),
+				y1: GTOP - 4,
+				x2: gx(st.walker),
+				y2: GBOT + 4,
+				stroke: HUE.warn,
+				strokeWidth: STROKE.hair,
+				strokeDasharray: "2 3"
+			}),
+			/* @__PURE__ */ jsx(GripSlider, {
+				cx: gx(st.walker),
+				cy: hillY,
+				r: 7,
+				hit: 26,
+				axis: "x",
+				label: "the walker: drag it round the loop to read the potential at each point",
+				control: walker,
+				toValue: (p) => Math.min(1, Math.max(0, (p.x - GX0) / (GX1 - GX0))),
+				children: /* @__PURE__ */ jsx("circle", {
+					cx: gx(st.walker),
+					cy: hillY,
+					r: 7,
+					fill: HUE.warn,
+					stroke: HUE.paper,
+					strokeWidth: STROKE.line
+				})
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: gx(st.walker),
+				y: GBOT + 18,
+				anchor: "middle",
+				tone: "warn",
+				size: "measure",
+				children: `${fmt(r.walkerV)} V`
+			})
+		]
+	});
+}
+
+//#endregion
+export { PotentialHillScene };

package/dist/domains/circuits/rc-charging/activity.mjs

@@ -2,8 +2,8 @@ import { defineActivity } from "../../../runtime/activity.mjs";
 import { rcChargingModel } from "./model.mjs";
 
 //#region src/domains/circuits/rc-charging/activity.ts
-/** Predict when the capacitor reaches two thirds of the supply, charge it and check, then halve
-* the resistor and time it again: the curve reaches two thirds in half the time. */
+/** Optionally estimate when the capacitor reaches about 63% of the supply, charge it, then halve
+* the resistor and compare the same voltage reached in half the time. */
 const rcChargingActivity = defineActivity(rcChargingModel, () => ({
 	pattern: "investigation",
 	title: "The time constant",
@@ -15,15 +15,15 @@ const rcChargingActivity = defineActivity(rcChargingModel, () => ({
 	steps: [{
 		id: "charge",
 		phase: "act",
-		title: "Drag to two thirds, then charge",
-		lead: "Drag the marker to where you expect the capacitor to reach two thirds of the supply. Then flip the switch to charge it and check.",
+		title: "Charge the capacitor",
+		lead: "The capacitor stores separated charge. Flip the switch and watch its voltage rise more slowly as it fills. You can place a timing estimate on the graph before charging.",
 		controls: ["marker", "flip"],
 		goal: "charged"
 	}, {
 		id: "halve",
 		phase: "transfer",
 		title: "Halve the resistance",
-		lead: "Halve the resistance and charge again. The curve reaches two thirds in half the time: the time constant tau = RC halved with the resistance.",
+		lead: "Tap the resistor to start a fresh trial with half the resistance and a discharged capacitor. Charge again and compare the curves on the same axes.",
 		controls: [
 			"halveResistor",
 			"flip",

package/dist/domains/circuits/rc-charging/manifest.mjs

@@ -8,7 +8,7 @@ var manifest_default = defineLab({
 	domain: "circuits",
 	group: "Circuits",
 	title: "RC charging and the time constant",
-	description: "A cell, a two-way switch, one resistor and a capacitor on the bench. Predict when the capacitor reaches two thirds of the supply, charge it and check, then halve the resistor and time it again: the time constant tau = RC halves with it.",
+	description: "A cell, a two-way switch, one resistor and a capacitor on the bench. Charge the capacitor and watch its voltage approach the supply. Optionally estimate the time to about 63%, then halve the resistor and compare both curves on the same time scale.",
 	model: rcChargingModel,
 	examples: [{
 		name: "default",
@@ -35,7 +35,7 @@ var manifest_default = defineLab({
 		levels: ["a-level"],
 		qualityTier: "support",
 		primaryMechanic: "investigation",
-		learnerAction: "predict the time to two thirds, then confirm by charging the capacitor",
+		learnerAction: "charge the capacitor, then halve resistance and compare its voltage curve",
 		evidenceTypes: ["observation", "measurement"],
 		mobileMode: "investigation",
 		misconceptions: ["a capacitor charges at a constant rate", "halving the resistance halves the final voltage rather than the time to reach it"],
@@ -47,14 +47,9 @@ var manifest_default = defineLab({
 			"Connect the circuit state to its exponential curve",
 			"Redesign the time constant by changing resistance or capacitance"
 		],
-		phases: [
-			"predict",
-			"act",
-			"observe",
-			"explain",
-			"transfer"
-		],
-		responses: ["choice"],
+		openingPhase: "act",
+		phases: ["act", "transfer"],
+		responses: [],
 		accessibility: {
 			keyboard: true,
 			textAlternative: true,

package/dist/domains/circuits/rc-charging/model.mjs

@@ -1,20 +1,18 @@
 import { defineLabModel } from "../../../model/define.mjs";
 import { z } from "zod";
-import { rcCurrentAt, rcTimeConstantS, rcTimeToFraction, rcVoltageAt } from "@classytic/stage/circuit";
+import { FIRST_ORDER_RESPONSE_CARD, rcCurrentAt, rcTimeConstantS, rcVoltageAt } from "@classytic/stage/circuit";
 
 //#region src/domains/circuits/rc-charging/model.ts
 /**
 * A cell, a two-way switch, one resistor and a capacitor: the time constant tau = RC.
 *
-* Predict when the capacitor reaches two thirds of the supply, charge it and check, then halve the
-* resistor and time it again: the curve reaches two thirds in half the time, because tau halved
+* Estimate when the capacitor reaches about 63% of the supply, charge it and check, then halve the
+* resistor and time it again: the curve reaches the same fraction in half the time, because tau halved
 * with it. Every voltage, current and time constant is stage's own RC kernel (`rcVoltageAt`,
-* `rcCurrentAt`, `rcTimeConstantS`, `rcTimeToFraction`, from `@classytic/stage/circuit`).
+* `rcCurrentAt`, `rcTimeConstantS`, from `@classytic/stage/circuit`).
 */
 /** How many time constants a run is drawn for. */
 const RUN_TAUS = 5;
-/** Two thirds of the way there: 1 - e^-1. */
-const TWO_THIRDS = 1 - Math.exp(-1);
 function circuitOf(s, halved) {
 	const ohm = s.resistanceK * 1e3 * (halved ? .5 : 1);
 	return {
@@ -37,6 +35,7 @@ const rcChargingModel = defineLabModel({
 		settled: false,
 		halved: false,
 		firstTauS: null,
+		firstRun: null,
 		marker: 0
 	}),
 	controls: (c) => ({
@@ -75,6 +74,8 @@ const rcChargingModel = defineLabModel({
 				return {
 					...st,
 					firstTauS: rcTimeConstantS(circuit, "charge"),
+					firstRun: st.run ? { ...st.run } : null,
+					marker: 0,
 					halved: true,
 					run: null,
 					t: 0,
@@ -128,6 +129,17 @@ const rcChargingModel = defineLabModel({
 		const volts = st.run ? rcVoltageAt(circuit, run, t) : 0;
 		const amps = st.run ? rcCurrentAt(circuit, run, t) : 0;
 		const trace = st.run ? Array.from({ length: 61 }, (_, i) => [i / 60 * t, rcVoltageAt(circuit, run, i / 60 * t)]) : [];
+		const oneTauTimeS = rcTimeConstantS(circuit, "charge");
+		const oneTauVoltageV = rcVoltageAt(circuit, st.run?.side === "charge" ? st.run : {
+			side: "charge",
+			startVoltageV: 0
+		}, oneTauTimeS);
+		const originalCircuit = circuitOf(s, false);
+		const comparisonEndS = 5 * (st.firstTauS ?? tau);
+		const originalTrace = st.firstRun ? Array.from({ length: 61 }, (_, i) => {
+			const timeS = i / 60 * comparisonEndS;
+			return [timeS, rcVoltageAt(originalCircuit, st.firstRun, timeS)];
+		}) : [];
 		return {
 			circuit,
 			run: st.run,
@@ -137,7 +149,11 @@ const rcChargingModel = defineLabModel({
 			volts,
 			amps,
 			trace,
-			tau
+			tau,
+			oneTauTimeS,
+			oneTauVoltageV,
+			comparisonEndS,
+			originalTrace
 		};
 	},
 	goals: {
@@ -155,12 +171,17 @@ const rcChargingModel = defineLabModel({
 			t: 5 * tau,
 			settled: true,
 			halved: true,
-			firstTauS: s.resistanceK * 1e3 * (s.capacitanceU * 1e-6),
+			firstTauS: rcTimeConstantS(circuitOf(s, false), "charge"),
+			firstRun: {
+				side: "charge",
+				startVoltageV: 0
+			},
 			marker: 0
 		};
 	},
-	describe: (_s, st, r) => `Capacitor at ${r.volts.toFixed(2)} volts.`
+	describe: (_s, st, r) => `Capacitor at ${r.volts.toFixed(2)} volts.`,
+	model: FIRST_ORDER_RESPONSE_CARD
 });
 
 //#endregion
-export { TWO_THIRDS, rcChargingModel, rcTimeToFraction };
+export { rcChargingModel };

package/dist/domains/circuits/rc-charging/runtime.mjs

@@ -6,7 +6,7 @@ import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.
 import { rcChargingModel } from "./model.mjs";
 import { rcChargingActivity } from "./activity.mjs";
 import { RcChargingScene } from "./scene.mjs";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 
 //#region src/domains/circuits/rc-charging/runtime.tsx
 function RcChargingLab(props) {
@@ -17,15 +17,12 @@ function RcChargingLab(props) {
 		className: "rc-charging-activity",
 		layout: "stack",
 		sceneLabel: "A cell, a switch, a resistor and a capacitor, charging and discharging",
-		evidence: ({ reading, state }) => /* @__PURE__ */ jsxs(StatList, { children: [/* @__PURE__ */ jsx(Stat, {
+		evidence: ({ reading, state }) => /* @__PURE__ */ jsx(StatList, { children: /* @__PURE__ */ jsx(Stat, {
 			label: "Time constant",
 			value: `${reading.tau.toFixed(2)} s`,
 			tone: state.halved ? "good" : undefined
-		}), /* @__PURE__ */ jsx(Stat, {
-			label: "Voltage",
-			value: `${reading.volts.toFixed(2)} V`
-		})] }),
-		observation: ({ reading, state }) => state.halved ? `Halving the resistance halved the time constant: it now takes ${reading.tau.toFixed(2)} s to reach two thirds of the way, half of what it took before.` : reading.done ? `The capacitor reached ${reading.volts.toFixed(2)} V, two thirds of the ${reading.circuit.emfV} V supply, in ${reading.tau.toFixed(2)} s: one time constant, tau = RC.` : undefined,
+		}) }),
+		observation: ({ reading, state }) => reading.done && reading.run?.side === "charge" ? state.halved ? `At one time constant, the capacitor reaches ${reading.oneTauVoltageV.toFixed(2)} V (about 63% of the rise) in ${reading.oneTauTimeS.toFixed(2)} s, half the original ${state.firstTauS.toFixed(2)} s. Both curves approach the same ${reading.circuit.emfV} V supply.` : `At one time constant, ${reading.oneTauTimeS.toFixed(2)} s, the capacitor reached ${reading.oneTauVoltageV.toFixed(2)} V (about 63% of the rise toward the ${reading.circuit.emfV} V supply). After five time constants it is nearly at the supply voltage.` : undefined,
 		children: /* @__PURE__ */ jsx(RcChargingScene, {})
 	});
 }