@classytic/labs 0.4.0 → 0.6.0

package/dist/domains/chem/chromatography-plate/model.mjs

@@ -1,180 +0,0 @@
-import { resolvedBy, spotDistance, unresolvedPairs } from "@classytic/stage/chem";
-
-//#region src/domains/chem/chromatography-plate/model.ts
-/**
-* Run a plate, measure the spots, and find out that one solvent is not enough.
-*
-* ## Why the lab exists rather than a worked Rf
-*
-* The arithmetic of a retention factor is one division, and a lesson can do that. What a lesson
-* cannot do is put a learner in the position of having run a plate, measured two spots, and found
-* that the measurement does not name them. That failure is the entire reason a second solvent
-* exists, and a learner told to "run two solvents" without meeting it has been given a ritual.
-*
-* So the first solvent here is chosen so that two of the four amino acids land on top of each other.
-* The learner measures, identifies two of them, gets stuck on the third, and has to work out what to
-* do. `resolvedBy` in the kernel then confirms which solvent breaks the tie.
-*
-* ## Why the setup question comes first
-*
-* Putting the baseline below the solvent level is the one mistake that destroys the experiment
-* rather than degrading it: the spots dissolve off into the tank and nothing runs at all. It is
-* asked before anything else because it is a decision made before anything else, and because a
-* learner who has predicted the failure remembers the rule.
-*
-* ## Where the numbers come from
-*
-* `@classytic/stage/chem` owns the retention factor, the spot positions and the identification,
-* including whether a match is unique. This file declares which substances are on the plate and
-* what each case is for.
-*
-* The Rf values are TEACHING values, chosen from published ranges for these amino acids in these
-* two solvent systems. A real Rf shifts with temperature, tank saturation and how the plate was
-* spotted, which is exactly why the lab quotes a tolerance rather than exact equality.
-*/
-const SOLVENTS = [{
-	id: "phenol",
-	name: "phenol and water",
-	short: "phenol"
-}, {
-	id: "butanol",
-	name: "butan-1-ol, ethanoic acid and water",
-	short: "butanol"
-}];
-/**
-* The four amino acids, with a retention factor in each solvent.
-*
-* Valine and leucine are 0.02 apart in phenol, which is inside the tolerance a real plate can
-* distinguish, and 0.13 apart in butanol. That pair is the lab's argument.
-*/
-const AMINO_ACIDS = [
-	{
-		id: "glycine",
-		name: "glycine",
-		rf: {
-			phenol: .42,
-			butanol: .26
-		}
-	},
-	{
-		id: "alanine",
-		name: "alanine",
-		rf: {
-			phenol: .59,
-			butanol: .38
-		}
-	},
-	{
-		id: "valine",
-		name: "valine",
-		rf: {
-			phenol: .8,
-			butanol: .6
-		}
-	},
-	{
-		id: "leucine",
-		name: "leucine",
-		rf: {
-			phenol: .82,
-			butanol: .73
-		}
-	}
-];
-const componentById = (id) => AMINO_ACIDS.find((c) => c.id === id);
-const PLATE_CASES = [{
-	id: "hydrolysate",
-	title: "Three amino acids from a hydrolysed protein",
-	mixture: [
-		"glycine",
-		"valine",
-		"leucine"
-	],
-	startSolvent: "phenol",
-	teaches: "two of the three stop in the same place in phenol. One solvent cannot name them, and a second one can."
-}, {
-	id: "pair",
-	title: "Two that separate cleanly",
-	mixture: ["glycine", "alanine"],
-	startSolvent: "phenol",
-	teaches: "a clean plate, where every spot matches one reference and the identification is done."
-}];
-const caseById = (id) => PLATE_CASES.find((c) => c.id === id);
-/** How far the solvent front has run, in cm. Fixed, because the plate is a fixed size. */
-const FRONT_CM = 8;
-const createPlateState = (caseId = PLATE_CASES[0].id) => {
-	return {
-		caseId,
-		solvent: (caseById(caseId) ?? PLATE_CASES[0]).startSolvent,
-		run: false,
-		named: [],
-		used: []
-	};
-};
-const currentCase = (state) => caseById(state.caseId) ?? PLATE_CASES[0];
-/** The components actually on the plate. */
-const mixtureOf = (entry) => entry.mixture.map((id) => componentById(id)).filter(Boolean);
-function spotsFor(state) {
-	const entry = currentCase(state);
-	return mixtureOf(entry).map((component) => ({
-		component,
-		rf: component.rf[state.solvent],
-		cm: spotDistance(component, state.solvent, 8)
-	})).sort((a, b) => b.cm - a.cm);
-}
-/**
-* Pairs the current solvent cannot separate.
-*
-* The lab's whole argument when it is not empty, and the reason the learner has to reach for a
-* second solvent rather than being told to.
-*/
-const stuckPairs = (state) => unresolvedPairs(mixtureOf(currentCase(state)), state.solvent);
-/** A solvent that tells a stuck pair apart, if the lab has one. */
-const solventThatResolves = (state) => {
-	const stuck = stuckPairs(state)[0];
-	if (!stuck) return void 0;
-	return resolvedBy(stuck[0], stuck[1], SOLVENTS.map((s) => s.id).filter((s) => s !== state.solvent));
-};
-/** Every component in the mixture has been named. */
-const allNamed = (state) => currentCase(state).mixture.every((id) => state.named.includes(id));
-/**
-* Changing the solvent un-runs the plate, because it is a new plate.
-*
-* Not a nicety. A learner who could switch solvent and keep the old spots would be looking at two
-* measurements that never coexisted, and the point of the second solvent is that it is a second
-* experiment.
-*/
-function transitionPlate(state, action) {
-	switch (action.type) {
-		case "SELECT": {
-			const entry = caseById(action.caseId);
-			return entry ? createPlateState(entry.id) : state;
-		}
-		case "SOLVENT":
-			if (!SOLVENTS.some((s) => s.id === action.solvent) || action.solvent === state.solvent) return state;
-			return {
-				...state,
-				solvent: action.solvent,
-				run: false
-			};
-		case "RUN":
-			if (state.run) return state;
-			return {
-				...state,
-				run: true,
-				used: [.../* @__PURE__ */ new Set([...state.used, state.solvent])]
-			};
-		case "NAME":
-			if (!state.run) return state;
-			if (!currentCase(state).mixture.includes(action.componentId)) return state;
-			if (state.named.includes(action.componentId)) return state;
-			return {
-				...state,
-				named: [...state.named, action.componentId]
-			};
-		default: return state;
-	}
-}
-
-//#endregion
-export { AMINO_ACIDS, PLATE_CASES, SOLVENTS, allNamed, caseById, componentById, createPlateState, currentCase, mixtureOf, solventThatResolves, spotsFor, stuckPairs, transitionPlate };

