@classytic/labs 0.1.0 → 0.3.0

package/dist/physics/modern/nuclear/activity.mjs

@@ -0,0 +1,74 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/nuclear/activity.ts
+const bindingEnergyActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Where nuclear energy comes from",
+	objectives: [
+		"Interpret mass defect as binding energy",
+		"Read binding energy per nucleon",
+		"Explain why light nuclei fuse and heavy nuclei fission toward the iron region"
+	],
+	success: [{
+		id: "direction",
+		source: "answer",
+		key: "direction",
+		pendingLabel: "Identify the downhill energy direction."
+	}],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Weigh the parts",
+			lead: "Will a bound nucleus weigh the same as its separated nucleons?"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Compare nuclei",
+			lead: "Move from hydrogen toward uranium.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Find the stability ridge",
+			lead: "Binding per nucleon rises toward the iron region."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Account for missing mass",
+			lead: "The mass difference left as energy when the nucleus formed."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Predict an energy-releasing change",
+			lead: "Move nuclei toward more binding per nucleon."
+		}
+	],
+	questions: [{
+		id: "direction",
+		prompt: "Which changes can release nuclear energy?",
+		choices: [
+			{
+				value: "toward",
+				label: "Changes toward more binding per nucleon"
+			},
+			{
+				value: "away",
+				label: "Changes away from the iron region"
+			},
+			{
+				value: "mass",
+				label: "Only changes that conserve atomic mass exactly"
+			}
+		],
+		answer: "toward",
+		explain: "Products with greater binding energy per nucleon have lower total rest mass; the difference can emerge as released energy."
+	}]
+});
+
+//#endregion
+export { bindingEnergyActivity };

package/dist/physics/modern/nuclear/core.d.mts

@@ -0,0 +1,75 @@
+//#region src/physics/modern/nuclear/core.d.ts
+declare const U_TO_MEV = 931.49410372,
+  HYDROGEN_ATOM_MASS_U = 1.00782503223,
+  NEUTRON_MASS_U = 1.00866491595;
+interface Nuclide {
+  id: string;
+  symbol: string;
+  name: string;
+  A: number;
+  Z: number;
+  atomicMassU: number;
+}
+declare const NUCLIDES: {
+  readonly deuterium: {
+    readonly id: "deuterium";
+    readonly symbol: "²H";
+    readonly name: "deuterium";
+    readonly A: 2;
+    readonly Z: 1;
+    readonly atomicMassU: 2.01410177812;
+  };
+  readonly helium4: {
+    readonly id: "helium4";
+    readonly symbol: "⁴He";
+    readonly name: "helium-4";
+    readonly A: 4;
+    readonly Z: 2;
+    readonly atomicMassU: 4.00260325413;
+  };
+  readonly carbon12: {
+    readonly id: "carbon12";
+    readonly symbol: "¹²C";
+    readonly name: "carbon-12";
+    readonly A: 12;
+    readonly Z: 6;
+    readonly atomicMassU: 12;
+  };
+  readonly iron56: {
+    readonly id: "iron56";
+    readonly symbol: "⁵⁶Fe";
+    readonly name: "iron-56";
+    readonly A: 56;
+    readonly Z: 26;
+    readonly atomicMassU: 55.93493633;
+  };
+  readonly uranium235: {
+    readonly id: "uranium235";
+    readonly symbol: "²³⁵U";
+    readonly name: "uranium-235";
+    readonly A: 235;
+    readonly Z: 92;
+    readonly atomicMassU: 235.0439299;
+  };
+  readonly uranium238: {
+    readonly id: "uranium238";
+    readonly symbol: "²³⁸U";
+    readonly name: "uranium-238";
+    readonly A: 238;
+    readonly Z: 92;
+    readonly atomicMassU: 238.05078826;
+  };
+};
+type NuclideId = keyof typeof NUCLIDES;
+interface BindingState {
+  nuclide: Nuclide;
+  neutrons: number;
+  separatedMassU: number;
+  massDefectU: number;
+  bindingEnergyMeV: number;
+  perNucleonMeV: number;
+  massRetainedPercent: number;
+}
+declare function bindingState(nuclide: Nuclide): BindingState;
+//#endregion
+export { BindingState, HYDROGEN_ATOM_MASS_U, NEUTRON_MASS_U, NUCLIDES, Nuclide, NuclideId, U_TO_MEV, bindingState };

