@classytic/labs 0.1.0 → 0.3.0

package/dist/physics/modern/relativity/simultaneity-activity.mjs

@@ -0,0 +1,80 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/relativity/simultaneity-activity.ts
+const simultaneityActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Same events, different now",
+	objectives: [
+		"Define simultaneity using synchronized clocks",
+		"Transform separated events between frames",
+		"Distinguish emission time from light-arrival time"
+	],
+	success: [{
+		id: "comparison-complete",
+		source: "metric",
+		key: "comparison-complete",
+		pendingLabel: "Run the event comparison once."
+	}, {
+		id: "order",
+		source: "answer",
+		key: "order",
+		pendingLabel: "Predict the train-frame order."
+	}],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Choose the train-frame order",
+			lead: "The platform clocks record two separated flashes at the same time.",
+			success: "order"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Change relative speed",
+			lead: "Watch the train clocks assigned to the same two events.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Compare event ledgers",
+			lead: "The event pair is unchanged; its coordinates are frame-dependent."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Separate seeing from assigning",
+			lead: "Correct light-travel delay with synchronized clocks."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Reverse the train",
+			lead: "Predict how the event order reverses."
+		}
+	],
+	questions: [{
+		id: "order",
+		prompt: "For a train moving right, which platform-simultaneous flash has the earlier train-frame time?",
+		choices: [
+			{
+				value: "right",
+				label: "the right/front flash"
+			},
+			{
+				value: "left",
+				label: "the left/rear flash"
+			},
+			{
+				value: "same",
+				label: "they remain simultaneous"
+			}
+		],
+		answer: "right",
+		explain: "t′ = γ(t − vx/c²). At equal platform time, the event at larger x has the earlier train-frame time."
+	}]
+});
+
+//#endregion
+export { simultaneityActivity };

package/dist/physics/modern/relativity/simultaneity-core.d.mts

@@ -0,0 +1,21 @@
+import { SpacetimeEvent } from "./core.mjs";
+
+//#region src/physics/modern/relativity/simultaneity-core.d.ts
+interface SimultaneityState {
+  beta: number;
+  separationM: number;
+  platform: {
+    left: SpacetimeEvent;
+    right: SpacetimeEvent;
+    deltaTimeNs: number;
+  };
+  train: {
+    left: SpacetimeEvent;
+    right: SpacetimeEvent;
+    deltaTimeNs: number;
+  };
+  firstInTrain: 'left' | 'right' | 'simultaneous';
+}
+declare function simultaneityState(beta: number, separationM?: number): SimultaneityState;
+//#endregion
+export { SimultaneityState, simultaneityState };

package/dist/physics/modern/relativity/simultaneity-core.mjs

@@ -0,0 +1,33 @@
+import { SPEED_OF_LIGHT } from "../constants.mjs";
+import { lorentzTransform, validBeta } from "./core.mjs";
+
+//#region src/physics/modern/relativity/simultaneity-core.ts
+function simultaneityState(beta, separationM = 300) {
+	const b = validBeta(beta);
+	if (!Number.isFinite(separationM) || separationM <= 0) throw new RangeError("separation must be positive");
+	const halfLightSeconds = separationM / (2 * SPEED_OF_LIGHT), left = {
+		x: -halfLightSeconds,
+		ct: 0
+	}, right = {
+		x: halfLightSeconds,
+		ct: 0
+	}, leftPrime = lorentzTransform(left, b), rightPrime = lorentzTransform(right, b), deltaTimeNs = (rightPrime.ct - leftPrime.ct) * 1e9;
+	return {
+		beta: b,
+		separationM,
+		platform: {
+			left,
+			right,
+			deltaTimeNs: 0
+		},
+		train: {
+			left: leftPrime,
+			right: rightPrime,
+			deltaTimeNs
+		},
+		firstInTrain: Math.abs(deltaTimeNs) < 1e-9 ? "simultaneous" : deltaTimeNs < 0 ? "right" : "left"
+	};
+}
+
+//#endregion
+export { simultaneityState };

package/dist/physics/modern/relativity/simultaneity-preset.d.mts