package/dist/domains/chem/chromatography-plate/runtime.mjs

@@ -1,200 +0,0 @@
-'use client';
-
-import { AssessedChoiceGroup } from "../../../kit/controls.mjs";
-import { LiveRegion, Readout } from "../../../kit/frame.mjs";
-import { AuthoredActivityRuntime } from "../../../kit/authored-activity-runtime.mjs";
-import { HazardChip, SafetyNote } from "../../../kit/chemistry/safety.mjs";
-import { activity } from "./activity.mjs";
-import { AMINO_ACIDS, PLATE_CASES, SOLVENTS, allNamed, createPlateState, currentCase, solventThatResolves, spotsFor, stuckPairs, transitionPlate } from "./model.mjs";
-import { ChromatographyPlateScene } from "./scene.mjs";
-import { useState } from "react";
-import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
-
-//#region src/domains/chem/chromatography-plate/runtime.tsx
-/**
-* The reagents behind the plate.
-*
-* Phenol is the one that matters and it is why this experiment is a fume-cupboard job: it burns
-* skin badly and the burn is painless at first, which is exactly the property that makes people
-* careless with it.
-*/
-const REAGENTS_USED = ["phenol"];
-/**
-* The learner runs the plate, measures, and then hits the wall the lab is built around.
-*
-* Two spots at the same Rf is not a failure of the learner or of the plate. It is what a single
-* solvent can do, and the step that follows offers the three things somebody might try, only one of
-* which is chromatography rather than wishful thinking.
-*/
-function ChromatographyPlate({ title = "Run the plate, then name the spots", prompt = "Four references, one unknown mixture, and one solvent that is not enough." } = {}) {
-	const [state, setState] = useState(createPlateState);
-	const [hint, setHint] = useState();
-	const entry = currentCase(state);
-	const spots = spotsFor(state);
-	const stuck = stuckPairs(state);
-	const resolver = solventThatResolves(state);
-	const solvent = SOLVENTS.find((s) => s.id === state.solvent);
-	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
-		activity,
-		activityId: "chromatography-plate",
-		eyebrow: "Analytical techniques",
-		title,
-		description: prompt,
-		presentation: "investigation",
-		focusLayout: "immersive",
-		transcriptMode: "sr-only",
-		status: /* @__PURE__ */ jsxs(Fragment$1, { children: [
-			/* @__PURE__ */ jsx(HazardChip, { reagents: REAGENTS_USED }),
-			/* @__PURE__ */ jsx("span", { children: solvent.short }),
-			/* @__PURE__ */ jsx("span", { children: `${state.named.length}/${entry.mixture.length} named` })
-		] }),
-		support: /* @__PURE__ */ jsx(SafetyNote, { reagents: REAGENTS_USED }),
-		controls: ({ sequence, complete }) => {
-			const id = sequence.current.id;
-			if (id === "setup") return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
-				ariaLabel: "Where should the pencil baseline go?",
-				options: [
-					{
-						value: "above",
-						label: "above the solvent level"
-					},
-					{
-						value: "below",
-						label: "below the solvent level"
-					},
-					{
-						value: "at",
-						label: "exactly at the solvent level"
-					}
-				],
-				onChange: (choice) => {
-					if (choice !== "above") {
-						setHint("Below the solvent the spots dissolve straight off the plate into the tank, and nothing runs at all. The baseline has to stay dry until the solvent climbs to it.");
-						return;
-					}
-					setHint("Above it, so the solvent reaches the spots by climbing the plate.");
-					complete("setup", "above the solvent");
-				}
-			});
-			if (id === "run") return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
-				ariaLabel: "Run the plate",
-				options: [{
-					value: "run",
-					label: `run it in ${solvent.short}`
-				}, ...SOLVENTS.filter((s) => s.id !== state.solvent).map((s) => ({
-					value: s.id,
-					label: `change the solvent to ${s.short}`
-				}))],
-				onChange: (choice) => {
-					if (choice === "run") {
-						const next = transitionPlate(state, { type: "RUN" });
-						setState(next);
-						setHint(`The front has run ${8} cm. Measure each spot from the pencil line to its centre.`);
-						complete("run", state.solvent);
-						return;
-					}
-					setState(transitionPlate(state, {
-						type: "SOLVENT",
-						solvent: choice
-					}));
-					setHint("A different solvent is a different plate, so it has to be run again.");
-				}
-			});
-			if (id === "identify") return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
-				ariaLabel: "Which reference does a spot line up with?",
-				options: AMINO_ACIDS.map((c) => ({
-					value: c.id,
-					label: c.name
-				})),
-				onChange: (choice) => {
-					if (!entry.mixture.includes(choice)) {
-						const missing = AMINO_ACIDS.find((c) => c.id === choice);
-						setHint(`Nothing in the mixture lane sits level with the ${missing.name} reference at Rf ${missing.rf[state.solvent]}, so the unknown does not contain it.`);
-						return;
-					}
-					if (state.named.includes(choice)) {
-						setHint("That one is already named. Look for a mark you have not matched yet.");
-						return;
-					}
-					if (stuck.some(([a, b]) => a.id === choice || b.id === choice)) {
-						const pair = stuck[0];
-						setHint(`You cannot name that one yet. ${pair[0].name} and ${pair[1].name} both stop at Rf ${pair[0].rf[state.solvent]} in ${solvent.short}, so this plate cannot tell them apart.`);
-						return;
-					}
-					const next = transitionPlate(state, {
-						type: "NAME",
-						componentId: choice
-					});
-					setState(next);
-					setHint(`Named. Its spot lines up with the ${choice} reference.`);
-					const namedCount = next.named.length;
-					if (namedCount >= entry.mixture.length - stuck.length * 2) complete("identify", `${namedCount} named`);
-				}
-			});
-			if (id === "stuck") {
-				if (!stuck.length) return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
-					ariaLabel: "Nothing is stuck on this plate",
-					options: PLATE_CASES.filter((c) => c.id !== state.caseId).map((c) => ({
-						value: c.id,
-						label: c.title
-					})),
-					onChange: (caseId) => {
-						setState(transitionPlate(state, {
-							type: "SELECT",
-							caseId
-						}));
-						setHint(void 0);
-					}
-				});
-				return /* @__PURE__ */ jsx(AssessedChoiceGroup, {
-					ariaLabel: "Two spots stopped together. What do you do?",
-					options: [
-						{
-							value: "solvent",
-							label: "run a fresh plate in a different solvent"
-						},
-						{
-							value: "longer",
-							label: "leave the same plate running for longer"
-						},
-						{
-							value: "nearest",
-							label: "report whichever reference is nearest"
-						}
-					],
-					onChange: (choice) => {
-						if (choice === "longer") {
-							setHint("Running longer moves the spots AND the front, so every Rf is unchanged. Two spots at the same Rf stay at the same Rf however long you wait.");
-							return;
-						}
-						if (choice === "nearest") {
-							setHint("That turns a failed measurement into a confident wrong answer. If two references are within the uncertainty of the plate, the plate has not identified anything.");
-							return;
-						}
-						if (resolver) {
-							const next = transitionPlate(state, {
-								type: "SOLVENT",
-								solvent: resolver
-							});
-							setState(transitionPlate(next, { type: "RUN" }));
-							const names = stuck[0];
-							setHint(`In ${SOLVENTS.find((s) => s.id === resolver).short} they are ${names[0].rf[resolver]} and ${names[1].rf[resolver]}, which is far enough apart to read.`);
-							complete("stuck", resolver);
-						}
-					}
-				});
-			}
-			return null;
-		},
-		evidence: /* @__PURE__ */ jsx(Readout, {
-			value: hint ?? `${entry.title}: ${entry.teaches}`,
-			sub: state.run ? `front at ${8} cm, ${spots.length} components` : "not run yet"
-		}),
-		observation: allNamed(state) ? "An Rf is a ratio, so leaving the plate longer moves the spot and the front together and changes nothing. Two components at the same Rf are separated by changing the solvent, because the competition between the phases depends on the solvent as much as on the substance." : void 0,
-		transcript: /* @__PURE__ */ jsx(LiveRegion, { children: `Plate in ${solvent.name}. ${state.run ? spots.map((s) => `${s.component.name} at ${s.cm.toFixed(1)} cm, Rf ${s.rf}`).join(". ") : "Not run."} Named so far: ${state.named.join(", ") || "none"}.` }),
-		children: /* @__PURE__ */ jsx(ChromatographyPlateScene, { state })
-	});
-}
-
-//#endregion
-export { ChromatographyPlate as default };

