@classytic/labs 0.3.0 → 0.4.0

package/dist/physics/biot-savart/torque-preset.mjs

@@ -0,0 +1,334 @@
+'use client';
+
+import { Slider } from "../../kit/controls.mjs";
+import { Field, Stat, StatList } from "../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../kit/authored-activity-runtime.mjs";
+import { Figure, HUE, STROKE } from "../../kit/figure/figure.mjs";
+import { FigText } from "../../kit/figure/text.mjs";
+import { Arrow } from "../../kit/figure/beam.mjs";
+import { Curve, Marker, PlotFrame, scale } from "../../kit/figure/plot.mjs";
+import { CurrentMark } from "../../kit/magnetism/glyphs.mjs";
+import { coilTorqueActivity } from "./torque-activity.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import { angleFromPlaneDeg, coilTorqueNm, magneticMomentAm2 } from "@classytic/stage/physics/magnetism";
+
+//#region src/physics/biot-savart/torque-preset.tsx
+/**
+* CoilTorqueLab: why a motor turns, and why it stops turning twice per rotation.
+*
+* ── Viewed END-ON, deliberately ────────────────────────────────────────────────
+* The coil is drawn looking ALONG its rotation axis, so the coil plane is a
+* single line on the page and the angle it makes with the field is directly
+* visible rather than foreshortened. A pseudo-3D coil looks more impressive and
+* makes the one quantity the lesson is about impossible to read off.
+*
+* End-on also makes the couple honest: the two current-carrying sides become a
+* dot and a cross at the ends of that line, and their forces are genuinely
+* perpendicular to the page-plane field, so the arrows can be drawn at true
+* length instead of being implied.
+*
+* ── Forces do not change; their line of action does ───────────────────────────
+* This is the thing students get wrong. F = BIL on each side is CONSTANT as the
+* coil turns, because neither B, I nor L changes. What changes is the
+* perpendicular distance between the two lines of action, and that is where the
+* sine comes from. So the force arrows here are drawn the same length at every
+* angle, and the moment arm is drawn separately and visibly shrinks. Scaling the
+* arrows with the torque would teach the misconception directly.
+*/
+const VIEW_W = 460;
+const VIEW_H = 250;
+/** The end-on coil panel. */
+const COIL = {
+	cx: 128,
+	cy: 112,
+	half: 66
+};
+/** The torque curve panel. */
+const PLOT = {
+	x: 268,
+	y: 34,
+	w: 162,
+	h: 146
+};
+/** Force arrow length in px, the same at every angle because the force is. */
+const FORCE_LEN = 44;
+const fmtTorque = (nm) => {
+	const abs = Math.abs(nm);
+	if (abs >= 1) return `${nm.toPrecision(3)} N m`;
+	if (abs >= .001) return `${(nm * 1e3).toPrecision(3)} mN m`;
+	return `${(nm * 1e6).toPrecision(3)} µN m`;
+};
+function CoilTorqueLab({ planeAngleDeg: initialAngle = 30, fieldT = .35, currentA = 2.4, turns = 100, areaCm2 = 60, lockGeometry = false, title = "The turning effect on a coil", prompt, activity = coilTorqueActivity }) {
+	const [planeDeg, setPlaneDeg] = useState(initialAngle);
+	const [current, setCurrent] = useState(currentA);
+	const [field, setField] = useState(fieldT);
+	const areaM2 = areaCm2 * 1e-4;
+	const normalDeg = angleFromPlaneDeg(planeDeg);
+	const moment = magneticMomentAm2(turns, current, areaM2);
+	const torque = coilTorqueNm(field, turns, current, areaM2, normalDeg);
+	const maxTorque = moment * field;
+	/** Each side carries N I L in the field, and that never changes as it turns. */
+	const forceN = turns * field * current * Math.sqrt(areaM2);
+	const a = planeDeg * Math.PI / 180;
+	const endA = {
+		x: COIL.cx + COIL.half * Math.cos(a),
+		y: COIL.cy - COIL.half * Math.sin(a)
+	};
+	const endB = {
+		x: COIL.cx - COIL.half * Math.cos(a),
+		y: COIL.cy + COIL.half * Math.sin(a)
+	};
+	/** The moment arm: the perpendicular separation of the two lines of action. */
+	const armHalf = COIL.half * Math.cos(a);
+	const curve = useMemo(() => {
+		const s = scale(PLOT, [0, 90], [0, 1]);
+		return {
+			s,
+			points: Array.from({ length: 91 }, (_, i) => [s.x(i), s.y(Math.cos(i * Math.PI / 180))])
+		};
+	}, []);
+	const scene = /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [VIEW_W, VIEW_H],
+		domain: "physics",
+		label: "A coil turning in a magnetic field",
+		children: [
+			[
+				0,
+				1,
+				2,
+				3,
+				4
+			].map((i) => {
+				const y = 42 + i * 35;
+				return /* @__PURE__ */ jsx(Arrow, {
+					x1: 18,
+					y1: y,
+					x2: 238,
+					y2: y,
+					color: HUE.soft,
+					weight: "hair",
+					opacity: .45,
+					head: 7
+				}, i);
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 18,
+				y: 28,
+				size: "label",
+				tone: "soft",
+				children: "B, uniform"
+			}),
+			Math.abs(armHalf) < 7 ? /* @__PURE__ */ jsx(FigText, {
+				x: 18,
+				y: COIL.cy + 74,
+				size: "label",
+				tone: "hue-3",
+				anchor: "start",
+				children: "no moment arm"
+			}) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsx("line", {
+					x1: COIL.cx - armHalf,
+					y1: COIL.cy - 58,
+					x2: COIL.cx - armHalf,
+					y2: COIL.cy + 58,
+					stroke: HUE[3],
+					strokeWidth: STROKE.hair,
+					strokeDasharray: "4 3"
+				}),
+				/* @__PURE__ */ jsx("line", {
+					x1: COIL.cx + armHalf,
+					y1: COIL.cy - 58,
+					x2: COIL.cx + armHalf,
+					y2: COIL.cy + 58,
+					stroke: HUE[3],
+					strokeWidth: STROKE.hair,
+					strokeDasharray: "4 3"
+				}),
+				/* @__PURE__ */ jsx(Arrow, {
+					x1: COIL.cx - armHalf,
+					y1: COIL.cy + 66,
+					x2: COIL.cx + armHalf,
+					y2: COIL.cy + 66,
+					color: HUE[3],
+					weight: "hair",
+					double: true,
+					label: "moment arm"
+				})
+			] }),
+			/* @__PURE__ */ jsx("line", {
+				x1: endA.x,
+				y1: endA.y,
+				x2: endB.x,
+				y2: endB.y,
+				stroke: HUE.ink,
+				strokeWidth: STROKE.edge
+			}),
+			/* @__PURE__ */ jsx(Arrow, {
+				x1: COIL.cx,
+				y1: COIL.cy,
+				x2: COIL.cx + 46 * Math.cos(a + Math.PI / 2),
+				y2: COIL.cy - 46 * Math.sin(a + Math.PI / 2),
+				color: HUE[2],
+				weight: "line",
+				dashed: true,
+				label: "normal"
+			}),
+			/* @__PURE__ */ jsx(Arrow, {
+				x1: endA.x,
+				y1: endA.y,
+				x2: endA.x,
+				y2: endA.y - FORCE_LEN,
+				color: HUE.hot,
+				weight: "line",
+				label: "F"
+			}),
+			/* @__PURE__ */ jsx(Arrow, {
+				x1: endB.x,
+				y1: endB.y,
+				x2: endB.x,
+				y2: endB.y + FORCE_LEN,
+				color: HUE.hot,
+				weight: "line",
+				label: "F"
+			}),
+			/* @__PURE__ */ jsx(CurrentMark, {
+				cx: endA.x,
+				cy: endA.y,
+				currentA: current,
+				r: 7
+			}),
+			/* @__PURE__ */ jsx(CurrentMark, {
+				cx: endB.x,
+				cy: endB.y,
+				currentA: -current,
+				r: 7
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: COIL.cx,
+				y: 234,
+				size: "label",
+				tone: "soft",
+				anchor: "middle",
+				children: `plane ${planeDeg.toFixed(0)}° to B, normal ${normalDeg.toFixed(0)}°`
+			}),
+			/* @__PURE__ */ jsx(PlotFrame, {
+				...PLOT,
+				arrows: false,
+				xLabel: "angle of the PLANE to B",
+				yLabel: "torque",
+				xTicks: [
+					{
+						at: curve.s.x(0),
+						label: "0°"
+					},
+					{
+						at: curve.s.x(45),
+						label: "45°"
+					},
+					{
+						at: curve.s.x(90),
+						label: "90°"
+					}
+				],
+				yTicks: [{
+					at: curve.s.y(0),
+					label: "0"
+				}, {
+					at: curve.s.y(1),
+					label: "max"
+				}]
+			}),
+			/* @__PURE__ */ jsx(Curve, {
+				points: curve.points,
+				color: HUE[1]
+			}),
+			/* @__PURE__ */ jsx(Marker, {
+				x: curve.s.x(planeDeg),
+				y: curve.s.y(Math.abs(Math.cos(a))),
+				color: HUE[2]
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: curve.s.x(planeDeg) + (planeDeg > 58 ? -10 : 10),
+				y: curve.s.y(Math.abs(Math.cos(a))) + (planeDeg > 58 ? -12 : 16),
+				size: "label",
+				tone: "hue-2",
+				anchor: planeDeg > 58 ? "end" : "start",
+				halo: true,
+				children: fmtTorque(torque)
+			})
+		]
+	});
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Field, {
+		label: "Angle of the coil plane to the field",
+		value: `${planeDeg.toFixed(0)}°`,
+		children: /* @__PURE__ */ jsx(Slider, {
+			value: planeDeg,
+			min: 0,
+			max: 90,
+			step: 1,
+			onChange: setPlaneDeg,
+			ariaLabel: "Angle between the coil plane and the field, in degrees",
+			valueText: `${planeDeg.toFixed(0)} degrees`
+		})
+	}), lockGeometry ? null : /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Field, {
+		label: "Current",
+		value: `${current.toFixed(1)} A`,
+		children: /* @__PURE__ */ jsx(Slider, {
+			value: current,
+			min: .2,
+			max: 6,
+			step: .2,
+			onChange: setCurrent,
+			ariaLabel: "Current in amperes",
+			valueText: `${current.toFixed(1)} amperes`
+		})
+	}), /* @__PURE__ */ jsx(Field, {
+		label: "Field",
+		value: `${field.toFixed(2)} T`,
+		children: /* @__PURE__ */ jsx(Slider, {
+			value: field,
+			min: .05,
+			max: 1,
+			step: .05,
+			onChange: setField,
+			ariaLabel: "Flux density in tesla",
+			valueText: `${field.toFixed(2)} tesla`
+		})
+	})] })] });
+	const evidence = /* @__PURE__ */ jsxs(StatList, {
+		ariaLabel: "Torque on the coil",
+		children: [
+			/* @__PURE__ */ jsx(Stat, {
+				label: "Force on each side",
+				value: `${forceN.toPrecision(3)} N`
+			}),
+			/* @__PURE__ */ jsx(Stat, {
+				label: "Moment, NIA",
+				value: `${moment.toPrecision(3)} A m²`
+			}),
+			/* @__PURE__ */ jsx(Stat, {
+				label: "Torque now",
+				value: fmtTorque(torque)
+			}),
+			/* @__PURE__ */ jsx(Stat, {
+				label: "Fraction of maximum",
+				value: `${(Math.abs(torque) / maxTorque * 100).toFixed(0)}%`
+			})
+		]
+	});
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		activity,
+		activityId: "coil-torque",
+		eyebrow: "Magnetic fields",
+		title,
+		description: prompt ?? "The two forces never change size. Only the distance between their lines of action does, and that is the whole of the turning effect.",
+		controls,
+		evidence,
+		observation: planeDeg >= 88 ? "The coil now stands across the field. Both forces still act, but they pull along the SAME line, so there is nothing left to turn it. This is the dead point a motor needs a commutator to get past." : planeDeg <= 2 ? "The coil lies along the field, the two lines of action are as far apart as they can get, and the torque is at its maximum. Note that the flux through the coil is ZERO here." : void 0,
+		children: scene
+	});
+}
+
+//#endregion
+export { CoilTorqueLab };