@@ -0,0 +1,20 @@
+import { AuthoredActivity } from "../../../kit/activity-authoring.mjs";
+import { ReactNode } from "react";
+
+//#region src/physics/modern/relativity/simultaneity-preset.d.ts
+interface RelativitySimultaneityLabProps {
+  beta?: number;
+  separationM?: number;
+  title?: string;
+  prompt?: string;
+  activity?: AuthoredActivity;
+}
+declare function RelativitySimultaneityLab({
+  beta: initial,
+  separationM,
+  title,
+  prompt,
+  activity
+}?: RelativitySimultaneityLabProps): ReactNode;
+//#endregion
+export { RelativitySimultaneityLab, RelativitySimultaneityLabProps };

package/dist/physics/modern/relativity/simultaneity-preset.mjs

@@ -0,0 +1,319 @@
+'use client';
+
+import { Segmented, 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 } from "../../../kit/figure/figure.mjs";
+import { FigTag, FigText } from "../../../kit/figure/text.mjs";
+import { Ball } from "../../../kit/figure/body.mjs";
+import { Arrow, Ground, Ray, Track } from "../../../kit/figure/beam.mjs";
+import { ClockFace, TrainCar } from "./scene-primitives.mjs";
+import { ExperimentTransport, useExperimentTimeline } from "../shared/experiment-transport.mjs";
+import { simultaneityState } from "./simultaneity-core.mjs";
+import { simultaneityActivity } from "./simultaneity-activity.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/modern/relativity/simultaneity-preset.tsx
+const W = 720;
+const H = 348;
+const RAIL_Y = 236;
+const REAR_X = 155;
+const FRONT_X = 565;
+const CAR_X = 166;
+const CAR_Y = 140;
+const CAR_W = 384;
+const OBSERVER_Y = 176;
+const CLOCK_Y = 298;
+/** Nanoseconds of train time per full turn of a clock's long hand. */
+const NS_PER_TURN = 3e3;
+/** A lightning strike on the embankment: an event flash plus its expanding light front. */
+function Strike({ x, progress }) {
+	const r = 18 + progress * 172;
+	return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx(Track, {
+		d: `M ${x - r} ${RAIL_Y} A ${r} ${r} 0 0 1 ${x + r} ${RAIL_Y}`,
+		dashed: false,
+		color: HUE[2],
+		weight: "line",
+		opacity: .85
+	}), /* @__PURE__ */ jsx(Ball, {
+		cx: x,
+		cy: RAIL_Y,
+		r: 7,
+		color: HUE[2],
+		flash: Math.max(0, 1 - progress * 3),
+		flashColor: HUE[2]
+	})] });
+}
+function Clock({ x, side, frame, timeNs, earlier }) {
+	const tx = side === "rear" ? x + 28 : x - 28;
+	const anchor = side === "rear" ? "start" : "end";
+	return /* @__PURE__ */ jsxs("g", { children: [
+		earlier && /* @__PURE__ */ jsx(FigTag, {
+			x,
+			y: 262,
+			color: HUE.good,
+			anchor: "middle",
+			children: "earlier"
+		}),
+		/* @__PURE__ */ jsx(ClockFace, {
+			cx: x,
+			cy: CLOCK_Y,
+			r: 20,
+			turns: frame === "train" ? timeNs / NS_PER_TURN : 0,
+			active: earlier
+		}),
+		/* @__PURE__ */ jsxs(FigText, {
+			x: tx,
+			y: CLOCK_Y - 8,
+			anchor,
+			size: "eyebrow",
+			tone: "soft",
+			children: [
+				side,
+				" · ",
+				frame,
+				" clock"
+			]
+		}),
+		/* @__PURE__ */ jsxs(FigText, {
+			x: tx,
+			y: 311,
+			anchor,
+			size: "measure",
+			children: [
+				frame === "train" ? "t′" : "t",
+				" = ",
+				timeNs.toFixed(1),
+				" ns"
+			]
+		})
+	] });
+}
+function SimultaneityScene({ beta, first, trainTimes, phase, progress }) {
+	const showMotion = phase !== "predict" && Math.abs(beta) > .005, showLedger = [
+		"observe",
+		"explain",
+		"transfer"
+	].includes(phase), showLight = phase === "explain", direction = beta >= 0 ? 1 : -1, offset = beta * 36 * progress, observerX = 358 + offset, frame = showLedger ? "train" : "platform";
+	return /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [W, H],
+		domain: "physics",
+		label: `Train at beta ${beta.toFixed(2)}. ${first} event is earlier in the train frame.`,
+		children: [
+			showMotion && /* @__PURE__ */ jsx(Arrow, {
+				x1: 360 - 55 * direction,
+				y1: 110,
+				x2: 360 + 55 * direction,
+				y2: 110,
+				color: HUE[1],
+				weight: "edge",
+				head: 9,
+				label: "v"
+			}),
+			/* @__PURE__ */ jsx(Ground, {
+				x1: 70,
+				x2: 650,
+				y: RAIL_Y
+			}),
+			/* @__PURE__ */ jsx(TrainCar, {
+				offset,
+				x: CAR_X,
+				y: CAR_Y,
+				width: CAR_W
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: observerX,
+				cy: OBSERVER_Y,
+				r: 7,
+				color: HUE.ink
+			}),
+			showLight && /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Ray, {
+				x1: REAR_X,
+				y1: RAIL_Y,
+				x2: observerX,
+				y2: OBSERVER_Y,
+				color: HUE[2],
+				width: 4,
+				opacity: .8
+			}), /* @__PURE__ */ jsx(Ray, {
+				x1: FRONT_X,
+				y1: RAIL_Y,
+				x2: observerX,
+				y2: OBSERVER_Y,
+				color: HUE[2],
+				width: 4,
+				opacity: .8
+			})] }),
+			/* @__PURE__ */ jsx(Strike, {
+				x: REAR_X,
+				progress
+			}),
+			/* @__PURE__ */ jsx(Strike, {
+				x: FRONT_X,
+				progress
+			}),
+			/* @__PURE__ */ jsx(Clock, {
+				x: REAR_X,
+				side: "rear",
+				frame,
+				timeNs: showLedger ? trainTimes.left : 0,
+				earlier: showLedger && first === "left"
+			}),
+			/* @__PURE__ */ jsx(Clock, {
+				x: FRONT_X,
+				side: "front",
+				frame,
+				timeNs: showLedger ? trainTimes.right : 0,
+				earlier: showLedger && first === "right"
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: 80,
+				cy: 336,
+				r: 5,
+				color: HUE[2]
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 92,
+				y: 336,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "strike event"
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				d: "M 200 340 A 8 8 0 0 1 216 340",
+				dashed: false,
+				color: HUE[2],
+				weight: "line"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 224,
+				y: 336,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "light front"
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: 330,
+				cy: 336,
+				r: 5,
+				color: HUE.ink
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 342,
+				y: 336,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "midpoint observer"
+			})
+		]
+	});
+}
+function RelativitySimultaneityLab({ beta: initial = .6, separationM = 300, title = "Two lightning strikes: whose “now” wins?", prompt = "Platform clocks mark two separated flashes simultaneously. Transform the same events into the moving train frame and compare their assigned times.", activity } = {}) {
+	const [beta, setBeta] = useState(initial), state = simultaneityState(beta, separationM), delta = Math.abs(state.train.deltaTimeNs);
+	const timeline = useExperimentTimeline({
+		durationMs: 3600,
+		stops: [
+			0,
+			.5,
+			1
+		]
+	});
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Field, {
+			label: "train speed β",
+			value: beta.toFixed(2),
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: beta,
+				min: -.9,
+				max: .9,
+				step: .01,
+				onChange: (value) => {
+					timeline.reset();
+					setBeta(value);
+				},
+				ariaLabel: "train velocity as a fraction of light speed"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "direction",
+			children: /* @__PURE__ */ jsx(Segmented, {
+				ariaLabel: "direction",
+				value: beta < 0 ? "left" : beta > 0 ? "right" : "rest",
+				onChange: (next) => {
+					timeline.reset();
+					if (next === "rest") setBeta(0);
+					else setBeta(next === "left" ? -Math.max(.1, Math.abs(beta)) : Math.max(.1, Math.abs(beta)));
+				},
+				options: [
+					{
+						value: "left",
+						label: "← left"
+					},
+					{
+						value: "rest",
+						label: "at rest"
+					},
+					{
+						value: "right",
+						label: "right →"
+					}
+				]
+			})
+		}),
+		/* @__PURE__ */ jsx(ExperimentTransport, {
+			timeline,
+			label: "event comparison",
+			detail: `${Math.round(timeline.progress * 100)}% · ${state.firstInTrain} first`
+		})
+	] });
+	const evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Readout, {
+		label: "train Δt′ (front − rear)",
+		value: `${state.train.deltaTimeNs.toFixed(1)} ns`,
+		sub: state.firstInTrain === "simultaneous" ? "simultaneous in both frames" : `${state.firstInTrain} event is earlier`
+	}), /* @__PURE__ */ jsxs(StatList, { children: [/* @__PURE__ */ jsx(Stat, {
+		label: "platform Δt",
+		value: "0.0 ns"
+	}), /* @__PURE__ */ jsx(Stat, {
+		label: "event separation",
+		value: `${separationM} m`
+	})] })] });
+	const showControls = (context) => ["act", "transfer"].includes(context.sequence.current.phase) ? controls : null;
+	const showEvidence = (context) => [
+		"observe",
+		"explain",
+		"transfer"
+	].includes(context.sequence.current.phase) ? evidence : null;
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		focusLayout: "immersive",
+		activity: activity ?? simultaneityActivity,
+		activityId: "relativity-simultaneity",
+		eyebrow: "Modern physics · special relativity",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs("span", { children: ["β ", beta.toFixed(2)] }),
+		controls: showControls,
+		evidence: showEvidence,
+		observation: beta === 0 ? "At rest, both frames share the same simultaneity slice." : `The event pair is unchanged; the moving frame assigns the ${state.firstInTrain} event ${delta.toFixed(1)} ns earlier.`,
+		children: (context) => /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(AuthoredMetricGate, {
+			conditionId: "comparison-complete",
+			met: timeline.progress >= 1,
+			complete: context.complete
+		}), /* @__PURE__ */ jsx(SimultaneityScene, {
+			beta,
+			first: state.firstInTrain,
+			trainTimes: {
+				left: state.train.left.ct * 1e9,
+				right: state.train.right.ct * 1e9
+			},
+			phase: context.sequence.current.phase,
+			progress: timeline.progress
+		})] })
+	});
+}
+
+//#endregion
+export { RelativitySimultaneityLab };

