@classytic/labs 0.1.0 → 0.3.0

package/dist/physics/modern/quantum/qubit-core.mjs

@@ -0,0 +1,52 @@
+//#region src/physics/modern/quantum/qubit-core.ts
+function qubitState(theta, phi) {
+	const t = Math.max(0, Math.min(Math.PI, theta)), p = (phi % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI), sin = Math.sin(t);
+	return {
+		theta: t,
+		phi: p,
+		x: sin * Math.cos(p),
+		y: sin * Math.sin(p),
+		z: Math.cos(t),
+		alpha: {
+			re: Math.cos(t / 2),
+			im: 0
+		},
+		beta: {
+			re: Math.cos(p) * Math.sin(t / 2),
+			im: Math.sin(p) * Math.sin(t / 2)
+		}
+	};
+}
+function measurementProbability(s, axis) {
+	return (1 + (axis === "x" ? s.x : axis === "y" ? s.y : s.z)) / 2;
+}
+const QUBIT_PRESETS = {
+	zero: {
+		label: "|0⟩",
+		theta: 0,
+		phi: 0
+	},
+	one: {
+		label: "|1⟩",
+		theta: Math.PI,
+		phi: 0
+	},
+	plus: {
+		label: "|+⟩",
+		theta: Math.PI / 2,
+		phi: 0
+	},
+	minus: {
+		label: "|−⟩",
+		theta: Math.PI / 2,
+		phi: Math.PI
+	},
+	plusI: {
+		label: "|+i⟩",
+		theta: Math.PI / 2,
+		phi: Math.PI / 2
+	}
+};
+
+//#endregion
+export { QUBIT_PRESETS, measurementProbability, qubitState };

package/dist/physics/modern/quantum/uncertainty-activity.d.mts

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

package/dist/physics/modern/quantum/uncertainty-activity.mjs

@@ -0,0 +1,74 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/quantum/uncertainty-activity.ts
+const uncertaintyActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Can a particle be sharp in position and momentum?",
+	objectives: [
+		"Interpret spread as quantum uncertainty",
+		"Connect position and momentum as Fourier-paired descriptions",
+		"Recognize a Gaussian minimum-uncertainty state"
+	],
+	success: [{
+		id: "cause",
+		source: "answer",
+		key: "cause",
+		pendingLabel: "Explain the reciprocal widths."
+	}],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Predict the momentum view",
+			lead: "What happens when the packet is localized?"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Narrow the position window",
+			lead: "Change one width and watch both distributions.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Compare the spreads",
+			lead: "Read Δx, Δp, and their product."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Connect the Fourier pair",
+			lead: "A narrow shape requires a broader range of wave numbers."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Reject the instrument myth",
+			lead: "The distributions belong to the prepared quantum state, not merely an inaccurate ruler."
+		}
+	],
+	questions: [{
+		id: "cause",
+		prompt: "Why does a narrowly localized Gaussian have a broad momentum distribution?",
+		choices: [
+			{
+				value: "fourier",
+				label: "Its position and momentum wavefunctions are Fourier pairs"
+			},
+			{
+				value: "camera",
+				label: "The detector is simply out of focus"
+			},
+			{
+				value: "slower",
+				label: "Localization makes every particle slower"
+			}
+		],
+		answer: "fourier",
+		explain: "Narrow support in one member of a Fourier pair requires broad support in the other. For this minimum-uncertainty Gaussian, ΔxΔp = ℏ/2."
+	}]
+});
+
+//#endregion
+export { uncertaintyActivity };

package/dist/physics/modern/quantum/uncertainty-core.d.mts

@@ -0,0 +1,11 @@
+//#region src/physics/modern/quantum/uncertainty-core.d.ts
+interface MinimumUncertaintyPacket {
+  sigmaX: number;
+  sigmaP: number;
+  product: number;
+  hbar: number;
+}
+declare function minimumUncertaintyPacket(sigmaX: number, hbar?: number): MinimumUncertaintyPacket;
+declare function gaussianProbability(value: number, sigma: number): number;
+//#endregion
+export { MinimumUncertaintyPacket, gaussianProbability, minimumUncertaintyPacket };

package/dist/physics/modern/quantum/uncertainty-core.mjs