package/dist/physics/bullet-walls/index.d.mts

@@ -1 +1,2 @@
-import { BulletWallsLab, BulletWallsProps } from "./preset.mjs";
+import { BulletWallsLab, BulletWallsProps } from "./preset.mjs";
+export { BulletWallsLab, type BulletWallsProps };

package/dist/physics/bullet-walls/model.mjs

@@ -0,0 +1,81 @@
+import { defineSimulation } from "../../kit/simulation/model.mjs";
+
+//#region src/physics/bullet-walls/model.ts
+/**
+* A bullet through a stack of planks, and the quantity that actually falls linearly.
+*
+* ── The claim the lab is built around ───────────────────────────────────────────────────────────
+* Asked how many planks a bullet will break, students halve the speed and expect twice the planks,
+* because speed is the number they were given. It is `v²` that falls in equal steps, not `v`: a
+* constant retarding force over a fixed thickness removes a fixed amount of KINETIC ENERGY, and
+* `v² = u² − 2as` is that statement. So a bullet at 2v goes through four times as many planks as
+* one at v, not twice as many.
+*
+* That is a prediction the lab invites before firing, and until this model existed nothing checked
+* it. The integrator lived in a `useFrameTick` callback and its only witness was a moving dot.
+*
+* ── Why the bullet's position is integrated rather than solved ──────────────────────────────────
+* The closed form is available and is what `penetrationDepth` in the lab already reports. The
+* integration exists to be WATCHED: the whole point is seeing the bullet slow in each plank and
+* then either emerge or stop inside one, and a lab that jumped to the answer would be a different
+* lab. The model therefore carries position and `v²` forward, and the closed form stays beside it
+* as the thing the animation must agree with.
+*
+* `v²` is carried rather than `v` because the physics is linear in `v²`: carrying the speed would
+* mean a square root and a squaring on every single step, which is arithmetic noise added to the
+* one quantity the lesson is about.
+*/
+/** World width of a plank. */
+const PLANK_W = .7;
+/** Where the stack starts. */
+const STACK_X0 = 0;
+/** Where the bullet starts. */
+const START_X = -4;
+/** Metres per second to world units per second on screen. */
+const SPEED_SCALE = .25;
+/** The left face of plank `i`. */
+const faceX = (i) => 0 + i * 1.7;
+/** How far past the last plank counts as having left the stack. */
+const CLEAR = .5;
+/** Is this position inside an intact plank? */
+function insidePlank(x, planks) {
+	for (let i = 0; i < planks; i++) {
+		const a = faceX(i);
+		if (x >= a && x < a + .7) return true;
+	}
+	return false;
+}
+const bulletFlight = defineSimulation({
+	init: ({ speed }) => ({
+		x: -4,
+		v2: speed * speed,
+		stopped: false
+	}),
+	step: (state, dt, { cost, planks }) => {
+		if (state.stopped) return state;
+		const dx = Math.sqrt(Math.max(0, state.v2)) * SPEED_SCALE * dt;
+		let x = state.x;
+		let v2 = state.v2;
+		if (insidePlank(x, planks)) {
+			const dV2 = cost / PLANK_W * dx;
+			if (dV2 >= v2) {
+				x += v2 / cost * PLANK_W;
+				v2 = 0;
+			} else {
+				x += dx;
+				v2 -= dV2;
+			}
+		} else x += dx;
+		const exited = x >= faceX(planks - 1) + PLANK_W + CLEAR;
+		return {
+			x,
+			v2,
+			stopped: v2 <= 0 || exited
+		};
+	},
+	done: (state) => state.stopped,
+	fixedStepS: 1 / 240
+});
+
+//#endregion
+export { PLANK_W, SPEED_SCALE, bulletFlight, faceX, insidePlank };

