@classytic/labs 0.3.0 → 0.4.0

package/dist/domains/chem/mechanism-walk/model.mjs

@@ -0,0 +1,429 @@
+import { formula, structure } from "../../../kit/chemistry/species.mjs";
+
+//#region src/domains/chem/mechanism-walk/model.ts
+const MECHANISMS = [
+	{
+		id: "electrophilic-addition",
+		name: "electrophilic addition",
+		title: "The pi bond attacks",
+		moves: "pairs",
+		condition: "room temperature, no catalyst needed",
+		question: {
+			prompt: "Bromine is a non-polar molecule. What makes it attack an alkene at all?",
+			choices: [
+				{
+					value: "induced",
+					label: "the alkene's pi electrons repel bromine's electrons, inducing a dipole"
+				},
+				{
+					value: "polar",
+					label: "bromine is already polar, so one end is permanently positive"
+				},
+				{
+					value: "heat",
+					label: "heat splits the bromine into radicals first"
+				}
+			],
+			answer: "induced",
+			wrong: {
+				polar: "Br–Br joins two identical atoms, so it has no permanent dipole. Something has to induce one, and the alkene is what does it.",
+				heat: "That is the radical route, and it needs ultraviolet light and an alkane. An alkene reacts in the dark at room temperature, so the mechanism cannot be that one."
+			}
+		},
+		steps: [{
+			id: "attack",
+			title: "The pi pair attacks the electrophile",
+			detail: "The exposed pi electrons repel electron density in Br–Br, inducing a dipole. The pi pair then attacks the δ+ bromine, and the Br–Br bond breaks heterolytically.",
+			species: [structure("ethene"), formula("Brᵟ⁺–Brᵟ⁻")],
+			arrows: [{
+				from: {
+					species: 0,
+					bond: [0, 1]
+				},
+				to: { species: 1 },
+				kind: "pair",
+				note: "The pi PAIR leaves the double bond and forms a bond to the δ+ bromine."
+			}],
+			forms: "a carbocation and a bromide ion"
+		}, {
+			id: "capture",
+			title: "The carbocation captures the bromide",
+			detail: "The pi pair has gone, so one carbon is left with only three bonds and a positive charge. The bromide ion still carries the pair it left with, and uses it to bond to that carbon.",
+			species: [structure("ethyl-carbocation"), formula("Br⁻")],
+			arrows: [{
+				from: { species: 1 },
+				to: {
+					species: 0,
+					vertex: 1
+				},
+				kind: "pair",
+				bow: -1,
+				note: "A lone PAIR on the bromide ion attacks the electron-deficient carbon."
+			}],
+			charges: [{
+				at: {
+					species: 0,
+					vertex: 1
+				},
+				mark: "+"
+			}, {
+				at: { species: 1 },
+				mark: "-"
+			}],
+			forms: "1,2-dibromoethane"
+		}],
+		rule: "An alkene reacts by electrophilic addition: the pi pair attacks an electrophile, leaving a carbocation, and a nucleophile then adds to that carbon. Both arrows move PAIRS, and the double bond becomes two single bonds with no small molecule lost.",
+		use: "It is the bromine-water test, and industrially it is how ethene becomes ethanol, in both cases by adding across the same double bond."
+	},
+	{
+		id: "free-radical-substitution",
+		name: "free-radical substitution",
+		title: "One electron at a time",
+		moves: "singles",
+		condition: "ultraviolet light",
+		question: {
+			prompt: "An alkane has no pi bond and no dipole. What has to happen before it reacts at all?",
+			choices: [
+				{
+					value: "homolytic",
+					label: "a bond must break evenly, giving each atom one electron"
+				},
+				{
+					value: "heterolytic",
+					label: "a bond must break unevenly, giving one atom both electrons"
+				},
+				{
+					value: "protonate",
+					label: "the alkane must be protonated by an acid first"
+				}
+			],
+			answer: "homolytic",
+			wrong: {
+				heterolytic: "That is how a polar mechanism starts, and it needs a dipole to decide which atom keeps the pair. Cl–Cl has no dipole, so there is nothing to make the split uneven.",
+				protonate: "An alkane has no lone pair and no pi bond, so there is nowhere for a proton to attach. It is the least reactive class of organic compound for exactly that reason."
+			}
+		},
+		steps: [
+			{
+				id: "initiation",
+				title: "Initiation: ultraviolet light splits the chlorine",
+				detail: "Ultraviolet light supplies enough energy to break Cl–Cl homolytically: the bonding pair splits, one electron to each atom, giving two chlorine radicals.",
+				species: [formula("Cl–Cl")],
+				arrows: [{
+					from: { species: 0 },
+					to: { species: 0 },
+					kind: "single",
+					note: "HOMOLYTIC fission: one electron of the pair goes to each atom, so the arrows are fishhooks."
+				}],
+				forms: "two chlorine radicals, Cl•"
+			},
+			{
+				id: "propagation",
+				title: "Propagation: the radical takes a hydrogen",
+				detail: "A chlorine radical removes a hydrogen atom from methane, forming HCl and leaving a methyl radical. That radical then attacks another Cl₂, making chloromethane and a new chlorine radical, so the chain continues.",
+				species: [structure("methane"), formula("Cl•")],
+				arrows: [{
+					from: {
+						species: 0,
+						vertex: 0,
+						sub: 3
+					},
+					to: { species: 1 },
+					kind: "single",
+					note: "A SINGLE electron moves, so one radical is consumed and another is made."
+				}],
+				forms: "HCl and a methyl radical"
+			},
+			{
+				id: "termination",
+				title: "Termination: two radicals meet",
+				detail: "Two radicals combine and the chain stops. Because any two radicals can meet, the products are a mixture, which is why this route is poor for making one pure compound.",
+				species: [structure("methyl-radical"), formula("Cl•")],
+				arrows: [{
+					from: {
+						species: 0,
+						vertex: 0
+					},
+					to: { species: 1 },
+					kind: "single",
+					note: "Two single electrons pair up into one bond, and no radical is left to continue."
+				}],
+				charges: [{
+					at: {
+						species: 0,
+						vertex: 0
+					},
+					mark: "•"
+				}],
+				forms: "chloromethane, plus a mixture of other products"
+			}
+		],
+		rule: "An alkane reacts by free-radical substitution, in three stages: initiation splits a bond homolytically under ultraviolet light, propagation makes a new radical each time so the chain continues, and termination pairs two radicals up. Every arrow moves ONE electron, drawn as a fishhook.",
+		use: "It is also how CFCs destroy ozone: one chlorine radical propagates through thousands of ozone molecules before it is terminated."
+	},
+	{
+		id: "nucleophilic-substitution",
+		name: "nucleophilic substitution",
+		title: "Something better takes the place",
+		moves: "pairs",
+		condition: "warm aqueous sodium hydroxide, heat under reflux",
+		question: {
+			prompt: "Why does a hydroxide ion attack the carbon of bromoethane rather than anywhere else?",
+			choices: [
+				{
+					value: "polar",
+					label: "the C–Br bond is polar, so that carbon carries a partial positive charge"
+				},
+				{
+					value: "weakest",
+					label: "the C–Br bond is the weakest, so it simply falls apart on its own"
+				},
+				{
+					value: "size",
+					label: "bromine is the largest atom, so there is most room to attack there"
+				}
+			],
+			answer: "polar",
+			wrong: {
+				weakest: "Bond strength decides how FAST the reaction goes, and the C–I bond being weakest is why iodoalkanes react quickest. It does not explain why the hydroxide aims at the carbon.",
+				size: "Attack happens where the charge is, not where the space is. A nucleophile is attracted to a positive centre."
+			}
+		},
+		steps: [{
+			id: "attack",
+			title: "The nucleophile attacks the δ+ carbon",
+			detail: "Bromine is more electronegative than carbon, so the C–Br bond is polar and that carbon is δ+. The hydroxide ion brings a lone pair to it, and the C–Br pair leaves with the bromine.",
+			species: [formula("OH⁻"), structure("bromoethane")],
+			arrows: [{
+				from: { species: 0 },
+				to: {
+					species: 1,
+					vertex: 1
+				},
+				kind: "pair",
+				note: "A lone PAIR on the hydroxide forms the new C–O bond, attacking the carbon that carries the bromine."
+			}, {
+				from: {
+					species: 1,
+					vertex: 1
+				},
+				to: {
+					species: 1,
+					vertex: 1,
+					sub: 2
+				},
+				kind: "pair",
+				bow: -1,
+				beyond: 22,
+				note: "At the same time the C–Br PAIR leaves entirely with the bromine, as a bromide ion."
+			}],
+			charges: [{
+				at: {
+					species: 1,
+					vertex: 1
+				},
+				mark: "δ+"
+			}, {
+				at: { species: 0 },
+				mark: "-"
+			}],
+			forms: "ethanol and a bromide ion"
+		}],
+		rule: "A halogenoalkane reacts by nucleophilic substitution: the halogen makes its carbon δ+, a nucleophile brings a lone pair to that carbon, and the halogen leaves with the bonding pair. Both arrows move PAIRS, and the halogen is what gets replaced.",
+		use: "It is the single most useful reaction in the AS course, because swapping the halogen for OH, CN or NH₂ is how one compound becomes a different class of compound."
+	},
+	{
+		id: "elimination",
+		name: "elimination",
+		title: "Same reagent, different conditions",
+		moves: "pairs",
+		condition: "hot ethanolic sodium hydroxide, heated under reflux",
+		question: {
+			prompt: "Warm aqueous hydroxide gives an alcohol. Hot ethanolic hydroxide gives an alkene. What is the hydroxide doing differently?",
+			choices: [
+				{
+					value: "base",
+					label: "acting as a base and removing a hydrogen, instead of attacking the carbon"
+				},
+				{
+					value: "stronger",
+					label: "the hot solution simply makes the same substitution go further"
+				},
+				{
+					value: "ethanol",
+					label: "the ethanol is the reactant, and the hydroxide takes no part"
+				}
+			],
+			answer: "base",
+			wrong: {
+				stronger: "The product is a different compound, not more of the same one. An alkene has fewer atoms than the alcohol, so a small molecule has left and that is a different reaction.",
+				ethanol: "Ethanol is the solvent. With no water present the hydroxide is a better base than a nucleophile, which is what changes, but it is still the hydroxide that reacts."
+			}
+		},
+		steps: [{
+			id: "eliminate",
+			title: "The hydroxide takes a hydrogen instead",
+			detail: "With no water to surround it, the hydroxide acts as a base. It removes a hydrogen from the carbon NEXT to the halogen. That C–H pair becomes the new carbon-carbon double bond, and the halide leaves with the C–Br pair.",
+			species: [formula("OH⁻"), structure("bromoethane")],
+			arrows: [
+				{
+					from: { species: 0 },
+					to: {
+						species: 1,
+						vertex: 0,
+						sub: 0
+					},
+					kind: "pair",
+					note: "The hydroxide takes a hydrogen from the carbon NEXT to the halogen, acting as a base."
+				},
+				{
+					from: {
+						species: 1,
+						vertex: 0,
+						sub: 0
+					},
+					to: {
+						species: 1,
+						bond: [0, 1]
+					},
+					kind: "pair",
+					bow: -1,
+					note: "The C–H PAIR left behind becomes the new carbon-carbon double bond."
+				},
+				{
+					from: {
+						species: 1,
+						vertex: 1
+					},
+					to: {
+						species: 1,
+						vertex: 1,
+						sub: 2
+					},
+					kind: "pair",
+					bow: -1,
+					beyond: 22,
+					note: "The C–Br PAIR leaves with the bromine, as it does in substitution."
+				}
+			],
+			forms: "ethene, water and a bromide ion"
+		}],
+		rule: "Hot ethanolic hydroxide eliminates rather than substitutes: it removes a hydrogen from the carbon next to the halogen, the C–H pair becomes a double bond, and the halide leaves. Same reagent, same substrate, different conditions, different product.",
+		use: "It is how an alkene is made from a halogenoalkane in the laboratory, and it is the reverse of the electrophilic addition that made the halogenoalkane in the first place."
+	},
+	{
+		id: "sn1",
+		name: "SN1 substitution",
+		title: "Two steps, not one",
+		moves: "pairs",
+		condition: "aqueous sodium hydroxide, warm",
+		question: {
+			prompt: "A tertiary halogenoalkane is hydrolysed faster than a primary one, even though its C–Br bond is no weaker. Why?",
+			choices: [
+				{
+					value: "carbocation",
+					label: "it forms a carbocation that the three alkyl groups stabilise"
+				},
+				{
+					value: "polar",
+					label: "its C–Br bond is more polar, so the carbon is more positive"
+				},
+				{
+					value: "small",
+					label: "the molecule is smaller, so the hydroxide reaches it sooner"
+				}
+			],
+			answer: "carbocation",
+			wrong: {
+				polar: "Polarity is set by the two atoms in the bond, and C–Br is C–Br in both. What differs is what is around that carbon.",
+				small: "A tertiary halogenoalkane is the LARGER molecule. Its carbon is crowded by three methyl groups, which is why a nucleophile cannot reach it from behind."
+			}
+		},
+		steps: [{
+			id: "ionise",
+			title: "Step one: the halide leaves on its own",
+			detail: "No nucleophile is involved yet. The C–Br bond breaks heterolytically and the bromide leaves with the pair, giving a carbocation. This step is slow, and it is the only step whose rate matters.",
+			species: [structure("tertiary-bromide")],
+			arrows: [{
+				from: {
+					species: 0,
+					vertex: 0
+				},
+				to: {
+					species: 0,
+					vertex: 0,
+					sub: 0
+				},
+				kind: "pair",
+				beyond: 22,
+				note: "The C–Br PAIR leaves with the bromine before any nucleophile arrives."
+			}],
+			charges: [{
+				at: {
+					species: 0,
+					vertex: 0
+				},
+				mark: "δ+"
+			}],
+			forms: "a tertiary carbocation and a bromide ion"
+		}, {
+			id: "capture",
+			title: "Step two: the hydroxide attacks the carbocation",
+			detail: "The carbocation has only three bonds and a full positive charge, so it is attacked from either side. This step is fast, which is why the overall rate does not depend on the hydroxide concentration.",
+			species: [formula("OH⁻"), structure("tertiary-carbocation")],
+			arrows: [{
+				from: { species: 0 },
+				to: {
+					species: 1,
+					vertex: 0
+				},
+				kind: "pair",
+				note: "A lone PAIR on the hydroxide bonds to the positive carbon, from either side."
+			}],
+			charges: [{
+				at: {
+					species: 1,
+					vertex: 0
+				},
+				mark: "+"
+			}, {
+				at: { species: 0 },
+				mark: "-"
+			}],
+			forms: "2-methylpropan-2-ol"
+		}],
+		rule: "A tertiary halogenoalkane substitutes by SN1: the halide leaves first, giving a carbocation that three alkyl groups stabilise, and the nucleophile attacks afterwards. A primary one substitutes by SN2 in a single step, because its carbon is reachable from behind and it would form an unstabilised carbocation.",
+		use: "The rate law is how the two are told apart in practice: an SN1 rate depends on the halogenoalkane alone, an SN2 rate on both reagents."
+	}
+];
+const mechanismCase = (id) => MECHANISMS.find((item) => item.id === id);
+const createMechanismState = (caseId) => ({
+	caseId,
+	committed: false,
+	step: 0
+});
+function transitionMechanism(state, event) {
+	if (event.type === "RESET") return createMechanismState(state.caseId);
+	const item = mechanismCase(state.caseId);
+	if (!item) return state;
+	if (event.type === "COMMIT") {
+		if (event.choice !== item.question.answer) return state;
+		return {
+			...state,
+			committed: true
+		};
+	}
+	if (!state.committed) return state;
+	if (event.type === "NEXT") return {
+		...state,
+		step: Math.min(state.step + 1, item.steps.length - 1)
+	};
+	return {
+		...state,
+		step: Math.max(state.step - 1, 0)
+	};
+}
+const currentStep = (state) => mechanismCase(state.caseId)?.steps[state.step];
+
+//#endregion
+export { MECHANISMS, createMechanismState, currentStep, mechanismCase, transitionMechanism };

