@classytic/labs 0.1.0 → 0.3.0

package/dist/physics/stress-strain/preset.mjs

@@ -0,0 +1,683 @@
+'use client';
+
+import { Tex } from "../../core/tex.mjs";
+import { ActivitySelect, Slider } from "../../kit/controls.mjs";
+import { Field, Readout, Stat, StatList } from "../../kit/frame.mjs";
+import { AuthoredActivityRuntime, AuthoredMetricGate } from "../../kit/authored-activity-runtime.mjs";
+import { Figure, HUE, fmt } from "../../kit/figure/figure.mjs";
+import { FigText } from "../../kit/figure/text.mjs";
+import { Block } from "../../kit/figure/body.mjs";
+import { Arrow } from "../../kit/figure/beam.mjs";
+import { Area, Curve, Guide, Marker, PlotFrame, scale } from "../../kit/figure/plot.mjs";
+import { MATERIALS, limitStrain, material, plotStrainMax, plotStressMax, stressStrainCurve, wireState } from "./core.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/stress-strain/preset.tsx
+/**
+* StressStrainLab, Cambridge A Level Physics 9702 chapter 6 (deformation of solids).
+*
+* A wire hangs from a clamp and carries a load. The learner picks the material, the diameter,
+* the original length and the load, and reads the extension. Beside the wire sits ONE plot with
+* two modes, and the contrast between them is the entire lesson:
+*
+*   force against extension   gradient k = A E / L   moves when the wire's SIZE changes
+*   stress against strain     gradient E             does not move: E belongs to the MATERIAL
+*
+* The invariance is structural, not cosmetic. The stress-strain curve and both of its axis
+* ranges come from `core.ts` functions that never receive the diameter or the length, so the
+* line is drawn from identical numbers for a thin wire and a thick one. The learner can swing
+* the force-extension line all over the frame, switch mode, and find the stress-strain line
+* exactly where they left it.
+*
+* The physics (materials, the model curve, the energy) lives in `core.ts`, outside React.
+*/
+const W = 720;
+const H = 380;
+const PLOT = {
+	x: 322,
+	y: 62,
+	w: 344,
+	h: 236
+};
+const WIRE_X = 152;
+const WIRE_TOP = 46;
+const LEN_MIN = .5;
+const LEN_MAX = 3;
+const DIA_MIN = .1;
+const DIA_MAX = 2;
+const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+/** Unicode superscript for a signed integer exponent, so readouts can print 6.74 × 10⁻⁴. */
+const SUPERSCRIPT = "⁰¹²³⁴⁵⁶⁷⁸⁹";
+function sup(exponent) {
+	const digits = String(Math.abs(exponent)).split("").map((d) => SUPERSCRIPT[Number(d)] ?? d).join("");
+	return (exponent < 0 ? "⁻" : "") + digits;
+}
+/** "6.74 × 10⁻⁴" for a readout. */
+function sciText(value, digits = 2) {
+	if (!Number.isFinite(value) || value === 0) return "0";
+	const e = Math.floor(Math.log10(Math.abs(value)));
+	return `${(value / 10 ** e).toFixed(digits)} × 10${sup(e)}`;
+}
+/** "6.74\times10^{-4}" for KaTeX. */
+function sciTex(value, digits = 2) {
+	if (!Number.isFinite(value) || value === 0) return "0";
+	const e = Math.floor(Math.log10(Math.abs(value)));
+	return `${(value / 10 ** e).toFixed(digits)}\\times 10^{${e}}`;
+}
+/** Three significant figures, without trailing zeros. */
+const num = (value, digits = 3) => Number(value.toPrecision(digits)).toString();
+/** Round tick values from 0 up to `max`, aiming for about `target` of them. */
+function axisTicks(max, target = 5) {
+	if (!(max > 0)) return [];
+	const raw = max / target;
+	const magnitude = 10 ** Math.floor(Math.log10(raw));
+	const step = ([
+		1,
+		2,
+		2.5,
+		5,
+		10
+	].find((s) => s * magnitude >= raw) ?? 10) * magnitude;
+	const out = [];
+	for (let i = 1; i * step <= max * 1.0001; i++) out.push(i * step);
+	return out;
+}
+/**
+* Keep a rising curve inside the plot box, cutting it exactly at the edge it leaves through.
+* Both plotted quantities increase together, so one pass is enough.
+*/
+function clipRising(points, xMax, yMax) {
+	const out = [];
+	for (const p of points) {
+		if (p[0] <= xMax && p[1] <= yMax) {
+			out.push(p);
+			continue;
+		}
+		const prev = out[out.length - 1];
+		if (prev) {
+			const tx = p[0] > xMax ? (xMax - prev[0]) / (p[0] - prev[0] || 1) : 1;
+			const ty = p[1] > yMax ? (yMax - prev[1]) / (p[1] - prev[1] || 1) : 1;
+			const t = clamp(Math.min(tx, ty), 0, 1);
+			out.push([prev[0] + (p[0] - prev[0]) * t, prev[1] + (p[1] - prev[1]) * t]);
+		}
+		break;
+	}
+	return out;
+}
+const STRESS_STRAIN_ACTIVITY = {
+	pattern: "investigation",
+	title: "Stress and strain: the graph that ignores the wire",
+	objectives: [
+		"Read the spring constant k as the gradient of a force against extension graph",
+		"Read the Young modulus E as the gradient of a stress against strain graph",
+		"Explain why changing the diameter or the length moves one graph and not the other"
+	],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Predict what a thinner wire does",
+			lead: "Commit to an answer before you touch a slider.",
+			success: "invariance-answer"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Change the wire, watch the force line swing",
+			lead: "Change the diameter or the original length. Watch the gradient of the force against extension line.",
+			controls: true,
+			reveal: ["model"],
+			success: "wire-changed"
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Switch to stress and strain",
+			lead: "Switch the graph. The wire has changed, so check whether this line has moved.",
+			controls: true,
+			reveal: ["model", "evidence"],
+			success: "graph-switched"
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Explain the gradient",
+			lead: "Say what the gradient of each graph belongs to.",
+			success: "gradient-answer"
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Change the material",
+			lead: "Now change the material. This is the one change that does move the stress and strain line.",
+			controls: true,
+			reveal: ["model", "evidence"],
+			success: "material-changed"
+		}
+	],
+	questions: [{
+		id: "invariance",
+		prompt: "You keep the same material but swap to a thinner wire. On the stress and strain graph, the line will…",
+		choices: [
+			{
+				value: "same",
+				label: "stay exactly where it is"
+			},
+			{
+				value: "steeper",
+				label: "become steeper"
+			},
+			{
+				value: "shallower",
+				label: "become less steep"
+			}
+		],
+		answer: "same",
+		explain: "Stress is force divided by area. Strain is extension divided by original length. Both numbers already take the size of the wire into account. Only the material is left, so the gradient stays at E."
+	}, {
+		id: "gradient",
+		prompt: "The gradient of the stress and strain graph is the Young modulus E. Which statement is true?",
+		choices: [
+			{
+				value: "material",
+				label: "E belongs to the material, so every steel wire gives the same E"
+			},
+			{
+				value: "wire",
+				label: "E belongs to the wire, so a thicker wire has a larger E"
+			},
+			{
+				value: "load",
+				label: "E depends on the load you hang on the wire"
+			}
+		],
+		answer: "material",
+		explain: "E = stress / strain. A thicker wire carries more force, but it also has more area, so the stress is unchanged. A longer wire stretches further, but it also has more original length, so the strain is unchanged."
+	}],
+	success: [
+		{
+			id: "invariance-answer",
+			source: "answer",
+			key: "invariance",
+			operator: "eq",
+			value: "same",
+			pendingLabel: "Predict what a thinner wire does to the stress and strain line."
+		},
+		{
+			id: "wire-changed",
+			source: "metric",
+			key: "wireChanged",
+			operator: "eq",
+			value: true,
+			pendingLabel: "Change the diameter or the original length."
+		},
+		{
+			id: "graph-switched",
+			source: "metric",
+			key: "graphSwitched",
+			operator: "eq",
+			value: true,
+			pendingLabel: "Switch to the other graph."
+		},
+		{
+			id: "gradient-answer",
+			source: "answer",
+			key: "gradient",
+			operator: "eq",
+			value: "material",
+			pendingLabel: "Say what the Young modulus belongs to."
+		},
+		{
+			id: "material-changed",
+			source: "metric",
+			key: "materialChanged",
+			operator: "eq",
+			value: true,
+			pendingLabel: "Choose a different material."
+		}
+	]
+};
+function StressStrainLab({ material: material0 = "steel", diameterMm: diameter0 = .6, lengthM: length0 = 2, loadN: load0 = 40, graph: graph0 = "force-extension", loadAxisN = 100, extensionAxisMm = 5, title = "Stress, strain and the Young modulus", prompt = "A wire stretches when you load it. The force against extension graph describes this one wire. The stress against strain graph describes the material it is made of. Change the wire and see which graph moves.", objectives, activity = "stress-strain" } = {}) {
+	const activityId = typeof activity === "string" ? activity : "stress-strain";
+	const authoredActivity = typeof activity === "string" ? STRESS_STRAIN_ACTIVITY : activity;
+	const [materialId, setMaterialId] = useState(material0);
+	const [diameter, setDiameter] = useState(diameter0);
+	const [length, setLength] = useState(length0);
+	const [load, setLoad] = useState(load0);
+	const [graph, setGraph] = useState(graph0);
+	const mat = material(materialId);
+	const state = wireState({
+		material: mat,
+		diameterMm: diameter,
+		lengthM: length,
+		loadN: load
+	});
+	const isStrain = graph === "stress-strain";
+	const heldStress = state.broken ? mat.limitStress : state.stressPa;
+	const heldLoad = heldStress * state.areaM2;
+	const toData = (p) => isStrain ? [p.strain * 1e3, p.stress / 1e6] : [p.strain * length * 1e3, p.stress * state.areaM2];
+	const xMax = isStrain ? plotStrainMax(mat) * 1e3 : extensionAxisMm;
+	const yMax = isStrain ? plotStressMax(mat) / 1e6 : loadAxisN;
+	const sc = scale(PLOT, [0, xMax], [0, yMax]);
+	const baseY = PLOT.y + PLOT.h;
+	const px = (p) => [sc.x(p[0]), sc.y(p[1])];
+	const samples = stressStrainCurve(mat);
+	const curve = clipRising(samples.map(toData), xMax, yMax);
+	const nowData = isStrain ? [state.strain * 1e3, heldStress / 1e6] : [state.extensionM * 1e3, heldLoad];
+	const filled = clipRising([...samples.filter((p) => p.stress < heldStress).map(toData), nowData], xMax, yMax);
+	const nowOnPlot = nowData[0] <= xMax && nowData[1] <= yMax;
+	const elasticEnd = isStrain ? plotStrainMax(mat) * 1.2 : Math.max(xMax / (length * 1e3), yMax / (state.areaM2 * mat.E)) * 1.05;
+	const elastic = clipRising([[0, 0], toData({
+		strain: elasticEnd,
+		stress: elasticEnd * mat.E
+	})], xMax, yMax);
+	const limitData = toData({
+		strain: limitStrain(mat),
+		stress: mat.limitStress
+	});
+	const limitOnPlot = limitData[0] <= xMax && limitData[1] <= yMax;
+	const limitPx = px(limitData);
+	const wirePx = 2 + (clamp(diameter, DIA_MIN, DIA_MAX) - DIA_MIN) / (DIA_MAX - DIA_MIN) * 8;
+	const lengthPx = 100 + (clamp(length, LEN_MIN, LEN_MAX) - LEN_MIN) / (LEN_MAX - LEN_MIN) * 70;
+	const restBottom = WIRE_TOP + lengthPx;
+	const extPx = clamp(state.extensionM * 1e3 * 6, 0, 26);
+	const fallenY = restBottom + 26;
+	const breakY = WIRE_TOP + lengthPx * .5;
+	const loadTop = state.broken ? fallenY : restBottom + extPx;
+	const figure = /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [W, H],
+		domain: "physics",
+		label: `A ${mat.label} wire of diameter ${num(diameter)} millimetres and original length ${num(length)} metres carries ${num(load)} newtons and extends ${num(state.extensionM * 1e3)} millimetres. The graph shows ${isStrain ? "stress against strain" : "force against extension"}.`,
+		children: [
+			/* @__PURE__ */ jsxs(FigText, {
+				x: 24,
+				y: 24,
+				size: "title",
+				children: [mat.label, " wire under load"]
+			}),
+			/* @__PURE__ */ jsx(Block, {
+				x: 88,
+				y: 30,
+				w: 128,
+				h: 14,
+				color: HUE.metal,
+				radius: 3
+			}),
+			/* @__PURE__ */ jsx(Arrow, {
+				x1: 100,
+				y1: WIRE_TOP,
+				x2: 100,
+				y2: restBottom,
+				color: HUE.soft,
+				weight: "line",
+				head: 5,
+				double: true
+			}),
+			/* @__PURE__ */ jsxs(FigText, {
+				x: 94,
+				y: (WIRE_TOP + restBottom) / 2,
+				anchor: "end",
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: [
+					"L = ",
+					length.toFixed(1),
+					" m"
+				]
+			}),
+			state.broken ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsx(Block, {
+					x: WIRE_X - wirePx / 2,
+					y: WIRE_TOP,
+					w: wirePx,
+					h: breakY - WIRE_TOP,
+					color: mat.colour,
+					style: mat.opacity ? { opacity: mat.opacity } : void 0,
+					radius: 1
+				}),
+				/* @__PURE__ */ jsx(Block, {
+					x: WIRE_X - wirePx / 2,
+					y: breakY + 16,
+					w: wirePx,
+					h: fallenY - breakY - 16,
+					color: mat.colour,
+					style: mat.opacity ? { opacity: mat.opacity } : void 0,
+					radius: 1
+				}),
+				/* @__PURE__ */ jsx(FigText, {
+					x: 166,
+					y: breakY + 8,
+					size: "note",
+					tone: "hot",
+					children: "it snapped"
+				})
+			] }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				/* @__PURE__ */ jsx(Block, {
+					x: WIRE_X - wirePx / 2,
+					y: WIRE_TOP,
+					w: wirePx,
+					h: restBottom + extPx - WIRE_TOP,
+					color: mat.colour,
+					style: mat.opacity ? { opacity: mat.opacity } : void 0,
+					radius: 1
+				}),
+				/* @__PURE__ */ jsx(Guide, {
+					x1: WIRE_X - 64,
+					y1: restBottom,
+					x2: 216,
+					y2: restBottom,
+					color: HUE.soft
+				}),
+				extPx > .5 && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Arrow, {
+					x1: 194,
+					y1: restBottom,
+					x2: 194,
+					y2: restBottom + Math.max(extPx, 11),
+					color: HUE[2],
+					weight: "line",
+					head: 5
+				}), /* @__PURE__ */ jsxs(FigText, {
+					x: 201,
+					y: restBottom + Math.max(extPx, 11) / 2,
+					baseline: "middle",
+					size: "note",
+					tone: "hue-2",
+					children: [
+						"x = ",
+						num(state.extensionM * 1e3),
+						" mm"
+					]
+				})] })
+			] }),
+			/* @__PURE__ */ jsxs(FigText, {
+				x: WIRE_X + wirePx / 2 + 10,
+				y: 72,
+				size: "note",
+				tone: "soft",
+				children: [
+					"d = ",
+					diameter.toFixed(2),
+					" mm"
+				]
+			}),
+			/* @__PURE__ */ jsx(Block, {
+				x: WIRE_X - 31,
+				y: loadTop,
+				w: 62,
+				h: 30,
+				color: HUE[3],
+				label: "load",
+				radius: 4
+			}),
+			/* @__PURE__ */ jsx(Arrow, {
+				x1: WIRE_X,
+				y1: loadTop + 30,
+				x2: WIRE_X,
+				y2: loadTop + 64,
+				color: HUE.hot,
+				weight: "edge"
+			}),
+			/* @__PURE__ */ jsxs(FigText, {
+				x: 166,
+				y: loadTop + 52,
+				baseline: "middle",
+				size: "note",
+				tone: "hot",
+				children: [
+					"F = ",
+					num(load),
+					" N"
+				]
+			}),
+			/* @__PURE__ */ jsxs(PlotFrame, {
+				...PLOT,
+				arrows: false,
+				title: isStrain ? "stress against strain" : "force against extension",
+				xLabel: isStrain ? "strain ε (×10⁻³)" : "extension x (mm)",
+				yLabel: isStrain ? "stress σ (MPa)" : "force F (N)",
+				xTicks: axisTicks(xMax).map((v) => ({
+					at: sc.x(v),
+					label: fmt(v, 2)
+				})),
+				yTicks: axisTicks(yMax).map((v) => ({
+					at: sc.y(v),
+					label: fmt(v, 2)
+				})),
+				children: [
+					filled.length > 1 && /* @__PURE__ */ jsx(Area, {
+						points: filled.map(px),
+						baseY,
+						color: HUE[2],
+						opacity: 26
+					}),
+					elastic.length > 1 && /* @__PURE__ */ jsx(Curve, {
+						points: elastic.map(px),
+						color: HUE.soft,
+						dashed: true,
+						weight: "line"
+					}),
+					curve.length > 1 && /* @__PURE__ */ jsx(Curve, {
+						points: curve.map(px),
+						color: HUE[1]
+					}),
+					limitOnPlot && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Guide, {
+						x1: limitPx[0],
+						y1: baseY,
+						x2: limitPx[0],
+						y2: limitPx[1],
+						color: HUE.warn
+					}), /* @__PURE__ */ jsx(Marker, {
+						x: limitPx[0],
+						y: limitPx[1],
+						r: 4.5,
+						color: HUE.warn
+					})] }),
+					nowOnPlot && /* @__PURE__ */ jsx(Marker, {
+						x: sc.x(nowData[0]),
+						y: sc.y(nowData[1]),
+						r: 5,
+						color: HUE[1]
+					}),
+					!nowOnPlot && /* @__PURE__ */ jsx(FigText, {
+						x: PLOT.x + PLOT.w - 8,
+						y: PLOT.y + (isStrain ? 14 : 32),
+						anchor: "end",
+						size: "note",
+						tone: "hot",
+						children: "this load is off the scale"
+					})
+				]
+			})
+		]
+	});
+	const evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Readout, {
+			label: "gradient of this graph",
+			value: isStrain ? `E = ${num(mat.E / 1e9)} GPa` : `k = ${sciText(state.springConstantNPerM)} N/m`,
+			sub: isStrain ? "The Young modulus. It is the same for every wire made of this material." : "The spring constant of this wire only. k = A E / L, so it changes with the diameter and the length."
+		}),
+		/* @__PURE__ */ jsxs(StatList, { children: [
+			/* @__PURE__ */ jsx(Stat, {
+				label: "area A = πd²/4",
+				value: `${sciText(state.areaM2)} m²`
+			}),
+			/* @__PURE__ */ jsx(Stat, {
+				label: "stress σ = F/A",
+				value: `${num(state.stressPa / 1e6)} MPa`
+			}),
+			/* @__PURE__ */ jsx(Stat, {
+				label: "strain ε = x/L",
+				value: sciText(state.strain)
+			}),
+			/* @__PURE__ */ jsx(Stat, {
+				label: "extension x",
+				value: `${num(state.extensionM * 1e3)} mm`
+			}),
+			/* @__PURE__ */ jsx(Stat, {
+				label: "elastic energy Eₚ",
+				value: `${num(state.energyJ)} J`,
+				tone: state.beyondLimit ? "warn" : void 0
+			})
+		] }),
+		/* @__PURE__ */ jsxs("div", {
+			className: "physics-probe",
+			children: [/* @__PURE__ */ jsx("strong", {
+				className: "physics-equation-result",
+				children: /* @__PURE__ */ jsx(Tex, { tex: isStrain ? `E=\\frac{\\sigma}{\\varepsilon}=\\frac{${sciTex(state.stressPa)}}{${sciTex(state.strain)}}=${sciTex(mat.E)}\\,\\mathrm{Pa}` : `k=\\frac{AE}{L}=\\frac{${sciTex(state.areaM2)}\\times ${sciTex(mat.E)}}{${num(length)}}=${sciTex(state.springConstantNPerM)}\\,\\mathrm{N/m}` })
+			}), /* @__PURE__ */ jsx("small", { children: state.beyondLimit ? "Past the limit of proportionality the line bends, so this ratio no longer holds." : isStrain ? "Below the limit of proportionality, stress divided by strain is a constant: the Young modulus." : "The stiffer, thicker or shorter the wire, the larger k is." })]
+		}),
+		/* @__PURE__ */ jsx("p", {
+			className: "physics-explain",
+			children: state.broken ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				"Glass has no plastic region. The line stays straight, then the wire snaps at",
+				" ",
+				num(mat.limitStress / 1e6),
+				" MPa. The energy stored just before the break was ",
+				num(state.energyJ),
+				" ",
+				"J."
+			] }) : state.beyondLimit ? /* @__PURE__ */ jsx(Fragment$1, { children: "The load has taken the wire past the limit of proportionality, so the shaded area is no longer ½Fx. The wire will stay stretched when you take the load off." }) : /* @__PURE__ */ jsxs(Fragment$1, { children: [
+				"The shaded area under the force against extension graph is the elastic potential energy,",
+				" ",
+				num(state.energyJ),
+				" J. It equals ½Fx only here, in the straight part of the graph."
+			] })
+		})
+	] });
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Field, {
+			label: "material",
+			children: /* @__PURE__ */ jsx(ActivitySelect, {
+				ariaLabel: "material",
+				value: materialId,
+				onChange: setMaterialId,
+				options: MATERIALS.map((m) => ({
+					value: m.id,
+					label: m.label
+				}))
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "graph",
+			children: /* @__PURE__ */ jsx(ActivitySelect, {
+				ariaLabel: "graph",
+				value: graph,
+				onChange: setGraph,
+				options: [{
+					value: "force-extension",
+					label: "force and extension"
+				}, {
+					value: "stress-strain",
+					label: "stress and strain"
+				}]
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "diameter",
+			value: `${diameter.toFixed(2)} mm`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: diameter,
+				min: DIA_MIN,
+				max: DIA_MAX,
+				step: .05,
+				onChange: setDiameter,
+				ariaLabel: "wire diameter in millimetres"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "original length",
+			value: `${length.toFixed(1)} m`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: length,
+				min: LEN_MIN,
+				max: LEN_MAX,
+				step: .1,
+				onChange: setLength,
+				ariaLabel: "original length in metres"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "load",
+			value: `${num(load)} N`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: load,
+				min: 0,
+				max: loadAxisN,
+				step: 1,
+				onChange: setLoad,
+				ariaLabel: "load in newtons"
+			})
+		})
+	] });
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		className: "physics-stress-strain",
+		focusLayout: "immersive",
+		activity: {
+			...authoredActivity,
+			objectives: objectives ?? authoredActivity.objectives
+		},
+		activityId,
+		eyebrow: "Deformation of solids",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("span", { children: mat.label }),
+			/* @__PURE__ */ jsxs("span", { children: [
+				"x ",
+				num(state.extensionM * 1e3),
+				" mm"
+			] }),
+			/* @__PURE__ */ jsx("span", { children: state.broken ? "snapped" : state.beyondLimit ? "past the limit" : "proportional" })
+		] }),
+		evidence,
+		controls,
+		observation: isStrain ? "Dividing the force by the area and the extension by the original length removes the size of the wire. Only the material is left, so this line holds still while you change the diameter and the length. Its gradient is the Young modulus E." : "This line belongs to one wire. A thicker or shorter wire is stiffer, so the line swings up. The gradient is k = A E / L, and A and L are both yours to change.",
+		transcript: /* @__PURE__ */ jsxs("p", { children: [
+			"A ",
+			mat.label,
+			" wire, diameter ",
+			num(diameter),
+			" mm, original length ",
+			num(length),
+			" m, carries",
+			" ",
+			num(load),
+			" N. Stress ",
+			num(state.stressPa / 1e6),
+			" MPa, strain ",
+			sciText(state.strain),
+			", extension",
+			" ",
+			num(state.extensionM * 1e3),
+			" mm. Spring constant ",
+			sciText(state.springConstantNPerM),
+			" N/m; Young modulus ",
+			num(mat.E / 1e9),
+			" GPa. ",
+			mat.note
+		] }),
+		children: ({ complete }) => /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(AuthoredMetricGate, {
+				conditionId: "wire-changed",
+				met: diameter !== diameter0 || length !== length0,
+				complete
+			}),
+			/* @__PURE__ */ jsx(AuthoredMetricGate, {
+				conditionId: "graph-switched",
+				met: graph !== graph0,
+				complete
+			}),
+			/* @__PURE__ */ jsx(AuthoredMetricGate, {
+				conditionId: "material-changed",
+				met: materialId !== material0,
+				complete
+			}),
+			figure
+		] })
+	});
+}
+
+//#endregion
+export { StressStrainLab };

package/dist/physics/temperature-scales/index.d.mts

@@ -1 +1 @@
-import { TemperatureScalesLab, TemperatureScalesProps } from "./preset.mjs";
+import { TemperaturePreset, TemperatureScalesLab, TemperatureScalesProps } from "./preset.mjs";