@classytic/labs 0.1.0 → 0.3.0

package/dist/chem/bohr-atom.mjs

@@ -2,21 +2,22 @@
 
 import { clamp, num } from "../core/util.mjs";
 import { Slider } from "../kit/controls.mjs";
-import { Callout, ControlBar, Field, LabFrame } from "../kit/frame.mjs";
+import { Field, Stat, StatList } from "../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../kit/authored-activity-runtime.mjs";
 import { PlayWrap, usePlayGate } from "../kit/play.mjs";
 import { useEffect, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { Circle, Dot, Label, Stage, useFrameLoop } from "@classytic/stage";
 
 //#region src/chem/bohr-atom.tsx
 /**
-* BohrAtom — the classic shell model of an atom, animated.
+* BohrAtom, the classic shell model of an atom, animated.
 *
 * Nucleus (Z protons) ringed by electron shells filled 2, 8, 8, 18…; electrons
 * orbit at a steady clip via the engine clock. Drag the proton count to walk the
 * first 20 elements and watch shells fill and close.
 *
-* Now on the @classytic/stage engine (SVG, accessible, themed) — shells are
+* Now on the @classytic/stage engine (SVG, accessible, themed), shells are
 * Circles, electrons are Dots, the nucleus is a labelled Circle.
 */
 const SYMBOLS = [
@@ -101,13 +102,40 @@ function shellsFor(z) {
 	}
 	return shells;
 }
+const ACTIVITY = {
+	pattern: "investigation",
+	title: "Bohr model of the atom",
+	objectives: ["Connect atomic number to electron count", "Read shell configurations"],
+	steps: [
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Read an electron configuration",
+			lead: "Connect atomic number to the occupied shells.",
+			reveal: ["model"]
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Build another atom",
+			lead: "Change the proton count and watch electrons fill shells.",
+			controls: true
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Explain a closed shell",
+			lead: "Use the shell capacities and configuration as evidence."
+		}
+	]
+};
 const VIEW = {
 	xMin: -10,
 	xMax: 10,
 	yMin: -10,
 	yMax: 10
 };
-function BohrAtom({ protons, title = "Bohr model of the atom", height = 340 } = {}) {
+function BohrAtom({ protons, title = "Bohr model of the atom", height = 340, activity = ACTIVITY } = {}) {
 	const [z, setZ] = useState(clamp(Math.round(num(protons, 6)), 1, 20));
 	const [spin, setSpin] = useState(0);
 	const gate = usePlayGate();
@@ -172,7 +200,7 @@ function BohrAtom({ protons, title = "Bohr model of the atom", height = 340 } =
 			]
 		})
 	});