package/dist/domains/chem/mechanism-walk/runtime.mjs

@@ -0,0 +1,76 @@
+'use client';
+
+import { AssessedChoiceGroup, CheckButton } from "../../../kit/controls.mjs";
+import { LiveRegion, Readout } from "../../../kit/frame.mjs";
+import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
+import { activity } from "./activity.mjs";
+import { MECHANISMS, createMechanismState, currentStep, mechanismCase, transitionMechanism } from "./model.mjs";
+import { MechanismWalkScene } from "./scene.mjs";
+import { useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/domains/chem/mechanism-walk/runtime.tsx
+function MechanismWalk({ title, prompt, mechanism = "electrophilic-addition" }) {
+	const item = mechanismCase(mechanism) ?? MECHANISMS[0];
+	const [state, setState] = useState(() => createMechanismState(item.id));
+	const [hint, setHint] = useState();
+	const step = currentStep(state);
+	const last = state.step === item.steps.length - 1;
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		activity,
+		activityId: `mechanism-walk-${item.id}`,
+		eyebrow: "Reaction mechanisms",
+		title: title ?? item.title,
+		description: prompt ?? item.question.prompt,
+		presentation: "investigation",
+		focusLayout: "immersive",
+		transcriptMode: "sr-only",
+		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx("span", { children: item.name }), /* @__PURE__ */ jsx("span", { children: state.committed ? `step ${state.step + 1} of ${item.steps.length}` : "no arrows yet" })] }),
+		controls: ({ sequence, complete }) => {
+			const id = sequence.current.id;
+			if (id === "start") return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
+				ariaLabel: item.question.prompt,
+				options: item.question.choices.map((choice) => ({
+					value: choice.value,
+					label: choice.label
+				})),
+				onChange: (choice) => {
+					const after = transitionMechanism(state, {
+						type: "COMMIT",
+						choice
+					});
+					if (after === state) {
+						setHint(item.question.wrong[choice] ?? "Not that. Look at what the reactants actually offer.");
+						return;
+					}
+					setHint(void 0);
+					setState(after);
+					complete("started", choice);
+				}
+			});
+			if (id === "walk") return /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(CheckButton, {
+				disabled: state.step === 0,
+				onClick: () => setState(transitionMechanism(state, { type: "BACK" })),
+				children: "Previous step"
+			}), /* @__PURE__ */ jsx(CheckButton, {
+				onClick: () => {
+					const after = transitionMechanism(state, { type: "NEXT" });
+					setState(after);
+					if (after.step === item.steps.length - 1) complete("walked", item.steps.at(-1).title);
+				},
+				children: last ? "Last step reached" : "Next step →"
+			})] });
+			return null;
+		},
+		evidence: /* @__PURE__ */ jsx(Readout, {
+			value: hint ?? (state.committed && step ? step.detail : item.condition),
+			sub: hint ? "not that" : state.committed && step ? step.forms ? `forms ${step.forms}` : step.title : "conditions"
+		}),
+		observation: state.committed && last ? `${item.rule} Every arrow here moves ${item.moves === "pairs" ? "a pair of electrons" : "a single electron"}. ${item.use}` : void 0,
+		transcript: /* @__PURE__ */ jsx(LiveRegion, { children: state.committed && step ? `${item.name}, step ${state.step + 1} of ${item.steps.length}. ${step.title}. ${step.detail}` : `${item.name}. Reactants shown without arrows. ${item.condition}.` }),
+		children: /* @__PURE__ */ jsx(MechanismWalkScene, { state })
+	});
+}
+
+//#endregion
+export { MechanismWalk as default };