package/dist/physics/bullet-walls/preset.d.mts

@@ -1,7 +1,6 @@
 import { AuthoredActivity } from "../../kit/activity-authoring.mjs";
 import { ControlConfig } from "../../kit/frame.mjs";
 import { ReactNode } from "react";
-
 //#region src/physics/bullet-walls/preset.d.ts
 interface BulletWallsProps {
   speed?: number;
@@ -16,16 +15,6 @@ interface BulletWallsProps {
   /** Lock/hide any knob, e.g. `{ lock: ['plank toughness'] }` to fix the toughness. */
   controlConfig?: ControlConfig;
 }
-declare function BulletWallsLab({
-  speed,
-  toughness,
-  planks,
-  mass,
-  title,
-  prompt,
-  objectives,
-  controlConfig,
-  activity
-}: BulletWallsProps): ReactNode;
+declare function BulletWallsLab({ speed, toughness, planks, mass, title, prompt, objectives, controlConfig, activity }: BulletWallsProps): ReactNode;
 //#endregion
 export { BulletWallsLab, BulletWallsProps };

package/dist/physics/bullet-walls/preset.mjs

@@ -7,9 +7,11 @@ import { Figure, HUE } from "../../kit/figure/figure.mjs";
 import { FigTag, FigText } from "../../kit/figure/text.mjs";
 import { Ground } from "../../kit/figure/beam.mjs";
 import { MaterialBarrier, ProjectileGlyph, SceneSurface, SimulationTransport } from "../mechanics/presentation.mjs";
-import { useFrameTick, useReducedMotion } from "../../kit/anim.mjs";
+import { useReducedMotion } from "../../kit/anim.mjs";
+import { useSimulation } from "../../kit/simulation/use-simulation.mjs";
 import { penetrationResult } from "../mechanics/core.mjs";
-import { useRef, useState } from "react";
+import { bulletFlight } from "./model.mjs";
+import { useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { useInView, useLearner } from "@classytic/stage";
 
@@ -32,7 +34,6 @@ import { useInView, useLearner } from "@classytic/stage";
 * Tokenized SVG; time-dependent integrator here; honours reduced-motion.
 */
 const PLANK_W = .7;
-const START_X = -4;
 const STACK_X0 = 0;
 function BulletWallsLab({ speed = 30, toughness = 160, planks = 6, mass = .02, title = "How many planks?: bet, then fire", prompt = "Each plank steals the same chunk of energy. Guess how many the bullet smashes through, then fire and watch the speed (and the energy bar) drain plank by plank.", objectives, controlConfig, activity }) {
 	const [v0, setV0] = useState(speed);
@@ -41,8 +42,6 @@ function BulletWallsLab({ speed = 30, toughness = 160, planks = 6, mass = .02, t
 	const [guess, setGuess] = useState(2);
 	const [running, setRunning] = useState(false);
 	const [fired, setFired] = useState(false);
-	const xRef = useRef(START_X);
-	const v2Ref = useRef(v0 * v0);
 	const reduce = useReducedMotion();
 	const learner = useLearner();
 	const { ref: viewRef, inView } = useInView();
@@ -52,35 +51,15 @@ function BulletWallsLab({ speed = 30, toughness = 160, planks = 6, mass = .02, t
 	const fullPenetrated = penetration.fullPenetrated;
 	const stopsInsideStack = !penetration.exitsStack;
 	const lodgeDepth = penetration.lodgeFraction * PLANK_W;
-	const SPEED_SCALE = .25;
-	const repaint = useFrameTick(running && inView, (f) => {
-		const dt = Math.min(.04, f.dtMs / 1e3);
-		let x = xRef.current;
-		let v2 = v2Ref.current;
-		let dx = Math.sqrt(Math.max(0, v2)) * SPEED_SCALE * dt;
-		let inside = false;
-		for (let i = 0; i < n; i++) {
-			const a = faceX(i), b = a + PLANK_W;
-			if (x >= a && x < b) {
-				inside = true;
-				break;
-			}
-		}
-		if (inside) {
-			const dV2 = cost / PLANK_W * dx;
-			if (dV2 >= v2) {
-				const allowed = v2 / cost * PLANK_W;
-				x += allowed;
-				v2 = 0;
-			} else {
-				x += dx;
-				v2 -= dV2;
-			}
-		} else x += dx;
-		xRef.current = x;
-		v2Ref.current = v2;
-		const exited = x >= faceX(n - 1) + PLANK_W + .5;
-		if (v2 <= 0 || exited) {
+	const sim = useSimulation(bulletFlight, {
+		speed: v0,
+		cost,
+		planks: n
+	}, {
+		running,
+		active: inView,
+		reducedMotion: "finish",
+		onDone: () => {
 			setRunning(false);
 			learner?.report({
 				activity: "bullet-walls",
@@ -95,13 +74,14 @@ function BulletWallsLab({ speed = 30, toughness = 160, planks = 6, mass = .02, t
 		}
 	});
 	const fire = () => {
-		xRef.current = START_X;
-		v2Ref.current = v0 * v0;
+		sim.reset();
 		setFired(true);
 		if (reduce) {
-			xRef.current = stopsInsideStack ? faceX(fullPenetrated) + lodgeDepth : faceX(n - 1) + PLANK_W + .5;
-			v2Ref.current = stopsInsideStack ? 0 : v0 * v0 - n * cost;
-			repaint();
+			sim.set({
+				x: stopsInsideStack ? faceX(fullPenetrated) + lodgeDepth : faceX(n - 1) + PLANK_W + .5,
+				v2: stopsInsideStack ? 0 : v0 * v0 - n * cost,
+				stopped: true
+			});
 			return;
 		}
 		setRunning(true);
@@ -110,21 +90,20 @@ function BulletWallsLab({ speed = 30, toughness = 160, planks = 6, mass = .02, t
 		set(x);
 		setRunning(false);
 		setFired(false);
-		xRef.current = START_X;
-		v2Ref.current = (set === setV0 ? x : v0) ** 2;
+		sim.reset();
 	};
-	const bx = xRef.current;
-	const vNow = Math.sqrt(Math.max(0, v2Ref.current));
-	const keNow = .5 * mass * v2Ref.current;
+	const bx = sim.state.x;
+	const vNow = Math.sqrt(Math.max(0, sim.state.v2));
+	const keNow = .5 * mass * sim.state.v2;
 	let broken = 0;
 	for (let i = 0; i < n; i++) if (bx >= faceX(i) + PLANK_W) broken++;
 	const settled = fired && !running;
 	const stackEnd = faceX(n - 1) + PLANK_W;
 	const sceneLeft = 42;
 	const sceneRight = 684;
-	const worldLeft = START_X - 1.3;
+	const worldLeft = -5.3;
 	const worldRight = stackEnd + 1.5;
-	const toSceneX = (x) => sceneLeft + (x - worldLeft) / (worldRight - worldLeft) * (sceneRight - sceneLeft);
+	const toSceneX = (x) => sceneLeft + (x - worldLeft) / (worldRight - worldLeft) * 642;
 	const plankWidth = Math.max(10, toSceneX(.7) - toSceneX(STACK_X0));
 	const figure = /* @__PURE__ */ jsx(SceneSurface, {
 		ref: viewRef,
@@ -186,7 +165,7 @@ function BulletWallsLab({ speed = 30, toughness = 160, planks = 6, mass = .02, t
 					children: `${vNow.toFixed(0)} m/s`
 				}),
 				settled ? /* @__PURE__ */ jsx(FigTag, {
-					x: Math.min(sceneRight - 68, Math.max(117, toSceneX(bx))),
+					x: Math.min(616, Math.max(117, toSceneX(bx))),
 					y: 54,
 					anchor: "middle",
 					color: stopsInsideStack ? HUE.warn : HUE.good,
@@ -286,8 +265,7 @@ function BulletWallsLab({ speed = 30, toughness = 160, planks = 6, mass = .02, t
 	const reset = () => {
 		setRunning(false);
 		setFired(false);
-		xRef.current = START_X;
-		v2Ref.current = v0 ** 2;
+		sim.reset();
 	};
 	const transport = /* @__PURE__ */ jsx(SimulationTransport, {
 		running,

package/dist/physics/carnot/index.d.mts

@@ -1 +1,2 @@
-import { CarnotCycleLab, CarnotProps } from "./preset.mjs";
+import { CarnotCycleLab, CarnotProps } from "./preset.mjs";
+export { CarnotCycleLab, type CarnotProps };

package/dist/physics/carnot/preset.d.mts

@@ -1,6 +1,5 @@
 import { AuthoredActivity } from "../../kit/activity-authoring.mjs";
 import { ReactNode } from "react";
-
 //#region src/physics/carnot/preset.d.ts
 interface CarnotProps {
   /** Initial hot-reservoir temperature, K (default 500). */
@@ -16,15 +15,6 @@ interface CarnotProps {
   objectives?: string[];
   activity?: string | AuthoredActivity;
 }
-declare function CarnotCycleLab({
-  hotK,
-  coldK,
-  gas,
-  expansionRatio,
-  title,
-  prompt,
-  objectives,
-  activity
-}?: CarnotProps): ReactNode;
+declare function CarnotCycleLab({ hotK, coldK, gas, expansionRatio, title, prompt, objectives, activity }?: CarnotProps): ReactNode;
 //#endregion
 export { CarnotCycleLab, CarnotProps };