@classytic/labs 0.1.0 → 0.3.0

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

@@ -0,0 +1,232 @@
+'use client';
+
+import { ActivitySelect, Segmented, Slider } from "../../../kit/controls.mjs";
+import { Field, Readout, SceneViewport } from "../../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { Figure, HUE, tint } 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 { Guide } from "../../../kit/figure/plot.mjs";
+import { QUBIT_PRESETS, measurementProbability, qubitState } from "./qubit-core.mjs";
+import { blochSphereActivity } from "./bloch-activity.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/modern/quantum/bloch-preset.tsx
+const W = 520;
+const H = 356;
+const CX = 260;
+const CY = 178;
+const R = 125;
+/** Oblique projection: the y axis (into the page) foreshortens onto the equator's minor radius. */
+const RY = 38;
+const PRESET_IDS = Object.keys(QUBIT_PRESETS);
+function BlochProjectedScene({ state, axis }) {
+	const x = CX + state.x * R, y = CY - state.z * R + state.y * RY, length = Math.hypot(x - CX, y - CY);
+	const guide = axis === "z" ? {
+		x1: CX,
+		y1: 303,
+		x2: CX,
+		y2: CY - R
+	} : axis === "x" ? {
+		x1: CX - R,
+		y1: CY,
+		x2: 385,
+		y2: CY
+	} : {
+		x1: CX,
+		y1: CY - RY,
+		x2: CX,
+		y2: 216
+	};
+	return /* @__PURE__ */ jsxs(Figure, {
+		viewBox: [W, H],
+		domain: "physics",
+		label: `Qubit Bloch vector x ${state.x.toFixed(2)}, y ${state.y.toFixed(2)}, z ${state.z.toFixed(2)}`,
+		children: [
+			/* @__PURE__ */ jsx(Ball, {
+				cx: CX,
+				cy: CY,
+				r: R,
+				color: tint(HUE[3], 22)
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				points: [[CX, CY - R], [CX, 303]],
+				color: HUE.soft,
+				weight: "hair",
+				dashed: false
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				points: [[CX - R, CY], [385, CY]],
+				color: HUE.soft,
+				weight: "hair",
+				dashed: false
+			}),
+			/* @__PURE__ */ jsx(Track, {
+				d: `M ${CX - R} ${CY} A ${R} ${RY} 0 1 0 385 ${CY} A ${R} ${RY} 0 1 0 ${CX - R} ${CY}`,
+				color: HUE.soft,
+				weight: "hair"
+			}),
+			/* @__PURE__ */ jsx(Guide, {
+				...guide,
+				color: HUE[2]
+			}),
+			length > 4 && /* @__PURE__ */ jsx(Arrow, {
+				x1: CX,
+				y1: CY,
+				x2: x,
+				y2: y,
+				color: HUE[1],
+				weight: "bold",
+				head: 10
+			}),
+			/* @__PURE__ */ jsx(Ball, {
+				cx: x,
+				cy: y,
+				r: 7,
+				color: HUE[1]
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: CX,
+				y: CY - R - 12,
+				anchor: "middle",
+				size: "measure",
+				children: "|0⟩"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: CX,
+				y: 327,
+				anchor: "middle",
+				size: "measure",
+				children: "|1⟩"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: 395,
+				y: CY,
+				baseline: "middle",
+				children: "+x"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: CX - R - 10,
+				y: CY,
+				anchor: "end",
+				baseline: "middle",
+				children: "−x"
+			}),
+			/* @__PURE__ */ jsx(FigText, {
+				x: CX - 12,
+				y: 234,
+				anchor: "end",
+				size: "note",
+				tone: "soft",
+				children: "+y"
+			})
+		]
+	});
+}
+function BlochSphereLab({ preset = "plus", measurementAxis: initialAxis = "z", title = "Qubit compass: state and measurement", prompt = "A pure qubit is a direction. Rotate its polar angle and relative phase, then ask different measurement questions without moving the state.", activity, sceneRenderer: Scene = BlochProjectedScene } = {}) {
+	const initial = QUBIT_PRESETS[preset], [theta, setTheta] = useState(initial.theta), [phi, setPhi] = useState(initial.phi), [axis, setAxis] = useState(initialAxis), s = qubitState(theta, phi), p = measurementProbability(s, axis);
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Field, {
+			label: "state presets",
+			children: /* @__PURE__ */ jsx(ActivitySelect, {
+				ariaLabel: "state presets",
+				value: PRESET_IDS.find((k) => Math.abs(theta - QUBIT_PRESETS[k].theta) < .01 && Math.abs(phi - QUBIT_PRESETS[k].phi) < .01) ?? "",
+				onChange: (k) => {
+					if (!k) return;
+					setTheta(QUBIT_PRESETS[k].theta);
+					setPhi(QUBIT_PRESETS[k].phi);
+				},
+				options: PRESET_IDS.map((k) => ({
+					value: k,
+					label: QUBIT_PRESETS[k].label
+				}))
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "polar angle θ",
+			value: `${Math.round(theta * 180 / Math.PI)}°`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: theta,
+				min: 0,
+				max: Math.PI,
+				step: .01,
+				onChange: setTheta,
+				ariaLabel: "Bloch polar angle"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "relative phase φ",
+			value: `${Math.round(phi * 180 / Math.PI)}°`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: phi,
+				min: 0,
+				max: 2 * Math.PI,
+				step: .01,
+				onChange: setPhi,
+				ariaLabel: "qubit relative phase"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "measurement basis",
+			children: /* @__PURE__ */ jsx(Segmented, {
+				ariaLabel: "measurement basis",
+				value: axis,
+				onChange: setAxis,
+				options: [
+					"x",
+					"y",
+					"z"
+				].map((a) => ({
+					value: a,
+					label: a.toUpperCase()
+				}))
+			})
+		})
+	] }), evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Readout, {
+		value: `P(+${axis}) ${(p * 100).toFixed(1)}%`,
+		sub: `P(−${axis}) ${((1 - p) * 100).toFixed(1)}%`
+	}), /* @__PURE__ */ jsxs("div", {
+		className: "lab-metric-list",
+		children: [
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "α · |0⟩" }), /* @__PURE__ */ jsx("strong", { children: s.alpha.re.toFixed(3) })] }),
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "β magnitude" }), /* @__PURE__ */ jsx("strong", { children: Math.hypot(s.beta.re, s.beta.im).toFixed(3) })] }),
+			/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "β phase" }), /* @__PURE__ */ jsxs("strong", { children: [Math.round(s.phi * 180 / Math.PI), "°"] })] })
+		]
+	})] });
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		activity: activity ?? blochSphereActivity,
+		activityId: "bloch-sphere",
+		focusLayout: "immersive",
+		eyebrow: "Modern physics · quantum state",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsxs("span", { children: [
+				"θ ",
+				Math.round(theta * 180 / Math.PI),
+				"°"
+			] }),
+			/* @__PURE__ */ jsxs("span", { children: [
+				"φ ",
+				Math.round(phi * 180 / Math.PI),
+				"°"
+			] }),
+			/* @__PURE__ */ jsxs("span", { children: [axis.toUpperCase(), " basis"] })
+		] }),
+		controls,
+		evidence,
+		observation: `The state vector is unchanged. Measuring along ${axis.toUpperCase()} asks how much it points toward that axis: P(+) = (1 + r${axis}) / 2 = ${(p * 100).toFixed(1)}%.`,
+		children: /* @__PURE__ */ jsx(SceneViewport, {
+			label: "Bloch sphere state model",
+			children: /* @__PURE__ */ jsx(Scene, {
+				state: s,
+				axis
+			})
+		})
+	});
+}
+
+//#endregion
+export { BlochProjectedScene, BlochSphereLab };