package/dist/physics/modern/relativity/spacetime.d.mts

@@ -0,0 +1,11 @@
+import { LightClockState } from "./core.mjs";
+import { ReactNode } from "react";
+
+//#region src/physics/modern/relativity/spacetime.d.ts
+declare function SpacetimeDiagram({
+  state
+}: {
+  state: LightClockState;
+}): ReactNode;
+//#endregion
+export { SpacetimeDiagram };

package/dist/physics/modern/relativity/spacetime.mjs

@@ -0,0 +1,168 @@
+import { Figure, HUE } from "../../../kit/figure/figure.mjs";
+import { FigText } from "../../../kit/figure/text.mjs";
+import { Ball } from "../../../kit/figure/body.mjs";
+import { Arrow, Track } from "../../../kit/figure/beam.mjs";
+import { Curve } from "../../../kit/figure/plot.mjs";
+import { lightClockEvents } from "./core.mjs";
+import { clipSegment } from "./scene-primitives.mjs";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/modern/relativity/spacetime.tsx
+const W = 520;
+const H = 300;
+const OX = 260;
+const OY = 262;
+const RANGE = 210;
+const PLOT = {
+	x0: 30,
+	y0: 40,
+	x1: 500,
+	y1: 274
+};
+function SpacetimeDiagram({ state }) {
+	const e = lightClockEvents(state.beta, state.mirrorHeight * 2), max = Math.max(2.2, e.return.ct * 1.08), sx = (x) => OX + x / max * RANGE, sy = (ct) => OY - ct / max * RANGE, current = {
+		x: state.shipX,
+		ct: state.coordinateElapsed
+	}, left = -max, right = max, ctLeft = current.ct + state.beta * (left - current.x), ctRight = current.ct + state.beta * (right - current.x), now = clipSegment(sx(left), sy(ctLeft), sx(right), sy(ctRight), PLOT);
+	return /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [W, H],
+		domain: "physics",
+		label: `Spacetime diagram with ship worldline at beta ${state.beta.toFixed(2)}`,
+		children: [
+			/* @__PURE__ */ jsx(Arrow, {
+				x1: PLOT.x0,
+				y1: OY,
+				x2: PLOT.x1 + 4,
+				y2: OY,
+				color: HUE.ink,
+				head: 8
+			}),
+			/* @__PURE__ */ jsx(Arrow, {
+				x1: OX,
+				y1: 276,
+				x2: OX,
+				y2: 30,
+				color: HUE.ink,
+				head: 8
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: PLOT.x1 + 10,
+				y: OY,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "x"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 268,
+				y: 34,
+				size: "note",
+				tone: "soft",
+				children: "ct"
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				points: [
+					[sx(-max), sy(max)],
+					[sx(0), sy(0)],
+					[sx(max), sy(max)]
+				],
+				color: HUE[2],
+				weight: "line"
+			}),
+			now && /* @__PURE__ */ jsx(Track, {
+				points: [[now[0], now[1]], [now[2], now[3]]],
+				color: HUE.soft,
+				weight: "line"
+			}),
+			/* @__PURE__ */ jsx(Curve, {
+				points: [[sx(0), sy(0)], [sx(e.return.x), sy(e.return.ct)]],
+				color: HUE[1],
+				weight: "bold"
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: sx(0),
+				cy: sy(0),
+				r: 4.5,
+				color: HUE[2]
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: sx(e.reflection.x),
+				cy: sy(e.reflection.ct),
+				r: 5,
+				color: HUE[2],
+				flash: state.event === "reflection" ? 1 : 0,
+				flashColor: HUE[2]
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: sx(e.return.x),
+				cy: sy(e.return.ct),
+				r: 4.5,
+				color: HUE[2]
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: sx(current.x),
+				cy: sy(current.ct),
+				r: 7,
+				color: HUE[1],
+				active: true
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				points: [[30, 290], [54, 290]],
+				dashed: false,
+				color: HUE[1],
+				weight: "edge"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 62,
+				y: 290,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "ship worldline"
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				points: [[170, 290], [194, 290]],
+				color: HUE[2],
+				weight: "line"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 202,
+				y: 290,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "light cone"
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				points: [[280, 290], [304, 290]],
+				color: HUE.soft,
+				weight: "line"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 312,
+				y: 290,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "ship’s now"
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: 400,
+				cy: 290,
+				r: 4.5,
+				color: HUE[2]
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 410,
+				y: 290,
+				baseline: "middle",
+				size: "note",
+				tone: "soft",
+				children: "tick events"
+			})
+		]
+	});
+}
+
+//#endregion
+export { SpacetimeDiagram };