-	const controls = /* @__PURE__ */ jsx(ControlBar, { children: /* @__PURE__ */ jsx(Field, {
+	const controls = /* @__PURE__ */ jsx(Fragment$1, { children: /* @__PURE__ */ jsx(Field, {
 		label: "protons (Z)",
 		value: z,
 		children: /* @__PURE__ */ jsx(Slider, {
@@ -181,29 +209,56 @@ function BohrAtom({ protons, title = "Bohr model of the atom", height = 340 } =
 			max: 20,
 			step: 1,
 			onChange: (v) => setZ(Math.round(v)),
-			ariaLabel: "proton count",
-			style: { width: 130 }
+			ariaLabel: "proton count"
 		})
 	}) });
-	return /* @__PURE__ */ jsx(LabFrame, {
-		title,
-		prompt: "Drag the proton count to walk the first 20 elements — watch the shells fill (2, 8, 8, …).",
-		aside: /* @__PURE__ */ jsx(Callout, {
-			tone: "result",
-			children: /* @__PURE__ */ jsxs("span", {
-				style: {
-					display: "grid",
-					gap: 4,
-					fontVariantNumeric: "tabular-nums"
-				},
-				children: [
-					/* @__PURE__ */ jsxs("span", { children: ["element ", SYMBOLS[z] ?? "—"] }),
-					/* @__PURE__ */ jsxs("span", { children: ["Z ", z] }),
-					/* @__PURE__ */ jsxs("span", { children: ["config ", shells.join(", ")] })
-				]
-			})
+	const aside = /* @__PURE__ */ jsxs(StatList, { children: [
+		/* @__PURE__ */ jsx(Stat, {
+			label: "element",
+			value: SYMBOLS[z] ?? ", "
+		}),
+		/* @__PURE__ */ jsx(Stat, {
+			label: "Z",
+			value: z
 		}),
+		/* @__PURE__ */ jsx(Stat, {
+			label: "config",
+			value: shells.join(", ")
+		})
+	] });
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		focusLayout: "immersive",
+		activity,
+		activityId: "bohr-atom",
+		eyebrow: "Atomic structure",
+		title,
+		description: "Change atomic number and watch electrons fill the shells 2, 8, 8, …",
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("span", { children: SYMBOLS[z] }),
+			/* @__PURE__ */ jsxs("span", { children: ["Z ", z] }),
+			/* @__PURE__ */ jsx("span", { children: shells.join(", ") })
+		] }),
+		evidence: aside,
 		controls,
+		observation: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			"A neutral atom has ",
+			z,
+			" electrons arranged as ",
+			shells.join(", "),
+			" across ",
+			shells.length,
+			" occupied shell",
+			shells.length === 1 ? "" : "s",
+			"."
+		] }),
+		transcript: /* @__PURE__ */ jsxs("p", { children: [
+			SYMBOLS[z],
+			" has atomic number ",
+			z,
+			" and electron configuration ",
+			shells.join(", "),
+			"."
+		] }),
 		children: figure
 	});
 }

package/dist/chem/crystal-lattice/activity.d.mts

@@ -0,0 +1,6 @@
+import { CompiledAuthoredActivity } from "../../kit/activity-authoring.mjs";
+
+//#region src/chem/crystal-lattice/activity.d.ts
+declare const crystalLatticeActivity: CompiledAuthoredActivity;
+//#endregion
+export { crystalLatticeActivity };

package/dist/chem/crystal-lattice/activity.mjs

@@ -0,0 +1,95 @@
+import { defineAuthoredActivity } from "../../kit/activity-authoring.mjs";
+
+//#region src/chem/crystal-lattice/activity.ts
+const crystalLatticeActivity = defineAuthoredActivity({
+	pattern: "investigation",
+	title: "From one unit cell to a crystal",
+	objectives: [
+		"Distinguish simple cubic, BCC, and FCC unit cells",
+		"Relate shared lattice sites to atoms per unit cell",
+		"Compare coordination number and packing efficiency"
+	],
+	success: [{
+		id: "packing-understood",
+		source: "answer",
+		key: "densest",
+		pendingLabel: "Identify the most efficiently packed cubic structure."
+	}],
+	steps: [
+		{
+			id: "predict",
+			phase: "predict",
+			title: "Predict the densest cell",
+			lead: "Choose a structure before comparing its evidence.",
+			reveal: ["model"]
+		},
+		{
+			id: "act",
+			phase: "act",
+			title: "Build the repeating solid",
+			lead: "Change the unit cell and repeat it through space.",
+			controls: true
+		},
+		{
+			id: "observe",
+			phase: "observe",
+			title: "Read local and bulk structure",
+			lead: "Connect neighbours and shared sites to the unit-cell totals.",
+			reveal: ["model"]
+		},
+		{
+			id: "explain",
+			phase: "explain",
+			title: "Explain the packing",
+			lead: "Use geometry rather than the apparent number of drawn spheres."
+		},
+		{
+			id: "transfer",
+			phase: "transfer",
+			title: "Choose a structure for a new material",
+			lead: "Apply coordination and packing evidence to a material-design decision."
+		}
+	],
+	questions: [{
+		id: "densest",
+		prompt: "Which cubic structure has the greatest packing efficiency?",
+		choices: [
+			{
+				value: "sc",
+				label: "Simple cubic"
+			},
+			{
+				value: "bcc",
+				label: "Body-centred cubic"
+			},
+			{
+				value: "fcc",
+				label: "Face-centred cubic"
+			}
+		],
+		answer: "fcc",
+		explain: "FCC packs atoms along face diagonals and occupies about 74% of the cell."
+	}, {
+		id: "material-choice",
+		prompt: "A model needs the greatest coordination and least empty space. Which unit cell should it use?",
+		choices: [
+			{
+				value: "fcc",
+				label: "FCC"
+			},
+			{
+				value: "bcc",
+				label: "BCC"
+			},
+			{
+				value: "sc",
+				label: "Simple cubic"
+			}
+		],
+		answer: "fcc",
+		explain: "FCC combines coordination number 12 with about 74% packing efficiency, the highest of these cubic cells."
+	}]
+});
+
+//#endregion
+export { crystalLatticeActivity };