package/dist/physics/modern/quantum/double-slit-activity.d.mts

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

package/dist/physics/modern/quantum/double-slit-activity.mjs

@@ -0,0 +1,74 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/physics/modern/quantum/double-slit-activity.ts
+const doubleSlitActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "Random dots, lawful pattern",
+	objectives: [
+		"Distinguish individual detections from the probability distribution",
+		"Relate fringe spacing to wavelength and slit separation",
+		"Explain why available path information removes interference"
+	],
+	success: [{
+		id: "path",
+		source: "answer",
+		key: "path",
+		pendingLabel: "Explain the which-path result."
+	}],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Predict one photon",
+			lead: "Can you predict its exact landing point?"
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Accumulate detections",
+			lead: "Increase exposure and change the apparatus.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Find order in randomness",
+			lead: "Individual events build a repeatable distribution."
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Reveal the path",
+			lead: "Make path information available and compare."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Spread the fringes",
+			lead: "Change wavelength or slit separation."
+		}
+	],
+	questions: [{
+		id: "path",
+		prompt: "Why does the interference pattern vanish when path information is available?",
+		choices: [
+			{
+				value: "distinguishable",
+				label: "The alternatives become distinguishable"
+			},
+			{
+				value: "blocked",
+				label: "Both slits become blocked"
+			},
+			{
+				value: "faster",
+				label: "Photons travel faster"
+			}
+		],
+		answer: "distinguishable",
+		explain: "Interference requires indistinguishable alternatives. A path-marking interaction removes their coherent cross term."
+	}]
+});
+
+//#endregion
+export { doubleSlitActivity };