package/dist/physics/modern/shared/experiment-transport.d.mts

@@ -0,0 +1,38 @@
+import { ReactNode, RefObject } from "react";
+
+//#region src/physics/modern/shared/experiment-transport.d.ts
+interface ExperimentTimeline {
+  progress: number;
+  playing: boolean;
+  ref: RefObject<HTMLDivElement | null>;
+  playPause: () => void;
+  reset: () => void;
+  step: () => void;
+  seek: (progress: number) => void;
+}
+interface ExperimentTimelineOptions {
+  durationMs?: number;
+  stops?: readonly number[];
+  initialProgress?: number;
+}
+declare function clampProgress(value: number): number;
+declare function nextTimelineStop(progress: number, stops: readonly number[]): number;
+/** One deterministic timeline shared by animation, scrubber, transcript, and evidence. */
+declare function useExperimentTimeline({
+  durationMs,
+  stops,
+  initialProgress
+}?: ExperimentTimelineOptions): ExperimentTimeline;
+declare function ExperimentTransport({
+  timeline,
+  label,
+  detail,
+  scrubAriaLabel
+}: {
+  timeline: ExperimentTimeline;
+  label?: string;
+  detail?: ReactNode;
+  scrubAriaLabel?: string;
+}): ReactNode;
+//#endregion
+export { ExperimentTimeline, ExperimentTimelineOptions, ExperimentTransport, clampProgress, nextTimelineStop, useExperimentTimeline };