package/dist/physics/modern/nuclear/core.mjs

@@ -0,0 +1,69 @@
+//#region src/physics/modern/nuclear/core.ts
+const U_TO_MEV = 931.49410372;
+const HYDROGEN_ATOM_MASS_U = 1.00782503223;
+const NEUTRON_MASS_U = 1.00866491595;
+const NUCLIDES = {
+	deuterium: {
+		id: "deuterium",
+		symbol: "²H",
+		name: "deuterium",
+		A: 2,
+		Z: 1,
+		atomicMassU: 2.01410177812
+	},
+	helium4: {
+		id: "helium4",
+		symbol: "⁴He",
+		name: "helium-4",
+		A: 4,
+		Z: 2,
+		atomicMassU: 4.00260325413
+	},
+	carbon12: {
+		id: "carbon12",
+		symbol: "¹²C",
+		name: "carbon-12",
+		A: 12,
+		Z: 6,
+		atomicMassU: 12
+	},
+	iron56: {
+		id: "iron56",
+		symbol: "⁵⁶Fe",
+		name: "iron-56",
+		A: 56,
+		Z: 26,
+		atomicMassU: 55.93493633
+	},
+	uranium235: {
+		id: "uranium235",
+		symbol: "²³⁵U",
+		name: "uranium-235",
+		A: 235,
+		Z: 92,
+		atomicMassU: 235.0439299
+	},
+	uranium238: {
+		id: "uranium238",
+		symbol: "²³⁸U",
+		name: "uranium-238",
+		A: 238,
+		Z: 92,
+		atomicMassU: 238.05078826
+	}
+};
+function bindingState(nuclide) {
+	const neutrons = nuclide.A - nuclide.Z, separatedMassU = nuclide.Z * HYDROGEN_ATOM_MASS_U + neutrons * NEUTRON_MASS_U, massDefectU = separatedMassU - nuclide.atomicMassU, bindingEnergyMeV = massDefectU * U_TO_MEV;
+	return {
+		nuclide,
+		neutrons,
+		separatedMassU,
+		massDefectU,
+		bindingEnergyMeV,
+		perNucleonMeV: bindingEnergyMeV / nuclide.A,
+		massRetainedPercent: nuclide.atomicMassU / separatedMassU * 100
+	};
+}
+
+//#endregion
+export { HYDROGEN_ATOM_MASS_U, NEUTRON_MASS_U, NUCLIDES, U_TO_MEV, bindingState };

package/dist/physics/modern/nuclear/fission-activity.d.mts

@@ -0,0 +1,6 @@
+import { CompiledAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/nuclear/fission-activity.d.ts
+declare const fissionChainActivity: CompiledAuthoredActivity;
+//#endregion
+export { fissionChainActivity };

package/dist/physics/modern/nuclear/fission-activity.mjs

@@ -0,0 +1,96 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/nuclear/fission-activity.ts
+const fissionChainActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Hold a chain reaction steady",
+	objectives: [
+		"Interpret effective multiplication k",
+		"Explain neutron absorption by control rods",
+		"Connect fission count to released binding energy"
+	],
+	success: [
+		{
+			id: "critical",
+			source: "answer",
+			key: "critical",
+			pendingLabel: "Identify a steady chain reaction."
+		},
+		{
+			id: "run-complete",
+			source: "metric",
+			key: "runComplete",
+			operator: "eq",
+			value: true,
+			pendingLabel: "Run all neutron generations."
+		},
+		{
+			id: "restored",
+			source: "metric",
+			key: "restored",
+			operator: "eq",
+			value: true,
+			pendingLabel: "Apply a disturbance, then restore criticality."
+		}
+	],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Predict the next generation",
+			lead: "Will each generation shrink, persist, or grow?",
+			success: "critical"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Move the absorber",
+			lead: "Insert the conceptual control rod and target k ≈ 1.",
+			controls: true,
+			success: "run-complete"
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Watch generations",
+			lead: "Compare produced, captured, and escaped neutrons."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Account for the energy",
+			lead: "Each fission moves products toward stronger binding."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Recover from a disturbance",
+			lead: "Change the starting multiplication and restore criticality.",
+			controls: true,
+			success: "restored"
+		}
+	],
+	questions: [{
+		id: "critical",
+		prompt: "What does k = 1 mean in this generation model?",
+		choices: [
+			{
+				value: "steady",
+				label: "Each generation replaces itself on average"
+			},
+			{
+				value: "stopped",
+				label: "No nuclei fission"
+			},
+			{
+				value: "double",
+				label: "The population doubles each generation"
+			}
+		],
+		answer: "steady",
+		explain: "At k = 1, each neutron generation produces one equally large successor generation on average."
+	}]
+});
+
+//#endregion
+export { fissionChainActivity };