package/dist/physics/modern/quantum/double-slit-core.d.mts

@@ -0,0 +1,17 @@
+//#region src/physics/modern/quantum/double-slit-core.d.ts
+interface SlitSetup {
+  wavelengthNm: number;
+  slitSeparationUm: number;
+  slitWidthUm: number;
+  screenDistanceM: number;
+  whichPath: boolean;
+}
+interface SlitSample {
+  positionMm: number;
+  bin: number;
+}
+declare function slitIntensity(positionMm: number, s: SlitSetup): number;
+declare function sampleSlitDetections(count: number, setup: SlitSetup, bins?: number, seed?: number): SlitSample[];
+declare function fringeSpacingMm(s: SlitSetup): number;
+//#endregion
+export { SlitSetup, fringeSpacingMm, sampleSlitDetections, slitIntensity };

package/dist/physics/modern/quantum/double-slit-core.mjs

@@ -0,0 +1,26 @@
+//#region src/physics/modern/quantum/double-slit-core.ts
+function slitIntensity(positionMm, s) {
+	const y = positionMm / 1e3, lambda = s.wavelengthNm * 1e-9, d = s.slitSeparationUm * 1e-6, a = s.slitWidthUm * 1e-6, theta = Math.atan2(y, s.screenDistanceM), alpha = Math.PI * a * Math.sin(theta) / lambda, beta = Math.PI * d * Math.sin(theta) / lambda;
+	return (alpha === 0 ? 1 : (Math.sin(alpha) / alpha) ** 2) * (s.whichPath ? 1 : (1 + Math.cos(2 * beta)) / 2);
+}
+function random(seed) {
+	const x = Math.sin(seed * 12.9898 + 78.233) * 43758.5453;
+	return x - Math.floor(x);
+}
+function sampleSlitDetections(count, setup, bins = 101, seed = 17) {
+	const weights = Array.from({ length: bins }, (_, i) => slitIntensity(-40 + 80 * i / (bins - 1), setup)), total = weights.reduce((a, b) => a + b, 0), cdf = [];
+	weights.reduce((a, w, i) => (cdf[i] = a + w / total, a + w / total), 0);
+	return Array.from({ length: Math.max(0, Math.min(5e3, Math.floor(count))) }, (_, i) => {
+		const r = random(seed + i), bin = Math.max(0, cdf.findIndex((v) => v >= r));
+		return {
+			bin,
+			positionMm: -40 + 80 * bin / (bins - 1)
+		};
+	});
+}
+function fringeSpacingMm(s) {
+	return s.wavelengthNm * 1e-9 * s.screenDistanceM / (s.slitSeparationUm * 1e-6) * 1e3;
+}
+
+//#endregion
+export { fringeSpacingMm, sampleSlitDetections, slitIntensity };

package/dist/physics/modern/quantum/double-slit-preset.d.mts

@@ -0,0 +1,24 @@
+import { AuthoredActivity } from "../../../kit/activity-authoring.mjs";
+import { ReactNode } from "react";
+
+//#region src/physics/modern/quantum/double-slit-preset.d.ts
+interface DoubleSlitLabProps {
+  wavelengthNm?: number;
+  slitSeparationUm?: number;
+  detections?: number;
+  whichPath?: boolean;
+  title?: string;
+  prompt?: string;
+  activity?: AuthoredActivity;
+}
+declare function DoubleSlitLab({
+  wavelengthNm: initialWave,
+  slitSeparationUm: initialD,
+  detections: initialCount,
+  whichPath: initialPath,
+  title,
+  prompt,
+  activity
+}?: DoubleSlitLabProps): ReactNode;
+//#endregion
+export { DoubleSlitLab, DoubleSlitLabProps };

package/dist/physics/modern/quantum/double-slit-preset.mjs