@@ -0,0 +1,19 @@
+//#region src/physics/modern/quantum/uncertainty-core.ts
+function minimumUncertaintyPacket(sigmaX, hbar = 1) {
+	if (!Number.isFinite(sigmaX) || sigmaX <= 0) throw new RangeError("position spread must be positive");
+	if (!Number.isFinite(hbar) || hbar <= 0) throw new RangeError("hbar must be positive");
+	const sigmaP = hbar / (2 * sigmaX);
+	return {
+		sigmaX,
+		sigmaP,
+		product: sigmaX * sigmaP,
+		hbar
+	};
+}
+function gaussianProbability(value, sigma) {
+	if (!Number.isFinite(sigma) || sigma <= 0) throw new RangeError("spread must be positive");
+	return Math.exp(-.5 * Math.pow(value / sigma, 2));
+}
+
+//#endregion
+export { gaussianProbability, minimumUncertaintyPacket };

package/dist/physics/modern/quantum/uncertainty-preset.d.mts

@@ -0,0 +1,20 @@
+import { AuthoredActivity } from "../../../kit/activity-authoring.mjs";
+import { ReactNode } from "react";
+
+//#region src/physics/modern/quantum/uncertainty-preset.d.ts
+interface UncertaintyWavePacketLabProps {
+  positionSpread?: number;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  activity?: AuthoredActivity;
+}
+declare function UncertaintyWavePacketLab({
+  positionSpread: initialSpread,
+  title,
+  prompt,
+  objectives,
+  activity
+}?: UncertaintyWavePacketLabProps): ReactNode;
+//#endregion
+export { UncertaintyWavePacketLab, UncertaintyWavePacketLabProps };

package/dist/physics/modern/quantum/uncertainty-preset.mjs