package/dist/physics/modern/nuclear/fission-core.d.mts

@@ -0,0 +1,49 @@
+//#region src/physics/modern/nuclear/fission-core.d.ts
+type Criticality = 'subcritical' | 'critical' | 'supercritical';
+interface FissionGeneration {
+  generation: number;
+  sourceNeutrons: number;
+  controlCaptured: number;
+  leaked: number;
+  fuelCaptured: number;
+  fissions: number;
+  emittedNeutrons: number;
+  energyMeV: number;
+}
+interface FissionChainState {
+  kEffective: number;
+  criticality: Criticality;
+  generations: FissionGeneration[];
+  totalExpectedFissions: number;
+  totalExpectedEnergyMeV: number;
+  neutronsPerFission: number;
+  leakageFraction: number;
+  controlCaptureFraction: number;
+}
+interface FissionChainScenario {
+  baseK?: number;
+  controlInsertion?: number;
+  generationCount?: number;
+  initialNeutrons?: number;
+  neutronsPerFission?: number;
+  leakageFraction?: number;
+  maxControlCapture?: number;
+}
+declare const ENERGY_PER_FISSION_MEV = 200;
+declare const DEFAULT_NEUTRONS_PER_FISSION = 2.43;
+declare const DEFAULT_LEAKAGE_FRACTION = 0.12;
+declare const DEFAULT_MAX_CONTROL_CAPTURE = 0.72;
+declare function effectiveMultiplication(baseK: number, controlInsertion: number, maxControlCapture?: number): number;
+declare function criticalityOf(k: number): Criticality;
+/** Expected-value model with an explicit, conserved source-neutron ledger. */
+declare function simulateFissionChain({
+  baseK,
+  controlInsertion,
+  generationCount,
+  initialNeutrons,
+  neutronsPerFission,
+  leakageFraction,
+  maxControlCapture
+}?: FissionChainScenario): FissionChainState;
+//#endregion
+export { Criticality, DEFAULT_LEAKAGE_FRACTION, DEFAULT_MAX_CONTROL_CAPTURE, DEFAULT_NEUTRONS_PER_FISSION, ENERGY_PER_FISSION_MEV, FissionChainScenario, FissionChainState, FissionGeneration, criticalityOf, effectiveMultiplication, simulateFissionChain };

package/dist/physics/modern/nuclear/fission-core.mjs