@@ -0,0 +1,266 @@
+'use client';
+
+import { ActivitySelect, Slider } from "../../../kit/controls.mjs";
+import { Field, Readout } from "../../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { Figure, HUE, alpha, tint } from "../../../kit/figure/figure.mjs";
+import { FigText } from "../../../kit/figure/text.mjs";
+import { Ball, Block, Particle } from "../../../kit/figure/body.mjs";
+import { Ray } from "../../../kit/figure/beam.mjs";
+import { Curve, PlotFrame } from "../../../kit/figure/plot.mjs";
+import { fringeSpacingMm, sampleSlitDetections, slitIntensity } from "./double-slit-core.mjs";
+import { doubleSlitActivity } from "./double-slit-activity.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/modern/quantum/double-slit-preset.tsx
+const W = 720;
+const H = 352;
+const BINS = 101;
+const SOURCE = {
+	cx: 56,
+	cy: 180,
+	r: 10
+};
+const BARRIER = {
+	x: 228,
+	w: 14,
+	top: 44,
+	bottom: 316
+};
+const SLITS = [{
+	y: 142,
+	h: 18
+}, {
+	y: 200,
+	h: 18
+}];
+const SCREEN = {
+	x: 556,
+	y: 40,
+	w: 44,
+	h: 280
+};
+const PROFILE = {
+	x: 612,
+	y: 48,
+	w: 84,
+	h: 265
+};
+const ROW = PROFILE.h / (BINS - 1);
+const MAX_DOTS = 400;
+const LABEL_Y = 340;
+function DoubleSlitLab({ wavelengthNm: initialWave = 550, slitSeparationUm: initialD = 120, detections: initialCount = 80, whichPath: initialPath = false, title = "One dot at a time: the double slit", prompt = "Send individual photons through two slits. No single impact draws a wave, yet accumulated impacts reveal an interference probability.", activity } = {}) {
+	const [wave, setWave] = useState(initialWave), [d, setD] = useState(initialD), [count, setCount] = useState(initialCount), [whichPath, setWhichPath] = useState(initialPath), setup = {
+		wavelengthNm: wave,
+		slitSeparationUm: d,
+		slitWidthUm: 28,
+		screenDistanceM: 1,
+		whichPath
+	}, samples = sampleSlitDetections(count, setup), bins = Array(BINS).fill(0);
+	samples.forEach((v) => {
+		bins[v.bin] = (bins[v.bin] ?? 0) + 1;
+	});
+	const weights = Array.from({ length: BINS }, (_, i) => slitIntensity(-40 + 80 * i / (BINS - 1), setup));
+	const total = weights.reduce((a, b) => a + b, 0) || 1;
+	const expected = weights.map((w) => count * w / total);
+	const unit = PROFILE.w * .92 / Math.max(1, ...bins, ...expected);
+	const rowY = (i) => PROFILE.y + i * ROW;
+	const profile = expected.map((e, i) => [PROFILE.x + e * unit, rowY(i)]);
+	const slitCenters = SLITS.map((s) => s.y + s.h / 2);
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Field, {
+			label: "path information",
+			children: /* @__PURE__ */ jsx(ActivitySelect, {
+				ariaLabel: "path information",
+				value: whichPath ? "detector" : "indistinguishable",
+				onChange: (next) => setWhichPath(next === "detector"),
+				options: [{
+					value: "indistinguishable",
+					label: "Interference visible"
+				}, {
+					value: "detector",
+					label: "Which-path detector"
+				}]
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "detections",
+			value: String(count),
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: count,
+				min: 1,
+				max: 1e3,
+				step: 1,
+				onChange: setCount,
+				ariaLabel: "number of photon detections"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "wavelength",
+			value: `${wave} nm`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: wave,
+				min: 380,
+				max: 700,
+				step: 5,
+				onChange: setWave,
+				ariaLabel: "photon wavelength"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "slit separation",
+			value: `${d} μm`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: d,
+				min: 60,
+				max: 240,
+				step: 5,
+				onChange: setD,
+				ariaLabel: "slit separation"
+			})
+		})
+	] }), evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(Readout, {
+		value: whichPath ? "No interference fringes" : "Interference emerges",
+		sub: `${fringeSpacingMm(setup).toFixed(2)} mm predicted fringe spacing`
+	}), /* @__PURE__ */ jsx("p", { children: "Each dot is one localized detection. The histogram estimates the probability distribution only after many repeated events." })] });
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		focusLayout: "immersive",
+		activity: activity ?? doubleSlitActivity,
+		activityId: "double-slit",
+		eyebrow: "Modern physics · quantum probability",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsxs("span", { children: [count, " detections"] }),
+			/* @__PURE__ */ jsxs("span", { children: [wave, " nm"] }),
+			/* @__PURE__ */ jsx("span", { children: whichPath ? "path known" : "paths indistinguishable" })
+		] }),
+		controls,
+		evidence,
+		observation: whichPath ? "Path marking makes the alternatives distinguishable, so the interference cross term disappears." : "The exact next impact remains unpredictable, but repeated detections build stable bright and dark fringes.",
+		children: /* @__PURE__ */ jsxs(Figure, {
+			viewBox: [W, H],
+			domain: "physics",
+			label: `${count} accumulated detections ${whichPath ? "without" : "with"} interference`,
+			children: [
+				/* @__PURE__ */ jsx(Ray, {
+					x1: SOURCE.cx + SOURCE.r + 2,
+					y1: SOURCE.cy,
+					x2: BARRIER.x - 2,
+					y2: SOURCE.cy,
+					color: HUE[2],
+					width: 6,
+					opacity: .55
+				}),
+				slitCenters.map((sy) => /* @__PURE__ */ jsx("path", {
+					d: `M ${BARRIER.x + BARRIER.w} ${sy} L ${SCREEN.x} ${SCREEN.y + 12} L ${SCREEN.x} ${SCREEN.y + SCREEN.h - 12} Z`,
+					fill: alpha(HUE[2], 9)
+				}, sy)),
+				/* @__PURE__ */ jsx(Ball, {
+					cx: SOURCE.cx,
+					cy: SOURCE.cy,
+					r: SOURCE.r,
+					color: HUE[2]
+				}),
+				/* @__PURE__ */ jsx(Block, {
+					x: BARRIER.x,
+					y: BARRIER.top,
+					w: BARRIER.w,
+					h: SLITS[0].y - BARRIER.top,
+					radius: 3,
+					color: HUE.metal
+				}),
+				/* @__PURE__ */ jsx(Block, {
+					x: BARRIER.x,
+					y: SLITS[0].y + SLITS[0].h,
+					w: BARRIER.w,
+					h: SLITS[1].y - SLITS[0].y - SLITS[0].h,
+					radius: 3,
+					color: HUE.metal
+				}),
+				/* @__PURE__ */ jsx(Block, {
+					x: BARRIER.x,
+					y: SLITS[1].y + SLITS[1].h,
+					w: BARRIER.w,
+					h: BARRIER.bottom - SLITS[1].y - SLITS[1].h,
+					radius: 3,
+					color: HUE.metal
+				}),
+				whichPath && /* @__PURE__ */ jsxs(Fragment$1, { children: [SLITS.map((s) => /* @__PURE__ */ jsx(Block, {
+					x: BARRIER.x + BARRIER.w + 4,
+					y: s.y + 4,
+					w: 10,
+					h: 10,
+					radius: 2,
+					color: HUE.warn
+				}, s.y)), /* @__PURE__ */ jsx(FigText, {
+					x: BARRIER.x + BARRIER.w / 2,
+					y: BARRIER.top - 12,
+					anchor: "middle",
+					size: "eyebrow",
+					tone: "soft",
+					children: "path marked"
+				})] }),
+				/* @__PURE__ */ jsx(Block, {
+					...SCREEN,
+					radius: 6,
+					color: tint(HUE.soft, 30)
+				}),
+				samples.slice(0, MAX_DOTS).map((v, i) => /* @__PURE__ */ jsx(Particle, {
+					x: SCREEN.x + 7 + i * 37 % (SCREEN.w - 14),
+					y: rowY(v.bin),
+					r: 2.2,
+					color: HUE[2],
+					opacity: .85
+				}, i)),
+				/* @__PURE__ */ jsxs(PlotFrame, {
+					...PROFILE,
+					arrows: false,
+					xLabel: "counts",
+					children: [bins.map((n, i) => n ? /* @__PURE__ */ jsx(Block, {
+						x: PROFILE.x,
+						y: rowY(i) - ROW / 2,
+						w: n * unit,
+						h: ROW,
+						radius: 1,
+						color: HUE[2]
+					}, i) : null), /* @__PURE__ */ jsx(Curve, {
+						points: profile,
+						color: HUE[1],
+						weight: "line",
+						dashed: true,
+						opacity: .6
+					})]
+				}),
+				/* @__PURE__ */ jsx(FigText, {
+					x: SOURCE.cx,
+					y: LABEL_Y,
+					anchor: "middle",
+					size: "note",
+					tone: "soft",
+					children: "source"
+				}),
+				/* @__PURE__ */ jsx(FigText, {
+					x: BARRIER.x + BARRIER.w / 2,
+					y: LABEL_Y,
+					anchor: "middle",
+					size: "note",
+					tone: "soft",
+					children: "two slits"
+				}),
+				/* @__PURE__ */ jsx(FigText, {
+					x: SCREEN.x + SCREEN.w / 2,
+					y: LABEL_Y,
+					anchor: "middle",
+					size: "note",
+					tone: "soft",
+					children: "screen"
+				})
+			]
+		})
+	});
+}
+
+//#endregion
+export { DoubleSlitLab };

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

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