package/dist/chem/crystal-lattice/core.d.mts

@@ -0,0 +1,19 @@
+//#region src/chem/crystal-lattice/core.d.ts
+type CrystalLatticeKind = 'simple-cubic' | 'body-centred' | 'face-centred';
+interface LatticeFacts {
+  label: string;
+  atomsPerCell: number;
+  coordination: number;
+  packingEfficiency: number;
+}
+interface LatticePoint {
+  x: number;
+  y: number;
+  z: number;
+  site: 'corner' | 'body' | 'face';
+}
+declare const LATTICE_FACTS: Record<CrystalLatticeKind, LatticeFacts>;
+/** Unique lattice sites for an n×n×n block; shared boundary atoms are emitted once. */
+declare function latticePoints(kind: CrystalLatticeKind, repetitions?: number): LatticePoint[];
+//#endregion
+export { CrystalLatticeKind, LATTICE_FACTS, LatticeFacts, LatticePoint, latticePoints };

package/dist/chem/crystal-lattice/core.mjs

@@ -0,0 +1,101 @@
+//#region src/chem/crystal-lattice/core.ts
+const LATTICE_FACTS = {
+	"simple-cubic": {
+		label: "Simple cubic",
+		atomsPerCell: 1,
+		coordination: 6,
+		packingEfficiency: Math.PI / 6
+	},
+	"body-centred": {
+		label: "Body-centred cubic",
+		atomsPerCell: 2,
+		coordination: 8,
+		packingEfficiency: Math.sqrt(3) * Math.PI / 8
+	},
+	"face-centred": {
+		label: "Face-centred cubic",
+		atomsPerCell: 4,
+		coordination: 12,
+		packingEfficiency: Math.PI / (3 * Math.sqrt(2))
+	}
+};
+const basis = (kind) => {
+	const corners = [0, 1].flatMap((x) => [0, 1].flatMap((y) => [0, 1].map((z) => ({
+		x,
+		y,
+		z,
+		site: "corner"
+	}))));
+	if (kind === "body-centred") return [...corners, {
+		x: .5,
+		y: .5,
+		z: .5,
+		site: "body"
+	}];
+	if (kind === "face-centred") return [
+		...corners,
+		{
+			x: .5,
+			y: .5,
+			z: 0,
+			site: "face"
+		},
+		{
+			x: .5,
+			y: .5,
+			z: 1,
+			site: "face"
+		},
+		{
+			x: .5,
+			y: 0,
+			z: .5,
+			site: "face"
+		},
+		{
+			x: .5,
+			y: 1,
+			z: .5,
+			site: "face"
+		},
+		{
+			x: 0,
+			y: .5,
+			z: .5,
+			site: "face"
+		},
+		{
+			x: 1,
+			y: .5,
+			z: .5,
+			site: "face"
+		}
+	];
+	return corners;
+};
+/** Unique lattice sites for an n×n×n block; shared boundary atoms are emitted once. */
+function latticePoints(kind, repetitions = 1) {
+	const n = Math.max(1, Math.min(3, Math.round(repetitions)));
+	const points = /* @__PURE__ */ new Map();
+	for (let x = 0; x < n; x += 1) for (let y = 0; y < n; y += 1) for (let z = 0; z < n; z += 1) basis(kind).forEach((point) => {
+		const item = {
+			...point,
+			x: point.x + x,
+			y: point.y + y,
+			z: point.z + z
+		};
+		points.set(`${item.x}:${item.y}:${item.z}`, item);
+	});
+	return [...points.values()];
+}
+function projectedLatticePoint(point, repetitions) {
+	const scale = 150 / Math.max(1, repetitions);
+	return {
+		x: 210 + (point.x - point.z) * scale * .72,
+		y: 220 - point.y * scale + (point.x + point.z) * scale * .34,
+		depth: point.x + point.y + point.z
+	};
+}
+
+//#endregion
+export { LATTICE_FACTS, latticePoints, projectedLatticePoint };