@@ -0,0 +1,67 @@
+//#region src/physics/modern/nuclear/fission-core.ts
+const ENERGY_PER_FISSION_MEV = 200;
+const DEFAULT_NEUTRONS_PER_FISSION = 2.43;
+const DEFAULT_LEAKAGE_FRACTION = .12;
+const DEFAULT_MAX_CONTROL_CAPTURE = .72;
+function fraction(value, name) {
+	if (!Number.isFinite(value)) throw new RangeError(`${name} must be finite`);
+	return Math.max(0, Math.min(1, value));
+}
+function effectiveMultiplication(baseK, controlInsertion, maxControlCapture = DEFAULT_MAX_CONTROL_CAPTURE) {
+	if (!Number.isFinite(baseK) || baseK < 0) throw new RangeError("baseK must be non-negative");
+	return baseK * (1 - fraction(controlInsertion, "controlInsertion") * fraction(maxControlCapture, "maxControlCapture"));
+}
+function criticalityOf(k) {
+	return Math.abs(k - 1) < .025 ? "critical" : k < 1 ? "subcritical" : "supercritical";
+}
+/** Expected-value model with an explicit, conserved source-neutron ledger. */
+function simulateFissionChain({ baseK = 1.35, controlInsertion = .36, generationCount = 7, initialNeutrons = 1, neutronsPerFission = DEFAULT_NEUTRONS_PER_FISSION, leakageFraction = DEFAULT_LEAKAGE_FRACTION, maxControlCapture = DEFAULT_MAX_CONTROL_CAPTURE } = {}) {
+	if (!Number.isFinite(initialNeutrons) || initialNeutrons < 0) throw new RangeError("initialNeutrons must be non-negative");
+	if (!Number.isFinite(neutronsPerFission) || neutronsPerFission <= 0) throw new RangeError("neutronsPerFission must be positive");
+	const leakage = fraction(leakageFraction, "leakageFraction");
+	const insertion = fraction(controlInsertion, "controlInsertion");
+	const maximumCapture = fraction(maxControlCapture, "maxControlCapture");
+	const controlCaptureFraction = insertion * maximumCapture;
+	const possibleMultiplier = (1 - leakage) * neutronsPerFission;
+	if (baseK > possibleMultiplier + Number.EPSILON) throw new RangeError(`baseK cannot exceed ${possibleMultiplier.toFixed(3)} for this leakage and neutron yield`);
+	const fuelFissionProbability = possibleMultiplier === 0 ? 0 : baseK / possibleMultiplier;
+	const kEffective = effectiveMultiplication(baseK, insertion, maximumCapture);
+	const generations = [];
+	let sourceNeutrons = initialNeutrons;
+	let totalExpectedFissions = 0;
+	const count = Math.max(1, Math.min(12, Math.floor(generationCount)));
+	for (let generation = 0; generation < count; generation += 1) {
+		const controlCaptured = sourceNeutrons * controlCaptureFraction;
+		const afterControl = sourceNeutrons - controlCaptured;
+		const leaked = afterControl * leakage;
+		const reachingFuel = afterControl - leaked;
+		const fissions = reachingFuel * fuelFissionProbability;
+		const fuelCaptured = reachingFuel - fissions;
+		const emittedNeutrons = fissions * neutronsPerFission;
+		generations.push({
+			generation,
+			sourceNeutrons,
+			controlCaptured,
+			leaked,
+			fuelCaptured,
+			fissions,
+			emittedNeutrons,
+			energyMeV: fissions * 200
+		});
+		totalExpectedFissions += fissions;
+		sourceNeutrons = emittedNeutrons;
+	}
+	return {
+		kEffective,
+		criticality: criticalityOf(kEffective),
+		generations,
+		totalExpectedFissions,
+		totalExpectedEnergyMeV: totalExpectedFissions * 200,
+		neutronsPerFission,
+		leakageFraction: leakage,
+		controlCaptureFraction
+	};
+}
+
+//#endregion
+export { DEFAULT_LEAKAGE_FRACTION, DEFAULT_MAX_CONTROL_CAPTURE, DEFAULT_NEUTRONS_PER_FISSION, ENERGY_PER_FISSION_MEV, criticalityOf, effectiveMultiplication, simulateFissionChain };

package/dist/physics/modern/nuclear/fission-preset.d.mts

@@ -0,0 +1,24 @@
+import { AuthoredActivity } from "../../../kit/activity-authoring.mjs";
+import { ReactNode } from "react";
+
+//#region src/physics/modern/nuclear/fission-preset.d.ts
+interface FissionChainLabProps {
+  baseK?: number;
+  controlInsertion?: number;
+  generations?: number;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  activity?: AuthoredActivity;
+}
+declare function FissionChainLab({
+  baseK: initialBaseK,
+  controlInsertion: initialControl,
+  generations,
+  title,
+  prompt,
+  objectives,
+  activity
+}?: FissionChainLabProps): ReactNode;
+//#endregion
+export { FissionChainLab, FissionChainLabProps };

package/dist/physics/modern/nuclear/fission-preset.mjs