package/dist/domains/chem/mechanism-walk/scene.mjs

@@ -0,0 +1,36 @@
+import { currentStep, mechanismCase } from "./model.mjs";
+import { MechanismFigure } from "../../../kit/chemistry/mechanism.mjs";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/domains/chem/mechanism-walk/scene.tsx
+/**
+* Before the question is answered: the reactants with NO arrows, and the one classification the
+* whole lab turns on left blank. After: the step, with its arrows.
+*
+* The arrows are the answer, so they are withheld. Showing them first turns "which mechanism is
+* this" into reading the diagram, which is the question the exam is trying not to ask.
+*/
+function MechanismWalkScene({ state }) {
+	const item = mechanismCase(state.caseId);
+	if (!item) return null;
+	const step = currentStep(state);
+	if (!state.committed || !step) {
+		const first = item.steps[0];
+		if (!first) return null;
+		return /* @__PURE__ */ jsx(MechanismFigure, {
+			step: {
+				...first,
+				arrows: [],
+				charges: []
+			},
+			label: `The reactants of ${item.name}, drawn before any electrons move. Conditions: ${item.condition}.`
+		});
+	}
+	return /* @__PURE__ */ jsx(MechanismFigure, {
+		step,
+		label: `${item.name}, step ${state.step + 1} of ${item.steps.length}: ${step.title}. ${step.detail}`
+	});
+}
+
+//#endregion
+export { MechanismWalkScene };