@@ -0,0 +1,157 @@
+'use client';
+
+import { Slider } from "../../../kit/controls.mjs";
+import { Field, Readout } from "../../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { Figure, HUE } from "../../../kit/figure/figure.mjs";
+import { Arrow } from "../../../kit/figure/beam.mjs";
+import { Area, Curve, Guide, PlotFrame, scale } from "../../../kit/figure/plot.mjs";
+import { gaussianProbability, minimumUncertaintyPacket } from "./uncertainty-core.mjs";
+import { uncertaintyActivity } from "./uncertainty-activity.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/modern/quantum/uncertainty-preset.tsx
+const W = 720;
+const H = 292;
+const PLOTS = {
+	x: {
+		x: 44,
+		y: 52,
+		w: 300,
+		h: 200
+	},
+	p: {
+		x: 404,
+		y: 52,
+		w: 300,
+		h: 200
+	}
+};
+const X_DOMAIN = [-6, 6];
+const Y_DOMAIN = [0, 1.15];
+const SIGMA_HEIGHT = Math.exp(-.5);
+function packetCurve(sigma, sc) {
+	return Array.from({ length: 101 }, (_, i) => {
+		const v = i / 100 * 12 - 6;
+		return [sc.x(v), sc.y(gaussianProbability(v, sigma))];
+	});
+}
+function UncertaintyWavePacketLab({ positionSpread: initialSpread = 1.25, title = "Uncertainty: squeeze one view, spread the other", prompt = "Prepare a minimum-uncertainty Gaussian packet. Localize its position and watch the momentum distribution broaden—even before any individual measurement is made.", objectives, activity } = {}) {
+	const [sigmaX, setSigmaX] = useState(initialSpread), packet = minimumUncertaintyPacket(sigmaX), runtime = activity ?? (objectives ? {
+		...uncertaintyActivity.source,
+		objectives
+	} : uncertaintyActivity), controls = /* @__PURE__ */ jsx(Field, {
+		label: "position spread Δx",
+		value: `${packet.sigmaX.toFixed(2)} units`,
+		children: /* @__PURE__ */ jsx(Slider, {
+			value: sigmaX,
+			min: .25,
+			max: 3,
+			step: .05,
+			onChange: setSigmaX,
+			ariaLabel: "position uncertainty"
+		})
+	}), evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Readout, {
+		value: `Δx Δp = ${packet.product.toFixed(2)} ℏ`,
+		sub: "minimum-uncertainty Gaussian: the product remains ℏ/2"
+	}), /* @__PURE__ */ jsxs("div", {
+		className: "lab-metric-list",
+		children: [
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "position spread Δx" }), /* @__PURE__ */ jsx("strong", { children: packet.sigmaX.toFixed(2) })] }),
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "momentum spread Δp" }), /* @__PURE__ */ jsxs("strong", { children: [packet.sigmaP.toFixed(2), " ℏ/unit"] })] }),
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "prepared state" }), /* @__PURE__ */ jsx("strong", { children: "Gaussian" })] })
+		]
+	})] });
+	const panels = [{
+		key: "x",
+		box: PLOTS.x,
+		sigma: packet.sigmaX,
+		color: HUE[1],
+		title: "position |ψ(x)|²",
+		axis: "x",
+		spread: "Δx"
+	}, {
+		key: "p",
+		box: PLOTS.p,
+		sigma: packet.sigmaP,
+		color: HUE[2],
+		title: "momentum |φ(p)|²",
+		axis: "p",
+		spread: "Δp"
+	}];
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		focusLayout: "immersive",
+		activity: runtime,
+		activityId: "uncertainty-wave-packet",
+		eyebrow: "Modern physics · quantum evidence",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsxs("span", { children: ["Δx ", packet.sigmaX.toFixed(2)] }),
+			/* @__PURE__ */ jsxs("span", { children: ["Δp ", packet.sigmaP.toFixed(2)] }),
+			/* @__PURE__ */ jsx("span", { children: "product ℏ/2" })
+		] }),
+		controls,
+		evidence,
+		observation: "Squeezing the packet in position widens the spread of momentum components it is built from, and the product stays at ℏ/2. This is a property of the prepared state, not measurement error.",
+		children: /* @__PURE__ */ jsx(Figure, {
+			viewBox: [W, H],
+			domain: "physics",
+			label: `Position spread ${packet.sigmaX.toFixed(2)} and momentum spread ${packet.sigmaP.toFixed(2)}`,
+			children: panels.map((panel) => {
+				const sc = scale(panel.box, X_DOMAIN, Y_DOMAIN);
+				const pts = packetCurve(panel.sigma, sc);
+				const bottom = panel.box.y + panel.box.h;
+				const widthY = sc.y(SIGMA_HEIGHT);
+				return /* @__PURE__ */ jsxs(PlotFrame, {
+					...panel.box,
+					title: panel.title,
+					xLabel: panel.axis,
+					arrows: false,
+					xTicks: [
+						-4,
+						0,
+						4
+					].map((v) => ({
+						at: sc.x(v),
+						label: v < 0 ? `−${-v}` : String(v)
+					})),
+					children: [
+						/* @__PURE__ */ jsx(Guide, {
+							x1: sc.x(0),
+							y1: bottom,
+							x2: sc.x(0),
+							y2: panel.box.y + 6,
+							color: HUE.soft
+						}),
+						/* @__PURE__ */ jsx(Area, {
+							points: pts,
+							baseY: bottom,
+							color: panel.color,
+							opacity: 14
+						}),
+						/* @__PURE__ */ jsx(Curve, {
+							points: pts,
+							color: panel.color
+						}),
+						/* @__PURE__ */ jsx(Arrow, {
+							x1: sc.x(-panel.sigma),
+							y1: widthY,
+							x2: sc.x(panel.sigma),
+							y2: widthY,
+							color: panel.color,
+							weight: "line",
+							head: 6,
+							double: true,
+							label: panel.spread
+						})
+					]
+				}, panel.key);
+			})
+		})
+	});
+}
+
+//#endregion
+export { UncertaintyWavePacketLab };

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

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

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

@@ -0,0 +1,80 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/relativity/activity.ts
+const lightClockActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Two clocks, one pair of events",
+	objectives: [
+		"Distinguish proper time from coordinate time",
+		"Derive time dilation from a longer light path",
+		"Read the same events in a spacetime diagram"
+	],
+	success: [{
+		id: "tick-complete",
+		source: "metric",
+		key: "tick-complete",
+		pendingLabel: "Run one complete emission–reflection–return tick."
+	}, {
+		id: "proper-time",
+		source: "answer",
+		key: "clock",
+		pendingLabel: "Identify the proper-time clock."
+	}],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Predict before the pulse leaves",
+			lead: "From the platform, which clock takes longer between the same two tick events?",
+			success: "proper-time"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Trace one complete tick",
+			lead: "Scrub emission → reflection → return.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Link path and clocks",
+			lead: "The moving pulse follows a longer diagonal path while every observer still measures c."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Name the proper interval",
+			lead: "Ask which frame records both events at one location."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Set a target aging difference",
+			lead: "Choose a new speed and predict the ratio."
+		}
+	],
+	questions: [{
+		id: "clock",
+		prompt: "Which elapsed time is proper time for emission and return on the ship?",
+		choices: [
+			{
+				value: "ship",
+				label: "The ship clock"
+			},
+			{
+				value: "platform",
+				label: "The platform clock"
+			},
+			{
+				value: "both",
+				label: "Both are proper time"
+			}
+		],
+		answer: "ship",
+		explain: "Emission and return occur at the same place in the ship frame, so the ship clock measures the proper time Δτ."
+	}]
+});
+
+//#endregion
+export { lightClockActivity };

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