@@ -0,0 +1,132 @@
+'use client';
+
+import { ActivitySelect, Slider } from "../../../kit/controls.mjs";
+import { Field, Readout } from "../../../kit/frame.mjs";
+import { AuthoredActivityRuntime, AuthoredMetricGate } from "../../../kit/authored-activity-runtime.mjs";
+import { ExperimentTransport, useExperimentTimeline } from "../shared/experiment-transport.mjs";
+import { simulateFissionChain } from "./fission-core.mjs";
+import { fissionChainActivity } from "./fission-activity.mjs";
+import { FissionExperimentScene } from "./fission-scene.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/modern/nuclear/fission-preset.tsx
+function FissionChainLab({ baseK: initialBaseK = 1.35, controlInsertion: initialControl = .36, generations = 7, title = "Chain reaction: keep every generation steady", prompt = "Trace where each neutron goes, then adjust the absorber until one generation replaces itself.", objectives, activity } = {}) {
+	const [baseK, setBaseK] = useState(initialBaseK);
+	const [control, setControl] = useState(initialControl);
+	const [disturbed, setDisturbed] = useState(false);
+	const state = simulateFissionChain({
+		baseK,
+		controlInsertion: control,
+		generationCount: generations
+	});
+	const stops = useMemo(() => Array.from({ length: generations }, (_, index) => index / Math.max(1, generations - 1)), [generations]);
+	const timeline = useExperimentTimeline({
+		durationMs: generations * 650,
+		stops
+	});
+	const selectedGeneration = Math.min(generations - 1, Math.floor(timeline.progress * generations));
+	const selected = state.generations[selectedGeneration];
+	const runtime = activity ?? (objectives ? {
+		...fissionChainActivity.source,
+		objectives
+	} : fissionChainActivity);
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Field, {
+			label: "control-rod insertion",
+			value: `${Math.round(control * 100)}%`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: control,
+				min: 0,
+				max: 1,
+				step: .01,
+				onChange: (value) => {
+					timeline.reset();
+					setControl(value);
+				},
+				ariaLabel: "neutron absorber insertion"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "reactor condition",
+			children: /* @__PURE__ */ jsx(ActivitySelect, {
+				ariaLabel: "reactor condition",
+				value: baseK === 1.15 ? "low" : baseK === 1.35 ? "nominal" : baseK === 1.55 ? "disturbance" : "",
+				onChange: (next) => {
+					timeline.reset();
+					if (next === "disturbance") setDisturbed(true);
+					setBaseK(next === "low" ? 1.15 : next === "disturbance" ? 1.55 : 1.35);
+				},
+				options: [
+					{
+						value: "low",
+						label: "Low multiplication"
+					},
+					{
+						value: "nominal",
+						label: "Nominal reactor"
+					},
+					{
+						value: "disturbance",
+						label: "Neutron disturbance"
+					}
+				]
+			})
+		}),
+		/* @__PURE__ */ jsx(ExperimentTransport, {
+			timeline,
+			label: "generations",
+			detail: `G${selectedGeneration} · k ${state.kEffective.toFixed(2)}`
+		})
+	] });
+	const evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Readout, {
+			value: `k = ${state.kEffective.toFixed(2)} · ${state.criticality}`,
+			sub: "average next-generation multiplier"
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			className: "lab-metric-list",
+			children: [
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "expected fissions" }), /* @__PURE__ */ jsx("strong", { children: state.totalExpectedFissions.toFixed(1) })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "expected released energy" }), /* @__PURE__ */ jsxs("strong", { children: [state.totalExpectedEnergyMeV.toFixed(0), " MeV"] })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "selected generation continues" }), /* @__PURE__ */ jsx("strong", { children: selected.emittedNeutrons.toFixed(2) })] })
+			]
+		}),
+		/* @__PURE__ */ jsx("p", { children: "Expected-value teaching model—not an operational reactor model." })
+	] });
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		focusLayout: "immersive",
+		activity: runtime,
+		activityId: "fission-chain",
+		eyebrow: "Modern physics · nuclear fission",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsxs("span", { children: ["G", selectedGeneration] }),
+			/* @__PURE__ */ jsxs("span", { children: ["k ", state.kEffective.toFixed(2)] }),
+			/* @__PURE__ */ jsx("span", { children: state.criticality })
+		] }),
+		controls,
+		evidence,
+		observation: state.criticality === "critical" ? "Each generation replaces itself on average." : state.criticality === "subcritical" ? "Capture and leakage exceed replacement, so the chain fades." : "Replacement exceeds losses, so the chain grows.",
+		children: ({ complete }) => /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx(AuthoredMetricGate, {
+				conditionId: "run-complete",
+				met: timeline.progress >= 1,
+				complete
+			}),
+			/* @__PURE__ */ jsx(AuthoredMetricGate, {
+				conditionId: "restored",
+				met: disturbed && state.criticality === "critical",
+				complete
+			}),
+			/* @__PURE__ */ jsx(FissionExperimentScene, {
+				state,
+				selectedGeneration
+			})
+		] })
+	});
+}
+
+//#endregion
+export { FissionChainLab };