package/dist/chem/crystal-lattice/index.d.mts

@@ -0,0 +1,3 @@
+import { CrystalLatticeKind, LATTICE_FACTS, LatticeFacts, LatticePoint, latticePoints } from "./core.mjs";
+import { CrystalLatticeLab, CrystalLatticeProjectedScene, CrystalLatticeProps, CrystalLatticeSceneProps, CrystalLatticeSceneRenderer } from "./preset.mjs";
+import { crystalLatticeActivity } from "./activity.mjs";

package/dist/chem/crystal-lattice/preset.d.mts

@@ -0,0 +1,44 @@
+import { AuthoredActivity } from "../../kit/activity-authoring.mjs";
+import { CrystalLatticeKind } from "./core.mjs";
+import { ComponentType, ReactNode } from "react";
+
+//#region src/chem/crystal-lattice/preset.d.ts
+interface CrystalLatticeSceneProps {
+  kind: CrystalLatticeKind;
+  repetitions: number;
+  showPlane: boolean;
+  yaw: number;
+  pitch: number;
+}
+type CrystalLatticeSceneRenderer = ComponentType<CrystalLatticeSceneProps>;
+interface CrystalLatticeProps {
+  lattice?: CrystalLatticeKind;
+  repetitions?: number;
+  showPlane?: boolean;
+  yaw?: number;
+  pitch?: number;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  activity?: AuthoredActivity;
+  sceneRenderer?: CrystalLatticeSceneRenderer;
+}
+declare function CrystalLatticeProjectedScene({
+  kind,
+  repetitions,
+  showPlane
+}: CrystalLatticeSceneProps): ReactNode;
+declare function CrystalLatticeLab({
+  lattice: initial,
+  repetitions: initialRepetitions,
+  showPlane: initialPlane,
+  yaw: initialYaw,
+  pitch: initialPitch,
+  title,
+  prompt,
+  objectives,
+  activity,
+  sceneRenderer: SceneRenderer
+}?: CrystalLatticeProps): ReactNode;
+//#endregion
+export { CrystalLatticeLab, CrystalLatticeProjectedScene, CrystalLatticeProps, CrystalLatticeSceneProps, CrystalLatticeSceneRenderer };

package/dist/chem/crystal-lattice/preset.mjs