package/dist/domains/chem/mole-factory/activity.mjs

@@ -0,0 +1,55 @@
+import { defineAuthoredActivity } from "../../../kit/activity-authoring.mjs";
+
+//#region src/domains/chem/mole-factory/activity.ts
+/** Portable lesson sequence. Keep domain state and React rendering in runtime.tsx. */
+const activity = defineAuthoredActivity({
+	pattern: "construction",
+	title: "Mole Factory",
+	objectives: ["Use a balanced equation as a mole recipe and identify product and leftover reactant"],
+	success: [
+		{
+			id: "batch-1",
+			source: "metric",
+			key: "loaded-1"
+		},
+		{
+			id: "batch-2",
+			source: "metric",
+			key: "loaded-2"
+		},
+		{
+			id: "batch-3",
+			source: "metric",
+			key: "loaded-3"
+		}
+	],
+	steps: [
+		{
+			id: "batch-1",
+			phase: "act",
+			title: "Build one recipe",
+			lead: "Load the exact reacting ratio.",
+			controls: true,
+			success: "batch-1"
+		},
+		{
+			id: "batch-2",
+			phase: "act",
+			title: "Find what runs out",
+			lead: "Feed all stock and inspect what remains.",
+			controls: true,
+			success: "batch-2"
+		},
+		{
+			id: "batch-3",
+			phase: "act",
+			title: "Test the other excess",
+			lead: "Run a new stock mix through the same recipe.",
+			controls: true,
+			success: "batch-3"
+		}
+	]
+});
+
+//#endregion
+export { activity };

