@classytic/labs 0.1.0

package/dist/physics/energy-skate/preset.mjs

@@ -0,0 +1,254 @@
+'use client';
+
+import { clamp } from "../../core/util.mjs";
+import { CheckButton, Chip, Slider } from "../../kit/controls.mjs";
+import { Callout, Control, ControlBar, Field, LabFrame, LiveRegion, MeterBar } from "../../kit/frame.mjs";
+import { useFrameTick, useReducedMotion } from "../../kit/anim.mjs";
+import { useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Label, Polyline, Segment, Stage, useInView } from "@classytic/stage";
+
+//#region src/physics/energy-skate/preset.tsx
+/**
+* EnergySkateLab — "Where did the energy go?", KE ⇄ PE on a ramp, with friction
+* bleeding the total into heat.
+*
+* A skater is released from a height on a parabolic ramp. Three stacked bars —
+* potential, kinetic, and thermal — ALWAYS sum to the same total: as the skater
+* drops, the PE bar empties into the KE bar and back on the way up. Turn friction
+* on and a THERMAL bar grows each pass, so the skater can never climb as high
+* again — mechanical energy isn't destroyed, it's moved to heat. (The "LOL" energy
+* bar chart, animated.)
+*
+* This complements WorkEnergyLab (work = area under F–x): here the spotlight is
+* CONVERSION and conservation, not the definition of work.
+*
+* Tokenized SVG; energy-method integrator here; honours reduced-motion.
+*/
+const G = 9.8;
+const X = 6;
+const H = 5;
+const MU = .08;
+const yAt = (x) => H * (x / X) * (x / X);
+function EnergySkateLab({ startHeight = 4, friction = false, mass = 1, title = "Where did the energy go? — KE ⇄ PE (and heat)", prompt = "Release the skater and watch potential energy pour into kinetic and back. The three bars always add to the same total — unless friction is on, then a heat bar grows and the skater can’t climb as high again.", objectives, controlConfig }) {
+	const [h0, setH0] = useState(clamp(startHeight, 1, H));
+	const [fric, setFric] = useState(friction);
+	const [m] = useState(mass);
+	const [running, setRunning] = useState(false);
+	const x0 = -6 * Math.sqrt(h0 / H);
+	const E0 = m * G * h0;
+	const xRef = useRef(x0);
+	const dirRef = useRef(1);
+	const qRef = useRef(0);
+	const reduce = useReducedMotion();
+	const { ref: viewRef, inView } = useInView();
+	const SCALE = .5;
+	const repaint = useFrameTick(running && inView, (f) => {
+		const dt = Math.min(.03, f.dtMs / 1e3);
+		let x = xRef.current;
+		const y = yAt(x);
+		let ke = E0 - m * G * y - qRef.current;
+		if (fric && E0 - qRef.current <= m * G * .03) {
+			xRef.current = 0;
+			setRunning(false);
+			return;
+		}
+		if (ke <= 0) {
+			dirRef.current = -dirRef.current;
+			ke = 0;
+		}
+		const v = Math.sqrt(Math.max(0, 2 * ke / m));
+		const dx = dirRef.current * v * SCALE * dt;
+		x = clamp(x + dx, -6, X);
+		if (Math.abs(x) >= X) dirRef.current = -dirRef.current;
+		if (fric) qRef.current = Math.min(E0, qRef.current + MU * m * G * Math.abs(dx));
+		xRef.current = x;
+	});
+	const release = () => {
+		xRef.current = x0;
+		dirRef.current = 1;
+		qRef.current = 0;
+		if (reduce) {
+			xRef.current = 0;
+			repaint();
+			return;
+		}
+		setRunning(true);
+	};
+	const onH0 = (n) => {
+		setH0(clamp(n, 1, H));
+		setRunning(false);
+		xRef.current = -6 * Math.sqrt(clamp(n, 1, H) / H);
+		dirRef.current = 1;
+		qRef.current = 0;
+	};
+	const x = xRef.current;
+	const y = yAt(x);
+	const pe = m * G * y;
+	const ke = Math.max(0, E0 - pe - qRef.current);
+	const q = qRef.current;
+	const track = [];
+	for (let i = -6; i <= 6.000000001; i += .25) track.push({
+		x: i,
+		y: yAt(i)
+	});
+	const view = {
+		xMin: -7,
+		xMax: 7,
+		yMin: -1,
+		yMax: 6
+	};
+	const figure = /* @__PURE__ */ jsx("div", {
+		ref: viewRef,
+		className: "lab-playwrap",
+		children: /* @__PURE__ */ jsxs(Stage, {
+			view,
+			height: 240,
+			preserveAspect: false,
+			ariaLabel: `Skater on a ramp released from ${h0.toFixed(1)} m${fric ? ", with friction" : ""}`,
+			children: [
+				/* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: view.xMin,
+						y: 0
+					},
+					to: {
+						x: view.xMax,
+						y: 0
+					},
+					color: "var(--stage-fg)",
+					opacity: .3,
+					weight: 1
+				}),
+				/* @__PURE__ */ jsx(Segment, {
+					from: {
+						x: view.xMin,
+						y: h0
+					},
+					to: {
+						x: view.xMax,
+						y: h0
+					},
+					color: "var(--stage-muted)",
+					opacity: .5,
+					weight: 1,
+					dashed: true
+				}),
+				/* @__PURE__ */ jsx(Label, {
+					x: view.xMin,
+					y: h0,
+					text: `release ${h0.toFixed(1)} m`,
+					color: "var(--stage-muted)",
+					size: 10,
+					anchor: "start",
+					dy: -3
+				}),
+				/* @__PURE__ */ jsx(Polyline, {
+					points: track,
+					color: "var(--stage-fg)",
+					weight: 2.5
+				}),
+				/* @__PURE__ */ jsx(Label, {
+					x,
+					y: y + .4,
+					text: "🛹",
+					color: "var(--stage-fg)",
+					size: 30
+				})
+			]
+		})
+	});
+	const ebar = E0 > 0 ? 1 / E0 : 0;
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		aside: /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				gap: 8
+			},
+			children: [
+				/* @__PURE__ */ jsx(MeterBar, {
+					label: "potential PE = mgh",
+					frac: pe * ebar,
+					color: "var(--stage-accent-2)",
+					value: `${pe.toFixed(1)} J`
+				}),
+				/* @__PURE__ */ jsx(MeterBar, {
+					label: "kinetic KE = ½mv²",
+					frac: ke * ebar,
+					color: "var(--stage-good)",
+					value: `${ke.toFixed(1)} J`
+				}),
+				fric && /* @__PURE__ */ jsx(MeterBar, {
+					label: "thermal (friction) 🔥",
+					frac: q * ebar,
+					color: "var(--stage-warn)",
+					value: `${q.toFixed(1)} J`
+				}),
+				/* @__PURE__ */ jsx(Callout, {
+					tone: "result",
+					children: /* @__PURE__ */ jsxs("span", {
+						style: { fontVariantNumeric: "tabular-nums" },
+						children: [
+							"PE + KE",
+							fric ? " + heat" : "",
+							" = ",
+							/* @__PURE__ */ jsxs("strong", { children: [(pe + ke + (fric ? q : 0)).toFixed(1), " J"] }),
+							" ",
+							"= constant total ",
+							E0.toFixed(1),
+							" J"
+						]
+					})
+				}),
+				/* @__PURE__ */ jsx("p", {
+					style: {
+						fontSize: 12,
+						opacity: .75,
+						margin: 0
+					},
+					children: "Friction off → the skater returns to the same height forever (mechanical energy conserved). Friction on → the heat bar climbs and every peak is lower: energy moved, not lost."
+				}),
+				/* @__PURE__ */ jsx(LiveRegion, { children: `Potential ${pe.toFixed(1)}, kinetic ${ke.toFixed(1)}${fric ? `, heat ${q.toFixed(1)}` : ""} joules; total ${E0.toFixed(1)}.` })
+			]
+		}),
+		controls: /* @__PURE__ */ jsxs(ControlBar, { children: [
+			/* @__PURE__ */ jsx(CheckButton, {
+				onClick: release,
+				children: "▶ Release"
+			}),
+			/* @__PURE__ */ jsx(Control, {
+				name: "friction",
+				children: /* @__PURE__ */ jsxs(Chip, {
+					selected: fric,
+					onClick: () => {
+						setFric((c) => !c);
+						setRunning(false);
+						qRef.current = 0;
+					},
+					children: ["friction ", fric ? "on 🔥" : "off"]
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "start height",
+				value: `${h0.toFixed(1)} m`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: h0,
+					min: 1,
+					max: H,
+					step: .5,
+					onChange: onH0,
+					ariaLabel: "release height (m)"
+				})
+			})
+		] }),
+		controlConfig,
+		children: figure
+	});
+}
+
+//#endregion
+export { EnergySkateLab };

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