package/dist/domains/chem/chromatography-plate/scene.mjs

@@ -1,292 +0,0 @@
-import { Figure, HUE, STROKE, alpha, tint } from "../../../kit/figure/figure.mjs";
-import { FigText } from "../../../kit/figure/text.mjs";
-import { AMINO_ACIDS, SOLVENTS, currentCase, mixtureOf, spotsFor, stuckPairs } from "./model.mjs";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-
-//#region src/domains/chem/chromatography-plate/scene.tsx
-/**
-* The plate, drawn to the measurements the kernel computes.
-*
-* ## Why the reference lanes are beside the mixture and not in a key
-*
-* Identification by chromatography IS the comparison of one lane against another. A key listing Rf
-* values would let a learner do the arithmetic and never look at the plate, which is the opposite of
-* the skill: you read a plate by putting a ruler across it and seeing which reference the unknown
-* lines up with.
-*
-* ## Why there is an Rf axis
-*
-* Because Rf is the only quantity the experiment produces, and without a scale the plate is a grey
-* rectangle with a `0` written beside it. The axis is in Rf rather than centimetres deliberately:
-* the distance a spot travels is not a property of the substance, and the ratio is. Quoting the
-* front in centimetres once, at the top, is enough to say where the ratio came from.
-*
-* The gridlines are drawn very faint. They are a ruler, not data, and the spots have to stay the
-* thing the eye lands on.
-*
-* ## Why every lane is spotted before the run
-*
-* Only the mixture used to be. A plate waiting to run therefore showed four labelled lanes with
-* nothing in them, which reads as a broken figure and, worse, teaches the wrong procedure: the
-* references are spotted at the same time as the unknown, and that is the whole reason they are
-* references, since they then climb the same plate in the same solvent for the same time.
-*
-* ## Why the solvent level is drawn
-*
-* Because the one mistake that destroys the experiment is putting the pencil line below it, and a
-* figure that omitted the solvent could not show why. The line is drawn under the baseline for the
-* whole of the run, so the relationship is visible rather than asserted.
-*
-* ## What the figure must make obvious when two spots collide
-*
-* That they are ONE mark, not two. Drawing them as two touching circles would let a learner count
-* two spots and conclude the plate had separated them. Overlapping spots are merged into a single
-* wider mark, because that is what the plate shows and what the problem is.
-*/
-const W = 440;
-const H = 352;
-/** The plate rectangle, in figure units. The right-hand gutter carries the Rf axis. */
-const PLATE = {
-	x: 40,
-	y: 40,
-	w: 300,
-	h: 244
-};
-/** Distance from the bottom of the plate to the pencil baseline. */
-const BASELINE = PLATE.y + PLATE.h - 30;
-/** Where the solvent front stops. */
-const FRONT_Y = PLATE.y + 28;
-/** Rf is the figure's vertical coordinate: 0 at the pencil line, 1 at the front. */
-const rfToY = (rf) => BASELINE - rf * (BASELINE - FRONT_Y);
-const AXIS_X = PLATE.x + PLATE.w + 8;
-const GRID = [
-	.2,
-	.4,
-	.6,
-	.8
-];
-/**
-* A spot, drawn as a blob rather than a disc.
-*
-* A developed spot is diffuse: it has a dense middle and a soft edge, because the substance spread
-* as it climbed. A flat ellipse of one colour looks like a sticker, and four stickers in a row look
-* like a diagram of a plate rather than a plate.
-*/
-function Spot({ cx, cy, rx, colour, emphasis = 1 }) {
-	return /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("ellipse", {
-		cx,
-		cy,
-		rx: rx + 3,
-		ry: rx * .72 + 2,
-		fill: alpha(colour, 18 * emphasis)
-	}), /* @__PURE__ */ jsx("ellipse", {
-		cx,
-		cy,
-		rx,
-		ry: rx * .68,
-		fill: alpha(colour, 55 * emphasis),
-		stroke: alpha(HUE.ink, 26),
-		strokeWidth: STROKE.hair
-	})] });
-}
-function ChromatographyPlateScene({ state }) {
-	const entry = currentCase(state);
-	const solvent = SOLVENTS.find((s) => s.id === state.solvent);
-	const spots = spotsFor(state);
-	const stuck = stuckPairs(state);
-	const stuckIds = new Set(stuck.flatMap(([a, b]) => [a.id, b.id]));
-	/** Lanes: the unknown first, then one reference per amino acid. */
-	const lanes = [{
-		id: "unknown",
-		label: "mixture"
-	}, ...AMINO_ACIDS.map((a) => ({
-		id: a.id,
-		label: a.name.slice(0, 3)
-	}))];
-	const laneW = PLATE.w / (lanes.length + .5);
-	const laneX = (i) => PLATE.x + laneW * (i + .75);
-	const referenceRf = (id) => AMINO_ACIDS.find((a) => a.id === id).rf[state.solvent];
-	return /* @__PURE__ */ jsxs(Figure, {
-		viewBox: [W, H],
-		domain: "chem",
-		label: `A thin-layer plate run in ${solvent.name}. ${state.run ? `${spots.length} components in the mixture: ${spots.map((s) => `${s.component.name} at Rf ${s.rf}`).join(", ")}.${stuck.length ? ` ${stuck[0][0].name} and ${stuck[0][1].name} stop in the same place, so this solvent cannot tell them apart.` : ""}` : "The plate has not been run yet, so every lane carries a spot on the pencil baseline."}`,
-		children: [
-			/* @__PURE__ */ jsx(FigText, {
-				x: PLATE.x,
-				y: 24,
-				size: "label",
-				tone: "soft",
-				children: `run in ${solvent.name}`
-			}),
-			/* @__PURE__ */ jsx("rect", {
-				x: PLATE.x,
-				y: PLATE.y,
-				width: PLATE.w,
-				height: PLATE.h,
-				fill: tint(HUE.solidWhite, 88),
-				stroke: alpha(HUE.ink, 35),
-				strokeWidth: STROKE.line,
-				rx: 2
-			}),
-			/* @__PURE__ */ jsx(FigText, {
-				x: AXIS_X,
-				y: PLATE.y + 2,
-				size: "eyebrow",
-				tone: "soft",
-				caps: false,
-				children: "Rf"
-			}),
-			GRID.map((rf) => /* @__PURE__ */ jsxs("g", { children: [/* @__PURE__ */ jsx("line", {
-				x1: PLATE.x,
-				y1: rfToY(rf),
-				x2: PLATE.x + PLATE.w,
-				y2: rfToY(rf),
-				stroke: alpha(HUE.ink, 9),
-				strokeWidth: STROKE.hair
-			}), /* @__PURE__ */ jsx(FigText, {
-				x: AXIS_X,
-				y: rfToY(rf) + 4,
-				size: "note",
-				tone: "soft",
-				caps: false,
-				children: `${rf}`
-			})] }, rf)),
-			/* @__PURE__ */ jsx("rect", {
-				x: PLATE.x,
-				y: BASELINE + 12,
-				width: PLATE.w,
-				height: PLATE.y + PLATE.h - (BASELINE + 12),
-				fill: alpha(HUE.cold, 22)
-			}),
-			/* @__PURE__ */ jsx(FigText, {
-				x: PLATE.x - 6,
-				y: PLATE.y + PLATE.h - 4,
-				size: "note",
-				tone: "soft",
-				anchor: "end",
-				children: "solvent"
-			}),
-			/* @__PURE__ */ jsx("line", {
-				x1: PLATE.x,
-				y1: BASELINE,
-				x2: PLATE.x + PLATE.w,
-				y2: BASELINE,
-				stroke: alpha(HUE.ink, 55),
-				strokeWidth: STROKE.hair,
-				strokeDasharray: "5 3"
-			}),
-			/* @__PURE__ */ jsx(FigText, {
-				x: AXIS_X,
-				y: BASELINE + 4,
-				size: "note",
-				tone: "soft",
-				caps: false,
-				children: "0"
-			}),
-			/* @__PURE__ */ jsx(FigText, {
-				x: PLATE.x - 6,
-				y: BASELINE + 4,
-				size: "note",
-				tone: "soft",
-				anchor: "end",
-				children: "pencil"
-			}),
-			state.run ? /* @__PURE__ */ jsxs(Fragment, { children: [
-				/* @__PURE__ */ jsx("line", {
-					x1: PLATE.x,
-					y1: FRONT_Y,
-					x2: PLATE.x + PLATE.w,
-					y2: FRONT_Y,
-					stroke: alpha(HUE.ink, 45),
-					strokeWidth: STROKE.hair
-				}),
-				/* @__PURE__ */ jsx(FigText, {
-					x: AXIS_X,
-					y: FRONT_Y + 4,
-					size: "note",
-					tone: "soft",
-					caps: false,
-					children: "1.0"
-				}),
-				/* @__PURE__ */ jsx(FigText, {
-					x: PLATE.x - 6,
-					y: FRONT_Y + 4,
-					size: "note",
-					tone: "soft",
-					anchor: "end",
-					caps: false,
-					children: "front"
-				}),
-				/* @__PURE__ */ jsx(FigText, {
-					x: PLATE.x - 6,
-					y: FRONT_Y + 16,
-					size: "note",
-					tone: "soft",
-					anchor: "end",
-					caps: false,
-					children: `${8 .toFixed(1)} cm`
-				})
-			] }) : null,
-			lanes.map((lane, i) => /* @__PURE__ */ jsx(FigText, {
-				x: laneX(i),
-				y: PLATE.y + PLATE.h + 18,
-				size: "note",
-				tone: lane.id === "unknown" ? "ink" : "soft",
-				anchor: "middle",
-				caps: false,
-				children: lane.label
-			}, lane.id)),
-			!state.run ? lanes.map((lane, i) => lane.id === "unknown" && mixtureOf(entry).length === 0 ? null : /* @__PURE__ */ jsx(Spot, {
-				cx: laneX(i),
-				cy: BASELINE,
-				rx: 7,
-				colour: lane.id === "unknown" ? HUE[2] : HUE[1],
-				emphasis: lane.id === "unknown" ? 1 : .7
-			}, `start-${lane.id}`)) : null,
-			state.run ? AMINO_ACIDS.map((acid, i) => /* @__PURE__ */ jsx(Spot, {
-				cx: laneX(i + 1),
-				cy: rfToY(acid.rf[state.solvent]),
-				rx: 9,
-				colour: HUE[1],
-				emphasis: .8
-			}, acid.id)) : null,
-			state.run ? state.named.map((id) => /* @__PURE__ */ jsx("line", {
-				x1: laneX(0) + 12,
-				y1: rfToY(referenceRf(id)),
-				x2: laneX(AMINO_ACIDS.findIndex((a) => a.id === id) + 1) - 12,
-				y2: rfToY(referenceRf(id)),
-				stroke: alpha(HUE.good, 70),
-				strokeWidth: STROKE.hair,
-				strokeDasharray: "3 3"
-			}, `match-${id}`)) : null,
-			state.run ? spots.filter((spot, i) => i === 0 || Math.abs(spots[i - 1].rf - spot.rf) > .03).map((spot) => {
-				const merged = stuckIds.has(spot.component.id);
-				return /* @__PURE__ */ jsx(Spot, {
-					cx: laneX(0),
-					cy: rfToY(spot.rf),
-					rx: merged ? 15 : 9,
-					colour: merged ? HUE.warn : HUE[2],
-					emphasis: merged ? 1.3 : 1
-				}, spot.component.id);
-			}) : null,
-			state.run ? /* @__PURE__ */ jsx(FigText, {
-				x: PLATE.x,
-				y: PLATE.y + PLATE.h + 42,
-				size: "label",
-				tone: stuck.length ? "warn" : "soft",
-				caps: false,
-				children: stuck.length ? `two components stopped together at Rf ${stuck[0][0].rf[state.solvent]}` : `${spots.length} spots, all separated`
-			}) : /* @__PURE__ */ jsx(FigText, {
-				x: PLATE.x,
-				y: PLATE.y + PLATE.h + 42,
-				size: "label",
-				tone: "soft",
-				caps: false,
-				children: "spotted on the baseline, ready to run"
-			})
-		]
-	});
-}
-
-//#endregion
-export { ChromatographyPlateScene };