package/dist/domains/chem/mole-factory/manifest.mjs

@@ -0,0 +1,62 @@
+import { defineLab } from "../../../lab-def/define-lab.mjs";
+import { z } from "zod";
+
+//#region src/domains/chem/mole-factory/manifest.ts
+var manifest_default = defineLab({
+	id: "mole-factory",
+	domain: "chem",
+	group: "Chemistry",
+	title: "Mole Factory",
+	description: "Load one-mole batches into a reaction line; the balanced recipe turns them into product and leaves excess reactant visible.",
+	schema: z.object({
+		title: z.string().optional(),
+		prompt: z.string().optional(),
+		process: z.enum([
+			"ammonia",
+			"water",
+			"magnesium-oxide"
+		]).optional()
+	}),
+	taxonomy: {
+		grades: [
+			"9",
+			"10",
+			"11"
+		],
+		outcomes: [
+			"chemistry",
+			"mole-ratio",
+			"limiting-reagent",
+			"theoretical-yield"
+		],
+		durationMinutes: 8,
+		interaction: "guided",
+		authorability: "simple",
+		representation: "carrier",
+		levels: ["o-level", "as-level"],
+		qualityTier: "flagship",
+		primaryMechanic: "construction",
+		learnerAction: "feed one-mole batches into a reaction recipe and inspect product and leftover output",
+		evidenceTypes: ["model-state", "calculation"],
+		mobileMode: "construction",
+		misconceptions: ["equation coefficients are mass ratios", "the reactant with fewer raw moles must be limiting"]
+	},
+	experience: {
+		objectives: ["Use a balanced equation as a mole recipe and identify product and leftover reactant"],
+		phases: [
+			"act",
+			"observe",
+			"explain"
+		],
+		responses: [],
+		accessibility: {
+			keyboard: true,
+			textAlternative: true,
+			reducedMotion: true
+		}
+	},
+	loadRuntime: () => import("./runtime.mjs")
+});
+
+//#endregion
+export { manifest_default as default };

package/dist/domains/chem/mole-factory/runtime.mjs

@@ -0,0 +1,6 @@
+'use client';
+
+import { activity } from "./activity.mjs";
+import { MoleFactory } from "../../../chem/mole-factory.mjs";
+
+export { activity, MoleFactory as default };