@@ -0,0 +1 @@
+import { EntropyLab, EntropyProps } from "./preset.mjs";

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

@@ -0,0 +1,18 @@
+import { ReactNode } from "react";
+
+//#region src/physics/entropy/preset.d.ts
+type Mode = 'heat' | 'expansion';
+interface EntropyProps {
+  mode?: Mode;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+}
+declare function EntropyLab({
+  mode: mode0,
+  title,
+  prompt,
+  objectives
+}?: EntropyProps): ReactNode;
+//#endregion
+export { EntropyLab, EntropyProps };

package/dist/physics/entropy/preset.mjs

@@ -0,0 +1,416 @@
+'use client';
+
+import { Tex } from "../../core/tex.mjs";
+import { Chip, Slider } from "../../kit/controls.mjs";
+import { Callout, ControlBar, Field, LabFrame } from "../../kit/frame.mjs";
+import { thermalColor } from "../../kit/thermal.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/entropy/preset.tsx
+/**
+* EntropyLab — why heat only flows one way, and why a gas always spreads out.
+* Entropy is the bookkeeping behind the second law: in any real (spontaneous)
+* process the TOTAL entropy of the universe increases.
+*
+*   • HEAT FLOW — move a chunk of heat Q from a hot body (Th) to a cold one (Tc).
+*     The hot body loses ΔS = −Q/Th; the cold body gains ΔS = +Q/Tc. Because
+*     Tc < Th, the gain outweighs the loss, so ΔS_total = Q(1/Tc − 1/Th) > 0 —
+*     hot→cold is spontaneous. Running it backwards would DECREASE total entropy,
+*     which never happens by itself. (Equal temperatures ⇒ ΔS_total = 0, reversible.)
+*   • FREE EXPANSION — let a gas spread into a vacuum. No heat, no work, but the gas
+*     can never un-mix: ΔS = nR·ln(Vf/Vi) > 0. Spreading out is simply overwhelmingly
+*     more likely than staying bunched up (more microstates).
+*
+* Interactive (recomputes on the sliders), no simulation loop. Pure SVG, themed.
+*/
+const R = 8.314462618;
+const W = 640, H = 340;
+function EntropyLab({ mode: mode0 = "heat", title = "Entropy & the second law — the one-way arrow", prompt = "Real processes always increase the total entropy of the universe. See why heat flows hot→cold and why a gas spreads out — and never reverses on its own.", objectives = [
+	"Compute entropy change as ΔS = Q/T for heat moved at temperature T",
+	"See ΔS_total > 0 for spontaneous heat flow (and = 0 only when Th = Tc)",
+	"Explain free expansion: ΔS = nR·ln(Vf/Vi) > 0, gas never un-mixes"
+] } = {}) {
+	const [mode, setMode] = useState(mode0);
+	const [Th, setTh] = useState(500);
+	const [Tc, setTc] = useState(300);
+	const [Q, setQ] = useState(1e3);
+	const [m, setM] = useState(1);
+	let figure;
+	let aside;
+	if (mode === "heat") {
+		const tc = Math.min(Tc, Th);
+		const dSh = -Q / Th, dSc = Q / tc, dST = dSh + dSc;
+		const scale = 70 / Math.max(2, Math.abs(dSc));
+		const bar = (x, label, val, color) => {
+			const baseY = 250, hpx = val * scale;
+			return /* @__PURE__ */ jsxs("g", { children: [
+				/* @__PURE__ */ jsx("rect", {
+					x: x - 26,
+					y: hpx >= 0 ? baseY - hpx : baseY,
+					width: 52,
+					height: Math.abs(hpx),
+					rx: 3,
+					fill: color,
+					opacity: .85
+				}),
+				/* @__PURE__ */ jsx("text", {
+					x,
+					y: 270,
+					textAnchor: "middle",
+					fontSize: 11,
+					fill: "var(--stage-fg)",
+					children: label
+				}),
+				/* @__PURE__ */ jsxs("text", {
+					x,
+					y: hpx >= 0 ? baseY - hpx - 6 : baseY + Math.abs(hpx) + 14,
+					textAnchor: "middle",
+					fontSize: 11,
+					fontWeight: 700,
+					fill: color,
+					style: { fontVariantNumeric: "tabular-nums" },
+					children: [val >= 0 ? "+" : "−", Math.abs(val).toFixed(2)]
+				})
+			] });
+		};
+		figure = /* @__PURE__ */ jsx("div", {
+			style: fwrap,
+			children: /* @__PURE__ */ jsxs("svg", {
+				viewBox: `0 0 ${W} ${H}`,
+				width: "100%",
+				role: "img",
+				"aria-label": `Heat flow, total entropy change ${dST.toFixed(2)} joules per kelvin`,
+				children: [
+					/* @__PURE__ */ jsx("rect", {
+						x: 40,
+						y: 130,
+						width: 120,
+						height: 90,
+						rx: 10,
+						fill: thermalColor(.95),
+						opacity: .85
+					}),
+					/* @__PURE__ */ jsx("text", {
+						x: 100,
+						y: 180,
+						textAnchor: "middle",
+						fontSize: 13,
+						fontWeight: 800,
+						fill: "var(--stage-bg)",
+						children: "HOT"
+					}),
+					/* @__PURE__ */ jsxs("text", {
+						x: 100,
+						y: 200,
+						textAnchor: "middle",
+						fontSize: 12,
+						fill: "var(--stage-bg)",
+						children: [Th, " K"]
+					}),
+					/* @__PURE__ */ jsx("rect", {
+						x: 250,
+						y: 130,
+						width: 120,
+						height: 90,
+						rx: 10,
+						fill: thermalColor(.12),
+						opacity: .85
+					}),
+					/* @__PURE__ */ jsx("text", {
+						x: 310,
+						y: 180,
+						textAnchor: "middle",
+						fontSize: 13,
+						fontWeight: 800,
+						fill: "var(--stage-bg)",
+						children: "COLD"
+					}),
+					/* @__PURE__ */ jsxs("text", {
+						x: 310,
+						y: 200,
+						textAnchor: "middle",
+						fontSize: 12,
+						fill: "var(--stage-bg)",
+						children: [tc, " K"]
+					}),
+					/* @__PURE__ */ jsx("line", {
+						x1: 165,
+						y1: 175,
+						x2: 245,
+						y2: 175,
+						stroke: "var(--stage-warn)",
+						strokeWidth: 3
+					}),
+					/* @__PURE__ */ jsx("polygon", {
+						points: "245,175 235,169 235,181",
+						fill: "var(--stage-warn)"
+					}),
+					/* @__PURE__ */ jsxs("text", {
+						x: 205,
+						y: 164,
+						textAnchor: "middle",
+						fontSize: 11,
+						fontWeight: 700,
+						fill: "var(--stage-warn)",
+						children: [
+							"Q = ",
+							Q,
+							" J"
+						]
+					}),
+					/* @__PURE__ */ jsx("line", {
+						x1: 420,
+						y1: 250,
+						x2: 620,
+						y2: 250,
+						stroke: "var(--stage-grid)",
+						strokeWidth: 1
+					}),
+					/* @__PURE__ */ jsx("text", {
+						x: 520,
+						y: 56,
+						textAnchor: "middle",
+						fontSize: 11,
+						fill: "var(--stage-muted)",
+						children: "entropy change (J/K)"
+					}),
+					bar(450, "hot", dSh, "var(--stage-danger, #e03131)"),
+					bar(520, "cold", dSc, "var(--stage-accent, #3b82f6)"),
+					bar(590, "total", dST, "var(--stage-good, #16a34a)")
+				]
+			})
+		});
+		aside = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Callout, {
+			tone: dST >= 0 ? "result" : "info",
+			children: /* @__PURE__ */ jsxs("span", {
+				style: {
+					display: "grid",
+					gap: 2,
+					fontVariantNumeric: "tabular-nums"
+				},
+				children: [/* @__PURE__ */ jsxs("span", {
+					style: {
+						fontWeight: 800,
+						fontSize: 16
+					},
+					children: [
+						"ΔS_total = ",
+						dST >= 0 ? "+" : "−",
+						Math.abs(dST).toFixed(2),
+						" J/K"
+					]
+				}), /* @__PURE__ */ jsx("span", {
+					style: { fontSize: 13 },
+					children: dST > .001 ? "spontaneous ✓" : "reversible limit (Th = Tc)"
+				})]
+			})
+		}), /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "grid",
+				gap: 8,
+				padding: "8px 2px 0",
+				fontSize: 13
+			},
+			children: [/* @__PURE__ */ jsx(Tex, {
+				tex: "\\Delta S_{tot} = \\dfrac{Q}{T_c} - \\dfrac{Q}{T_h} > 0",
+				block: true
+			}), /* @__PURE__ */ jsxs("span", {
+				style: { color: "var(--stage-muted)" },
+				children: [
+					"The cold body gains ",
+					/* @__PURE__ */ jsx("strong", {
+						style: { color: "var(--stage-fg)" },
+						children: "more"
+					}),
+					" entropy than the hot body loses (same Q, smaller T). So heat flows hot→cold by itself; the reverse would lower total entropy — forbidden by the 2nd law."
+				]
+			})]
+		})] });
+	} else {
+		const n = 1, ratio = 1 + m, dS = n * R * Math.log(ratio);
+		const bx = 60, by = 70, bw = 360, bh = 200;
+		const wallX = 240;
+		const accRight = bx + bw * (.5 + .5 * m);
+		const parts = Array.from({ length: 44 }, (_, i) => {
+			const hx = i * .6180339 % 1, hy = (i * .7548 + .13) % 1;
+			return /* @__PURE__ */ jsx("circle", {
+				cx: 68 + hx * (accRight - bx - 16),
+				cy: 80 + hy * (bh - 20),
+				r: 3.2,
+				fill: thermalColor(.5),
+				opacity: .9
+			}, i);
+		});
+		figure = /* @__PURE__ */ jsx("div", {
+			style: fwrap,
+			children: /* @__PURE__ */ jsxs("svg", {
+				viewBox: `0 0 ${W} ${H}`,
+				width: "100%",
+				role: "img",
+				"aria-label": `Free expansion, entropy increase ${dS.toFixed(2)} joules per kelvin`,
+				children: [
+					/* @__PURE__ */ jsx("rect", {
+						x: bx,
+						y: by,
+						width: bw,
+						height: bh,
+						rx: 6,
+						fill: "color-mix(in oklab, var(--stage-accent) 8%, transparent)",
+						stroke: "var(--stage-metal)",
+						strokeWidth: 3
+					}),
+					m < .98 && /* @__PURE__ */ jsx("text", {
+						x: (accRight + bx + bw) / 2,
+						y: 170,
+						textAnchor: "middle",
+						fontSize: 12,
+						fill: "var(--stage-muted)",
+						children: "vacuum"
+					}),
+					parts,
+					/* @__PURE__ */ jsx("line", {
+						x1: wallX,
+						y1: by,
+						x2: wallX,
+						y2: 270,
+						stroke: "var(--stage-warn)",
+						strokeWidth: 4,
+						strokeDasharray: "6 5",
+						opacity: 1 - m
+					}),
+					/* @__PURE__ */ jsx("text", {
+						x: 240,
+						y: 292,
+						textAnchor: "middle",
+						fontSize: 11,
+						fill: "var(--stage-muted)",
+						children: m < .02 ? "gas confined to the left half" : m > .98 ? "gas fills the whole box" : "spreading…"
+					})
+				]
+			})
+		});
+		aside = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Callout, {
+			tone: "result",
+			children: /* @__PURE__ */ jsxs("span", {
+				style: {
+					fontWeight: 800,
+					fontSize: 16,
+					fontVariantNumeric: "tabular-nums"
+				},
+				children: [
+					"ΔS = +",
+					dS.toFixed(2),
+					" J/K"
+				]
+			})
+		}), /* @__PURE__ */ jsxs("div", {
+			style: {
+				display: "grid",
+				gap: 8,
+				padding: "8px 2px 0",
+				fontSize: 13
+			},
+			children: [/* @__PURE__ */ jsx(Tex, {
+				tex: "\\Delta S = nR\\,\\ln\\!\\dfrac{V_f}{V_i}",
+				block: true
+			}), /* @__PURE__ */ jsxs("span", {
+				style: { color: "var(--stage-muted)" },
+				children: [
+					"No heat, no work — yet entropy still rises, because the gas now has far more ways to arrange itself. Fully open (Vf = 2Vi) gives ",
+					/* @__PURE__ */ jsx("strong", {
+						style: { color: "var(--stage-fg)" },
+						children: "nR·ln 2 ≈ 5.76 J/K"
+					}),
+					". You’ll never see it pile back into one half on its own."
+				]
+			})]
+		})] });
+	}
+	const controls = /* @__PURE__ */ jsxs("div", {
+		style: {
+			display: "grid",
+			gap: 10
+		},
+		children: [/* @__PURE__ */ jsx(ControlBar, { children: /* @__PURE__ */ jsx(Field, {
+			label: "process",
+			children: /* @__PURE__ */ jsxs("span", {
+				className: "lab-field-row",
+				children: [/* @__PURE__ */ jsx(Chip, {
+					selected: mode === "heat",
+					onClick: () => setMode("heat"),
+					children: "heat flows hot→cold"
+				}), /* @__PURE__ */ jsx(Chip, {
+					selected: mode === "expansion",
+					onClick: () => setMode("expansion"),
+					children: "free expansion (spreading)"
+				})]
+			})
+		}) }), mode === "heat" ? /* @__PURE__ */ jsxs(ControlBar, { children: [
+			/* @__PURE__ */ jsx(Field, {
+				label: "hot Th",
+				value: `${Th} K`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: Th,
+					min: 310,
+					max: 800,
+					step: 10,
+					onChange: setTh,
+					ariaLabel: "hot temperature"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "cold Tc",
+				value: `${Math.min(Tc, Th)} K`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: Tc,
+					min: 250,
+					max: 800,
+					step: 10,
+					onChange: setTc,
+					ariaLabel: "cold temperature"
+				})
+			}),
+			/* @__PURE__ */ jsx(Field, {
+				label: "heat Q",
+				value: `${Q} J`,
+				children: /* @__PURE__ */ jsx(Slider, {
+					value: Q,
+					min: 200,
+					max: 3e3,
+					step: 100,
+					onChange: setQ,
+					ariaLabel: "heat transferred"
+				})
+			})
+		] }) : /* @__PURE__ */ jsx(ControlBar, { children: /* @__PURE__ */ jsx(Field, {
+			label: "open the partition",
+			value: `${Math.round(m * 100)}%`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: m,
+				min: 0,
+				max: 1,
+				step: .05,
+				onChange: setM,
+				ariaLabel: "partition openness"
+			})
+		}) })]
+	});
+	return /* @__PURE__ */ jsx(LabFrame, {
+		title,
+		prompt,
+		objectives,
+		aside,
+		controls,
+		children: figure
+	});
+}
+const fwrap = {
+	borderRadius: 14,
+	overflow: "hidden",
+	background: "var(--stage-bg)",
+	border: "1px solid var(--stage-grid)"
+};
+
+//#endregion
+export { EntropyLab };

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

@@ -0,0 +1 @@
+import { ThermalExpansionLab, ThermalExpansionProps } from "./preset.mjs";