@@ -0,0 +1,29 @@
+//#region src/physics/modern/relativity/core.d.ts
+interface SpacetimeEvent {
+  x: number;
+  ct: number;
+}
+type LightClockEventName = 'emission' | 'outbound' | 'reflection' | 'return';
+interface LightClockState {
+  beta: number;
+  gamma: number;
+  progress: number;
+  event: LightClockEventName;
+  properElapsed: number;
+  coordinateElapsed: number;
+  shipX: number;
+  photonY: number;
+  mirrorHeight: number;
+  photonPathLength: number;
+}
+declare function validBeta(beta: number, max?: number): number;
+declare function lorentzGamma(beta: number): number;
+declare const coordinateTime: (properTime: number, beta: number) => number;
+declare const properTime: (coordinate: number, beta: number) => number;
+declare function lorentzTransform(event: SpacetimeEvent, beta: number): SpacetimeEvent;
+declare function inverseLorentzTransform(event: SpacetimeEvent, beta: number): SpacetimeEvent;
+declare const spacetimeInterval: (a: SpacetimeEvent, b?: SpacetimeEvent) => number;
+declare function lightClockState(beta: number, properTick?: number, progress?: number): LightClockState;
+declare function lightClockEvents(beta: number, properTick?: number): Record<'emission' | 'reflection' | 'return', SpacetimeEvent>;
+//#endregion
+export { LightClockEventName, LightClockState, SpacetimeEvent, coordinateTime, inverseLorentzTransform, lightClockEvents, lightClockState, lorentzGamma, lorentzTransform, properTime, spacetimeInterval, validBeta };

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

@@ -0,0 +1,60 @@
+//#region src/physics/modern/relativity/core.ts
+function validBeta(beta, max = .995) {
+	if (!Number.isFinite(beta)) throw new RangeError("beta must be finite");
+	return Math.max(-max, Math.min(max, beta));
+}
+function lorentzGamma(beta) {
+	const b = validBeta(beta);
+	return 1 / Math.sqrt(1 - b * b);
+}
+const coordinateTime = (properTime, beta) => properTime * lorentzGamma(beta);
+const properTime = (coordinate, beta) => coordinate / lorentzGamma(beta);
+function lorentzTransform(event, beta) {
+	const b = validBeta(beta), g = lorentzGamma(b);
+	return {
+		x: g * (event.x - b * event.ct),
+		ct: g * (event.ct - b * event.x)
+	};
+}
+function inverseLorentzTransform(event, beta) {
+	return lorentzTransform(event, -beta);
+}
+const spacetimeInterval = (a, b = {
+	x: 0,
+	ct: 0
+}) => (a.ct - b.ct) ** 2 - (a.x - b.x) ** 2;
+function lightClockState(beta, properTick = 2, progress = 0) {
+	const b = validBeta(beta), g = lorentzGamma(b), p = Math.max(0, Math.min(1, progress)), h = properTick / 2, tau = p * properTick, ct = g * tau, localPhase = p <= .5 ? p * 2 : (1 - p) * 2;
+	return {
+		beta: b,
+		gamma: g,
+		progress: p,
+		event: p === 0 ? "emission" : p < .5 ? "outbound" : p === .5 ? "reflection" : p < 1 ? "return" : "return",
+		properElapsed: tau,
+		coordinateElapsed: ct,
+		shipX: b * ct,
+		photonY: h * localPhase,
+		mirrorHeight: h,
+		photonPathLength: ct
+	};
+}
+function lightClockEvents(beta, properTick = 2) {
+	const g = lorentzGamma(beta), h = properTick / 2;
+	return {
+		emission: {
+			x: 0,
+			ct: 0
+		},
+		reflection: {
+			x: beta * g * h,
+			ct: g * h
+		},
+		return: {
+			x: beta * g * properTick,
+			ct: g * properTick
+		}
+	};
+}
+
+//#endregion
+export { coordinateTime, inverseLorentzTransform, lightClockEvents, lightClockState, lorentzGamma, lorentzTransform, properTime, spacetimeInterval, validBeta };