@@ -0,0 +1,244 @@
+'use client';
+
+import { Chip, Segmented, Slider } from "../../kit/controls.mjs";
+import { Field, Readout, SceneViewport } from "../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../kit/authored-activity-runtime.mjs";
+import { crystalLatticeActivity } from "./activity.mjs";
+import { LATTICE_FACTS, latticePoints, projectedLatticePoint } from "./core.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/chem/crystal-lattice/preset.tsx
+const KINDS = Object.keys(LATTICE_FACTS);
+function CrystalLatticeProjectedScene({ kind, repetitions, showPlane }) {
+	const points = useMemo(() => latticePoints(kind, repetitions).map((point) => ({
+		point,
+		projected: projectedLatticePoint(point, repetitions)
+	})).sort((a, b) => a.projected.depth - b.projected.depth), [kind, repetitions]);
+	const n = repetitions;
+	const p = [
+		{
+			x: 0,
+			y: 0,
+			z: 0,
+			site: "corner"
+		},
+		{
+			x: n,
+			y: 0,
+			z: 0,
+			site: "corner"
+		},
+		{
+			x: n,
+			y: n,
+			z: 0,
+			site: "corner"
+		},
+		{
+			x: 0,
+			y: n,
+			z: 0,
+			site: "corner"
+		},
+		{
+			x: 0,
+			y: 0,
+			z: n,
+			site: "corner"
+		},
+		{
+			x: n,
+			y: 0,
+			z: n,
+			site: "corner"
+		},
+		{
+			x: n,
+			y: n,
+			z: n,
+			site: "corner"
+		},
+		{
+			x: 0,
+			y: n,
+			z: n,
+			site: "corner"
+		}
+	].map((point) => projectedLatticePoint(point, repetitions));
+	return /* @__PURE__ */ jsxs("svg", {
+		viewBox: "0 0 420 360",
+		width: "100%",
+		role: "img",
+		"aria-label": `${LATTICE_FACTS[kind].label}, ${repetitions} cells in each direction`,
+		children: [
+			showPlane && /* @__PURE__ */ jsx("polygon", {
+				points: [
+					p[3],
+					p[2],
+					p[5],
+					p[4]
+				].map((point) => `${point.x},${point.y}`).join(" "),
+				fill: "var(--stage-accent)",
+				opacity: ".12",
+				stroke: "var(--stage-accent)",
+				strokeDasharray: "5 5"
+			}),
+			[
+				[0, 1],
+				[1, 2],
+				[2, 3],
+				[3, 0],
+				[4, 5],
+				[5, 6],
+				[6, 7],
+				[7, 4],
+				[0, 4],
+				[1, 5],
+				[2, 6],
+				[3, 7]
+			].map(([a, b], index) => /* @__PURE__ */ jsx("line", {
+				x1: p[a].x,
+				y1: p[a].y,
+				x2: p[b].x,
+				y2: p[b].y,
+				stroke: "var(--stage-grid)",
+				strokeWidth: "1.5"
+			}, index)),
+			points.map(({ point, projected }, index) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("circle", {
+				cx: projected.x,
+				cy: projected.y,
+				r: point.site === "corner" ? 8 : 10,
+				fill: point.site === "body" ? "var(--stage-warn)" : point.site === "face" ? "var(--stage-accent-2)" : "var(--stage-accent)",
+				opacity: ".9"
+			}), /* @__PURE__ */ jsx("circle", {
+				cx: projected.x - 2,
+				cy: projected.y - 2,
+				r: "2",
+				fill: "white",
+				opacity: ".75"
+			})] }, index))
+		]
+	});
+}
+function CrystalLatticeLab({ lattice: initial = "face-centred", repetitions: initialRepetitions = 1, showPlane: initialPlane = false, yaw: initialYaw = 32, pitch: initialPitch = -18, title = "Crystal lattices: one cell becomes a solid", prompt = "Repeat a unit cell, reveal a crystallographic plane, and connect shared atom positions to coordination and packing.", objectives, activity, sceneRenderer: SceneRenderer } = {}) {
+	const [kind, setKind] = useState(initial), [repetitions, setRepetitions] = useState(Math.max(1, Math.min(3, initialRepetitions))), [showPlane, setShowPlane] = useState(initialPlane), [yaw, setYaw] = useState(initialYaw), [pitch, setPitch] = useState(initialPitch);
+	const facts = LATTICE_FACTS[kind], sceneProps = {
+		kind,
+		repetitions,
+		showPlane,
+		yaw,
+		pitch
+	};
+	const runtimeActivity = activity ?? (objectives ? {
+		...crystalLatticeActivity.source,
+		objectives
+	} : crystalLatticeActivity);
+	const evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Readout, {
+			value: `${facts.atomsPerCell} atom${facts.atomsPerCell === 1 ? "" : "s"} per cell`,
+			sub: `${facts.coordination} nearest neighbours`
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			className: "lab-metric-list",
+			children: [
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "coordination number" }), /* @__PURE__ */ jsx("strong", { children: facts.coordination })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "packing efficiency" }), /* @__PURE__ */ jsxs("strong", { children: [(facts.packingEfficiency * 100).toFixed(1), "%"] })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "displayed lattice sites" }), /* @__PURE__ */ jsx("strong", { children: latticePoints(kind, repetitions).length })] })
+			]
+		}),
+		/* @__PURE__ */ jsx("p", { children: "Corner and face atoms are shared with adjacent cells. Count their fractions, not every complete sphere visible in the drawing." })
+	] });
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Field, {
+			label: "unit cell",
+			children: /* @__PURE__ */ jsx(Segmented, {
+				ariaLabel: "unit cell",
+				value: kind,
+				onChange: setKind,
+				options: KINDS.map((item) => ({
+					value: item,
+					label: item === "simple-cubic" ? "SC" : item === "body-centred" ? "BCC" : "FCC"
+				}))
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "repeat cells",
+			value: `${repetitions} × ${repetitions} × ${repetitions}`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: repetitions,
+				min: 1,
+				max: 3,
+				step: 1,
+				onChange: setRepetitions,
+				ariaLabel: "unit cell repetitions"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "rotate horizontally",
+			value: `${yaw}°`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: yaw,
+				min: -180,
+				max: 180,
+				step: 2,
+				onChange: setYaw,
+				ariaLabel: "horizontal lattice rotation"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "tilt",
+			value: `${pitch}°`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: pitch,
+				min: -70,
+				max: 70,
+				step: 2,
+				onChange: setPitch,
+				ariaLabel: "vertical lattice tilt"
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "structure layers",
+			children: /* @__PURE__ */ jsx(Chip, {
+				selected: showPlane,
+				onClick: () => setShowPlane(!showPlane),
+				children: "show (110) plane"
+			})
+		})
+	] });
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		activity: runtimeActivity,
+		activityId: "crystal-lattice",
+		focusLayout: "immersive",
+		eyebrow: "Solid-state chemistry",
+		title,
+		description: prompt,
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
+			/* @__PURE__ */ jsx("span", { children: facts.label }),
+			/* @__PURE__ */ jsxs("span", { children: [facts.coordination, " neighbours"] }),
+			/* @__PURE__ */ jsxs("span", { children: [(facts.packingEfficiency * 100).toFixed(0), "% packed"] })
+		] }),
+		evidence,
+		controls,
+		observation: `${facts.label} has ${facts.atomsPerCell} atoms per unit cell, coordination number ${facts.coordination}, and ${(facts.packingEfficiency * 100).toFixed(1)}% packing efficiency.`,
+		transcript: /* @__PURE__ */ jsxs("p", { children: [
+			facts.label,
+			". Each atom has ",
+			facts.coordination,
+			" nearest neighbours. Shared lattice sites contribute ",
+			facts.atomsPerCell,
+			" atoms per unit cell, giving",
+			" ",
+			(facts.packingEfficiency * 100).toFixed(1),
+			" percent packing efficiency."
+		] }),
+		children: /* @__PURE__ */ jsx(SceneViewport, {
+			label: `${facts.label} crystal lattice model`,
+			children: SceneRenderer ? /* @__PURE__ */ jsx(SceneRenderer, { ...sceneProps }) : /* @__PURE__ */ jsx(CrystalLatticeProjectedScene, { ...sceneProps })
+		})
+	});
+}
+
+//#endregion
+export { CrystalLatticeLab, CrystalLatticeProjectedScene };