package/dist/physics/modern/relativity/explorer-activity.d.mts

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

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

@@ -0,0 +1,74 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/relativity/explorer-activity.ts
+const lorentzExplorerActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Change coordinates, preserve the event",
+	objectives: [
+		"Transform spacetime coordinates",
+		"Classify timelike, lightlike, and spacelike intervals",
+		"Verify the invariant interval"
+	],
+	success: [{
+		id: "invariant",
+		source: "answer",
+		key: "invariant",
+		pendingLabel: "Identify what every inertial frame preserves."
+	}],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Classify before transforming",
+			lead: "Place an event inside, on, or outside the light cone."
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Change the frame",
+			lead: "Drag the event and vary β.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Compare both ledgers",
+			lead: "Coordinates change while the interval remains fixed."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Read tilted axes",
+			lead: "A new frame changes its space and simultaneity directions."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Construct an interval",
+			lead: "Create an authored timelike, lightlike, or spacelike target."
+		}
+	],
+	questions: [{
+		id: "invariant",
+		prompt: "What remains unchanged under a Lorentz transformation?",
+		choices: [
+			{
+				value: "interval",
+				label: "the spacetime interval (ct)² − x²"
+			},
+			{
+				value: "time",
+				label: "the time coordinate alone"
+			},
+			{
+				value: "space",
+				label: "the position coordinate alone"
+			}
+		],
+		answer: "interval",
+		explain: "Space and time coordinates mix, but the Minkowski spacetime interval is invariant."
+	}]
+});
+
+//#endregion
+export { lorentzExplorerActivity };

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

@@ -0,0 +1,16 @@
+import { SpacetimeEvent } from "./core.mjs";
+
+//#region src/physics/modern/relativity/explorer-core.d.ts
+type IntervalKind = 'timelike' | 'lightlike' | 'spacelike';
+interface LorentzExplorerState {
+  beta: number;
+  event: SpacetimeEvent;
+  transformed: SpacetimeEvent;
+  interval: number;
+  transformedInterval: number;
+  kind: IntervalKind;
+}
+declare function intervalKind(interval: number, tolerance?: number): IntervalKind;
+declare function lorentzExplorerState(event: SpacetimeEvent, beta: number): LorentzExplorerState;
+//#endregion
+export { IntervalKind, LorentzExplorerState, intervalKind, lorentzExplorerState };

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

@@ -0,0 +1,21 @@
+import { lorentzTransform, spacetimeInterval, validBeta } from "./core.mjs";
+
+//#region src/physics/modern/relativity/explorer-core.ts
+function intervalKind(interval, tolerance = 1e-9) {
+	return Math.abs(interval) <= tolerance ? "lightlike" : interval > 0 ? "timelike" : "spacelike";
+}
+function lorentzExplorerState(event, beta) {
+	if (!Number.isFinite(event.x) || !Number.isFinite(event.ct)) throw new RangeError("event coordinates must be finite");
+	const b = validBeta(beta), transformed = lorentzTransform(event, b), interval = spacetimeInterval(event);
+	return {
+		beta: b,
+		event,
+		transformed,
+		interval,
+		transformedInterval: spacetimeInterval(transformed),
+		kind: intervalKind(interval)
+	};
+}
+
+//#endregion
+export { intervalKind, lorentzExplorerState };

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

@@ -0,0 +1,21 @@
+import { AuthoredActivity } from "../../../kit/activity-authoring.mjs";
+import { SpacetimeEvent } from "./core.mjs";
+import { ReactNode } from "react";
+
+//#region src/physics/modern/relativity/explorer-preset.d.ts
+interface LorentzTransformationLabProps {
+  event?: SpacetimeEvent;
+  beta?: number;
+  title?: string;
+  prompt?: string;
+  activity?: AuthoredActivity;
+}
+declare function LorentzTransformationLab({
+  event: initialEvent,
+  beta: initialBeta,
+  title,
+  prompt,
+  activity
+}?: LorentzTransformationLabProps): ReactNode;
+//#endregion
+export { LorentzTransformationLab, LorentzTransformationLabProps };