@classytic/labs 0.3.0 → 0.4.0

package/dist/physics/modern/imaging/pet-core.mjs

@@ -0,0 +1,389 @@
+import { ELECTRONVOLT, ELECTRON_REST_ENERGY_MEV, HC_EV_NM, SPEED_OF_LIGHT } from "../../constants.mjs";
+import { decayConstant, remainingFraction } from "../../attenuation/core.mjs";
+
+//#region src/physics/modern/imaging/pet-core.ts
+/**
+* Positron emission tomography: the tracer, the annihilation, and the line of response.
+*
+* Cambridge 9702 topic 24.3, which the A2 medical-and-astronomy course promised in its summary, in
+* its coverage list and in an outcome ("describe electron-positron annihilation and 511 keV
+* collinear photon coincidence detection in PET") and then taught in none of its twelve lessons.
+* This is the engine that closes that gap, rather than the promise being quietly deleted.
+*
+* ── Why PET is a different KIND of imaging from everything else in topic 24 ─────────────────────
+* X-ray radiography and CT are TRANSMISSION imaging: the source is outside the patient, and the
+* image is what survived the journey through (`attenuation/core.ts`, `xray-core.ts`). Ultrasound is
+* REFLECTION imaging: the source is outside, and the image is what came back off the boundaries
+* (`ultrasound/core.ts`). PET is EMISSION imaging: the source is INSIDE the patient, it was
+* injected, and it went where the body's own metabolism took it.
+*
+* That is the distinction worth teaching first, because it changes what the picture means. A
+* radiograph shows anatomy: what is dense and where. A PET scan shows FUNCTION: what is consuming
+* glucose fastest. A tumour and healthy tissue of the same density are one grey in a radiograph and
+* two very different brightnesses here.
+*
+* ── Why the two photons come out back to back ──────────────────────────────────────────────────
+* A positron meets an electron and both are annihilated. Two conservation laws fix what comes out:
+*
+*   energy:   the rest energy of both particles, 2 m_e c^2 = 1.022 MeV, has to go somewhere
+*   momentum: the pair was very nearly at rest, so the total momentum was very nearly zero
+*
+* One photon cannot satisfy both: a single photon carrying 1.022 MeV would carry momentum E/c in
+* whatever direction it left, and nothing would balance it. Two photons can, and only if they are
+* equal in energy and OPPOSITE in direction. So 511 keV each, back to back, is not a measured
+* coincidence to be memorised: it is forced, and a student who can say why has the marks.
+*
+* ── The line of response, and the honest limit of the time difference ──────────────────────────
+* Detect both photons within a few nanoseconds of each other and you know the annihilation happened
+* somewhere on the straight line joining the two detectors. That line is the datum PET is built
+* from, and one line localises nothing: the image comes from where millions of lines cross.
+*
+* The syllabus then asks for the time difference, `x = c dt / 2`, which does place the event along
+* the line. It is worth being straight about what that buys, because textbooks imply it is where the
+* resolution comes from and it is not. Light travels 30 cm in a nanosecond. The best clinical timing
+* is around 200 ps, so the position along the line is known to about 3 cm, while a PET image
+* resolves about 4 mm. The time difference sharpens the statistics; the crossing lines make the
+* picture. `timingResolutionToPositionMm` computes the first number so a lesson can compare them
+* instead of asserting.
+*
+* ── Why the resolution floor is physics, not engineering ───────────────────────────────────────
+* Two effects a better detector cannot fix. The positron is emitted with kinetic energy and travels
+* a short distance before it slows enough to annihilate, so the photons leave from somewhere near
+* the decay, not at it. And the pair is never exactly at rest, so the photons are not exactly
+* collinear. Both blur the line. This is also why fluorine-18 wins: the longest half-life in the
+* table AND the lowest positron energy, so the best resolution.
+*/
+const finitePositive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive and finite`);
+	return value;
+};
+const finite = (value, what) => {
+	if (!Number.isFinite(value)) throw new RangeError(`${what} must be finite`);
+	return value;
+};
+/**
+* Energy of each annihilation photon, in MeV. The 511 keV the whole technique is named around.
+*
+* Derived from the electron rest energy rather than typed as 0.511, because the equality IS the
+* physics: each photon carries away exactly one particle's worth of rest energy.
+*/
+const ANNIHILATION_PHOTON_MEV = ELECTRON_REST_ENERGY_MEV;
+/** Total energy released, in MeV: both rest energies, 1.022 MeV. */
+const ANNIHILATION_TOTAL_MEV = 2 * ELECTRON_REST_ENERGY_MEV;
+/** Energy of one annihilation photon in joules, which is the unit an exam answer usually wants. */
+const ANNIHILATION_PHOTON_J = ANNIHILATION_PHOTON_MEV * 1e6 * ELECTRONVOLT;
+/**
+* Wavelength of an annihilation photon, in metres: about 2.4 pm.
+*
+* Worth computing once in a lesson to place these photons on the spectrum. 2.4 pm is shorter than an
+* atomic spacing, which is why they leave the body almost unimpeded and can be detected outside it
+* at all. It is also the Compton wavelength of the electron, which is not a coincidence.
+*/
+const ANNIHILATION_PHOTON_WAVELENGTH_M = HC_EV_NM / (ANNIHILATION_PHOTON_MEV * 1e6) * 1e-9;
+/** Momentum of one annihilation photon, `p = E / c`, in kg m/s. */
+const ANNIHILATION_PHOTON_MOMENTUM = ANNIHILATION_PHOTON_J / SPEED_OF_LIGHT;
+/**
+* Photon energy for an annihilating pair with some kinetic energy left, in MeV.
+*
+* Almost always quoted as if the pair were at rest, and for the syllabus that is right. This exists
+* so a lesson can show WHY the approximation is safe: a positron has to slow to a few eV before it
+* annihilates, against a rest energy of 511 keV, so the shift is parts per hundred thousand.
+*/
+function photonEnergyFromPairMev(kineticTotalMev) {
+	return (ANNIHILATION_TOTAL_MEV + finite(kineticTotalMev, "kinetic energy")) / 2;
+}
+/**
+* The tracers a PET centre actually stocks.
+*
+* Every half-life here is in MINUTES, and that is the fact to notice before any of the others: a
+* tracer cannot be ordered and shelved. Oxygen-15 has to be made in the room. Fluorine-18's
+* 110 minutes is the longest in clinical use and it is still a courier run against the clock, which
+* is why PET centres are built beside cyclotrons and why a missed delivery slot cancels the scan.
+*
+* The short half-life is not a nuisance to be engineered around: it is deliberate. The activity has
+* to fall away quickly once the picture is taken, or the dose keeps accumulating for no benefit.
+*/
+const PET_TRACERS = {
+	fluorine18: {
+		label: "fluorine-18 (FDG)",
+		halfLifeMin: 109.77,
+		positronMaxMev: .633,
+		rangeMm: .6,
+		use: "glucose uptake, so tumours, brain metabolism and inflammation"
+	},
+	gallium68: {
+		label: "gallium-68",
+		halfLifeMin: 67.71,
+		positronMaxMev: 1.899,
+		rangeMm: 2.9,
+		use: "receptor imaging, from a generator rather than a cyclotron"
+	},
+	carbon11: {
+		label: "carbon-11",
+		halfLifeMin: 20.36,
+		positronMaxMev: .96,
+		rangeMm: 1.1,
+		use: "labelling almost any organic molecule, since carbon is already in it"
+	},
+	nitrogen13: {
+		label: "nitrogen-13",
+		halfLifeMin: 9.965,
+		positronMaxMev: 1.198,
+		rangeMm: 1.5,
+		use: "ammonia for blood flow in heart muscle"
+	},
+	oxygen15: {
+		label: "oxygen-15",
+		halfLifeMin: 2.037,
+		positronMaxMev: 1.732,
+		rangeMm: 2.5,
+		use: "labelled water for blood flow, made in the room it is used in"
+	}
+};
+const tracerOf = (id) => PET_TRACERS[id];
+/**
+* Fraction of a tracer dose still active after a delay, in minutes.
+*
+* The same exponential law as beam attenuation, over time rather than distance, so it comes from
+* `attenuation/core.ts` rather than being written again here. A lesson can make the point directly:
+* `N = N_0 e^(-kx)` does not care whether `x` is a thickness of lead or an hour of the afternoon.
+*/
+function tracerRemaining(id, minutes) {
+	finite(minutes, "delay");
+	return remainingFraction(decayConstant(PET_TRACERS[id].halfLifeMin), Math.max(0, minutes));
+}
+/**
+* Minutes until a dose falls to a usable fraction of what was made.
+*
+* The number a delivery schedule is built from. Answers "can this tracer survive the drive", which
+* for oxygen-15 is no, at any distance.
+*/
+function tracerUsableMinutes(id, usableFraction) {
+	const f = finitePositive(usableFraction, "usable fraction");
+	if (f >= 1) return 0;
+	return PET_TRACERS[id].halfLifeMin * (Math.log(1 / f) / Math.LN2);
+}
+/**
+* Where a pair of collinear photons leaves a detector ring, and when each one arrives.
+*
+* `emissionAngle` is the direction the first photon took, in radians; the second goes exactly
+* opposite, which is the part conservation of momentum forces. The ring is centred on the origin.
+* Both photons travel at `c` regardless of which way they went, so the arrival times differ only
+* because the distances do, which is the entire basis of time-of-flight localisation.
+*
+* Throws if the annihilation is outside the ring, because there is no physical geometry to report.
+*/
+function lineOfResponse(annihilation, ringRadiusM, emissionAngle) {
+	const r = finitePositive(ringRadiusM, "ring radius");
+	finite(annihilation.x, "annihilation x");
+	finite(annihilation.y, "annihilation y");
+	finite(emissionAngle, "emission angle");
+	const fromCentre = Math.hypot(annihilation.x, annihilation.y);
+	if (fromCentre >= r) throw new RangeError("annihilation must lie inside the detector ring");
+	const ux = Math.cos(emissionAngle);
+	const uy = Math.sin(emissionAngle);
+	const alongToCentre = annihilation.x * ux + annihilation.y * uy;
+	const discriminant = Math.sqrt(alongToCentre * alongToCentre + (r * r - fromCentre * fromCentre));
+	const distanceAM = discriminant - alongToCentre;
+	const distanceBM = discriminant + alongToCentre;
+	return {
+		detectorA: {
+			x: annihilation.x + ux * distanceAM,
+			y: annihilation.y + uy * distanceAM
+		},
+		detectorB: {
+			x: annihilation.x - ux * distanceBM,
+			y: annihilation.y - uy * distanceBM
+		},
+		chordM: distanceAM + distanceBM,
+		distanceAM,
+		distanceBM,
+		timeDifferenceS: (distanceBM - distanceAM) / SPEED_OF_LIGHT,
+		offsetFromMidpointM: (distanceBM - distanceAM) / 2
+	};
+}
+/**
+* Position of the annihilation along the line, from the arrival time difference: `x = c dt / 2`.
+*
+* The 24.3 calculation, and the factor of two is where the marks go. If the event sits `x` nearer to
+* A, A's photon has `x` less to travel and B's photon has `x` more, so the PATH difference is `2x`
+* and not `x`. Returns metres from the midpoint of the line, positive towards the detector that
+* fired first.
+*/
+function positionFromTimeDifference(timeDifferenceS) {
+	return SPEED_OF_LIGHT * finite(timeDifferenceS, "time difference") / 2;
+}
+/** The time difference an event at a given offset from the midpoint would produce, in seconds. */
+function timeDifferenceForOffset(offsetM) {
+	return 2 * finite(offsetM, "offset") / SPEED_OF_LIGHT;
+}
+/**
+* Position uncertainty along the line, in mm, implied by a detector's timing resolution in ps.
+*
+* The honesty function. A clinical scanner's 200 ps gives about 30 mm, against an image resolution
+* of about 4 mm, so the time difference is nowhere near good enough to place the event by itself.
+* A lesson that quotes `x = c dt / 2` without this leaves the learner believing PET works in a way
+* it does not.
+*/
+function timingResolutionToPositionMm(timingPs) {
+	return positionFromTimeDifference(finitePositive(timingPs, "timing resolution") * 1e-12) * 1e3;
+}
+/** Timing precision in ps needed to place an event to a given number of mm. The inverse. */
+function timingForPositionPs(positionMm) {
+	return timeDifferenceForOffset(finitePositive(positionMm, "position") / 1e3) * 0xe8d4a51000;
+}
+/**
+* Largest time difference a genuine pair can produce in a ring of a given radius, in seconds.
+*
+* Reached when the line is a diameter and the event sits right against one detector. Anything longer
+* than this cannot be one annihilation, which is how the coincidence window is chosen: wide enough
+* to admit every true pair, narrow enough to reject most accidental ones.
+*/
+function maxTrueTimeDifferenceS(ringRadiusM) {
+	return 2 * finitePositive(ringRadiusM, "ring radius") / SPEED_OF_LIGHT;
+}
+/** Whether a measured time difference is inside the coincidence window, given in nanoseconds. */
+function withinCoincidenceWindow(timeDifferenceS, windowNs) {
+	return Math.abs(finite(timeDifferenceS, "time difference")) <= finitePositive(windowNs, "window") * 1e-9;
+}
+/**
+* Approximate image resolution, in mm, from the two floors and the detector size.
+*
+* Combined in quadrature, as independent blurs are. The point of returning the terms alongside the
+* total is that it shows which one dominates: with fluorine-18 and 4 mm detectors the detector wins,
+* so a better crystal helps. With oxygen-15 the positron range wins, and no detector helps at all.
+* That is a conclusion a learner can reach by changing a control, which is worth more than the
+* number.
+*
+* Deliberately omits the block-decoding term real scanners carry, which adds about 2 mm and would
+* bring these numbers up to the 4 to 5 mm a clinical scanner quotes. It is an engineering artefact
+* of how detector crystals are ganged together behind shared photomultipliers, and it is the one
+* term here that is not physics.
+*/
+function imageResolutionMm(id, detectorWidthMm, ringRadiusM) {
+	const detector = finitePositive(detectorWidthMm, "detector width") / 2;
+	const range = PET_TRACERS[id].rangeMm;
+	const collinearity = .0022 * (2 * finitePositive(ringRadiusM, "ring radius") * 1e3);
+	return {
+		totalMm: Math.hypot(detector, range, collinearity),
+		detectorMm: detector,
+		rangeMm: range,
+		collinearityMm: collinearity
+	};
+}
+/**
+* Deterministic generator, so a scan renders the same on the server and in the browser.
+*
+* Every scene in this package has to survive hydration, and a scan built from `Math.random` would
+* produce a different set of lines on each render. Mulberry32, seeded from a prop.
+*/
+function rng(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/**
+* Sample annihilations from a phantom and turn each into a line of response.
+*
+* The emission angle is uniform over a half turn and the two photons go opposite ways, which is the
+* one piece of this that is not a modelling choice: an annihilation has no preferred direction, so
+* every line through it is equally likely. That is exactly why the reconstruction works at all.
+*
+* Deliberately omits attenuation, scatter and random coincidences. Each of those degrades a real
+* scan and none of them changes what a learner needs to see here, which is that a single line says
+* almost nothing and ten thousand lines say where the tracer went.
+*/
+function simulatePetScan(phantom, ringRadiusM, count, seed = 1) {
+	const r = finitePositive(ringRadiusM, "ring radius");
+	finitePositive(phantom.bodyRadiusM, "body radius");
+	if (!Number.isInteger(count) || count < 0) throw new RangeError("event count must be a non-negative integer");
+	if (phantom.bodyRadiusM >= r) throw new RangeError("the body must fit inside the detector ring");
+	for (const source of phantom.sources) if (Math.hypot(source.x, source.y) + source.radiusM > phantom.bodyRadiusM) throw new RangeError(`source "${source.label}" does not fit inside the body`);
+	const next = rng(seed);
+	const bodyArea = Math.PI * phantom.bodyRadiusM ** 2;
+	const weights = phantom.sources.map((s) => s.uptake * Math.PI * s.radiusM ** 2);
+	const total = weights.reduce((sum, w) => sum + w, bodyArea);
+	const events = [];
+	for (let id = 0; id < count; id += 1) {
+		let pick = next() * total;
+		let sourceIndex = -1;
+		for (let i = 0; i < weights.length; i += 1) {
+			if (pick < weights[i]) {
+				sourceIndex = i;
+				break;
+			}
+			pick -= weights[i];
+		}
+		const source = sourceIndex === -1 ? null : phantom.sources[sourceIndex];
+		const centreX = source?.x ?? 0;
+		const centreY = source?.y ?? 0;
+		const spread = source?.radiusM ?? phantom.bodyRadiusM;
+		const rho = Math.sqrt(next()) * spread;
+		const phi = next() * Math.PI * 2;
+		const origin = {
+			x: centreX + rho * Math.cos(phi),
+			y: centreY + rho * Math.sin(phi)
+		};
+		events.push({
+			id,
+			origin,
+			lor: lineOfResponse(origin, r, next() * Math.PI),
+			sourceIndex
+		});
+	}
+	return events;
+}
+/**
+* Simple backprojection: lay every line of response back down and count the crossings.
+*
+* This is the whole idea of tomographic reconstruction in one function, and it is the same idea CT
+* uses. Each line says "the event was somewhere along here", which on its own excludes almost
+* nothing. Add them up and the places where many lines agree are the places the tracer actually
+* was. A learner watching this grid fill in as the event count rises has seen the reconstruction
+* happen rather than been told a scanner does it.
+*
+* Returns `[row][col]` with row 0 at the TOP of the image, matching how a scene draws, and the peak
+* value so a caller can normalise. Real scanners filter before backprojecting, or iterate, both of
+* which sharpen the result; plain backprojection blurs, and the blur is honest about what the data
+* supports.
+*
+* Each cell accumulates the LENGTH of line that crossed it, not a count of marching steps. Counting
+* steps was the first thing I wrote and it is subtly wrong: a diagonal chord takes more steps per
+* cell than an axis-aligned one, so diagonal lines came out brighter and the image acquired a faint
+* cross through the middle that no tracer put there. Weighting by path length is both the correct
+* line integral and free of the artefact.
+*/
+function backproject(events, ringRadiusM, gridSize = 32) {
+	const r = finitePositive(ringRadiusM, "ring radius");
+	if (!Number.isInteger(gridSize) || gridSize < 2) throw new RangeError("grid size must be an integer >= 2");
+	const grid = Array.from({ length: gridSize }, () => Array.from({ length: gridSize }, () => 0));
+	const cell = 2 * r / gridSize;
+	let peak = 0;
+	for (const event of events) {
+		const { detectorA, detectorB } = event.lor;
+		const steps = Math.max(1, Math.ceil(event.lor.chordM / (cell / 4)));
+		const stepLength = event.lor.chordM / steps;
+		for (let i = 0; i < steps; i += 1) {
+			const t = (i + .5) / steps;
+			const x = detectorA.x + (detectorB.x - detectorA.x) * t;
+			const y = detectorA.y + (detectorB.y - detectorA.y) * t;
+			const col = Math.floor((x + r) / cell);
+			const row = Math.floor((r - y) / cell);
+			if (col < 0 || col >= gridSize || row < 0 || row >= gridSize) continue;
+			const value = grid[row][col] += stepLength;
+			if (value > peak) peak = value;
+		}
+	}
+	return {
+		grid,
+		peak
+	};
+}
+
+//#endregion
+export { ANNIHILATION_PHOTON_J, ANNIHILATION_PHOTON_MEV, ANNIHILATION_PHOTON_MOMENTUM, ANNIHILATION_PHOTON_WAVELENGTH_M, ANNIHILATION_TOTAL_MEV, PET_TRACERS, backproject, imageResolutionMm, lineOfResponse, maxTrueTimeDifferenceS, photonEnergyFromPairMev, positionFromTimeDifference, simulatePetScan, timeDifferenceForOffset, timingForPositionPs, timingResolutionToPositionMm, tracerOf, tracerRemaining, tracerUsableMinutes, withinCoincidenceWindow };

package/dist/physics/modern/imaging/pet-preset.d.mts

@@ -0,0 +1,26 @@
+import { AuthoredActivity } from "../../../kit/activity-authoring.mjs";
+import { PetTracerId } from "./pet-core.mjs";
+import { ReactNode } from "react";
+//#region src/physics/modern/imaging/pet-preset.d.ts
+interface PetScanLabProps {
+  tracer?: PetTracerId;
+  /** Detector timing resolution in picoseconds. 200 ps is the best clinical hardware. */
+  timingPs?: number;
+  events?: number;
+  /**
+   * Fraction of the scan already acquired when the lab loads, 0 to 1.
+   *
+   * Defaults to 0, so a learner watches the picture build from nothing. An author who wants the
+   * finished image visible at rest, in a lesson about what the reconstruction shows rather than
+   * how it arrives, can start it part way. This also makes the static gallery useful: a rasterised
+   * render never presses play, so without it every snapshot of this lab shows one coincidence.
+   */
+  startAcquired?: number;
+  title?: string;
+  prompt?: string;
+  objectives?: string[];
+  activity?: AuthoredActivity;
+}
+declare function PetScanLab({ tracer: initialTracer, timingPs: initialTiming, events: totalEvents, startAcquired, title, prompt, objectives, activity }?: PetScanLabProps): ReactNode;
+//#endregion
+export { PetScanLab, PetScanLabProps };

package/dist/physics/modern/imaging/pet-preset.mjs

@@ -0,0 +1,167 @@
+'use client';
+
+import { ActivitySelect, Chip, Slider } from "../../../kit/controls.mjs";
+import { Field, Readout } from "../../../kit/frame.mjs";
+import { AuthoredActivityRuntime, AuthoredMetricGate } from "../../../kit/authored-activity-runtime.mjs";
+import { ExperimentTransport, useExperimentTimeline } from "../shared/experiment-transport.mjs";
+import { ANNIHILATION_PHOTON_MEV, ANNIHILATION_TOTAL_MEV, PET_TRACERS, backproject, imageResolutionMm, maxTrueTimeDifferenceS, positionFromTimeDifference, simulatePetScan, timingResolutionToPositionMm, tracerRemaining } from "./pet-core.mjs";
+import { PetScanScene } from "./pet-scene.mjs";
+import { petScanActivity } from "./pet-activity.mjs";
+import { useMemo, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/physics/modern/imaging/pet-preset.tsx
+const TRACER_IDS = Object.keys(PET_TRACERS);
+const RING_RADIUS_M = .4;
+const GRID = 24;
+/**
+* A torso with raised glucose uptake in two places, which is what an FDG scan is looking for.
+*
+* Neither is drawn into the reconstruction. The right-hand panel is backprojected from the
+* coincidences and nothing else, so the hot spots appear there only because the lines crossed.
+*/
+const PHANTOM = {
+	bodyRadiusM: .18,
+	sources: [{
+		label: "suspected tumour",
+		x: .07,
+		y: .06,
+		radiusM: .015,
+		uptake: 45
+	}, {
+		label: "bladder",
+		x: -.045,
+		y: -.105,
+		radiusM: .026,
+		uptake: 14
+	}]
+};
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function PetScanLab({ tracer: initialTracer = "fluorine18", timingPs: initialTiming = 400, events: totalEvents = 900, startAcquired = 0, title = "PET: locate the tracer from coincidences alone", prompt = "Each annihilation sends two 511 keV photons out back to back. Catch both and you have a line the event happened on. Collect enough lines and the tracer shows up where they cross.", objectives, activity } = {}) {
+	const [tracer, setTracer] = useState(initialTracer);
+	const [timingPs, setTimingPs] = useState(initialTiming);
+	const [truth, setTruth] = useState(false);
+	const timeline = useExperimentTimeline({
+		durationMs: 7200,
+		stops: [
+			0,
+			.1,
+			.35,
+			.65,
+			1
+		],
+		initialProgress: Math.max(0, Math.min(1, startAcquired))
+	});
+	const scan = useMemo(() => simulatePetScan(PHANTOM, RING_RADIUS_M, totalEvents, 20260918), [totalEvents]);
+	const collected = Math.max(1, Math.round(timeline.progress * totalEvents));
+	const events = useMemo(() => scan.slice(0, collected), [scan, collected]);
+	const { grid, peak } = useMemo(() => backproject(events, RING_RADIUS_M, GRID), [events]);
+	const live = events[events.length - 1];
+	const photonProgress = timeline.playing ? timeline.progress * totalEvents % 1 : 1;
+	const tofMm = timingResolutionToPositionMm(timingPs);
+	const resolution = imageResolutionMm(tracer, 4, RING_RADIUS_M);
+	const dtNs = live.lor.timeDifferenceS * 1e9;
+	const offsetMm = positionFromTimeDifference(live.lor.timeDifferenceS) * 1e3;
+	const controls = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(ExperimentTransport, {
+			timeline,
+			label: "acquisition",
+			detail: `${collected} of ${plural(totalEvents, "coincidence")}`
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "tracer",
+			children: /* @__PURE__ */ jsx(ActivitySelect, {
+				ariaLabel: "tracer",
+				value: tracer,
+				onChange: setTracer,
+				options: TRACER_IDS.map((id) => ({
+					value: id,
+					label: PET_TRACERS[id].label
+				}))
+			})
+		}),
+		/* @__PURE__ */ jsx(Field, {
+			label: "detector timing",
+			value: `${timingPs} ps`,
+			children: /* @__PURE__ */ jsx(Slider, {
+				value: timingPs,
+				min: 100,
+				max: 3e3,
+				step: 50,
+				onChange: setTimingPs,
+				ariaLabel: "detector timing resolution"
+			})
+		}),
+		/* @__PURE__ */ jsx(Chip, {
+			selected: truth,
+			onClick: () => setTruth((on) => !on),
+			children: truth ? "Tracer shown" : "Reveal the tracer"
+		})
+	] });
+	const evidence = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+		/* @__PURE__ */ jsx(Readout, {
+			value: `${dtNs >= 0 ? "+" : ""}${dtNs.toFixed(2)} ns`,
+			sub: `arrival time difference for the live coincidence, so ${offsetMm >= 0 ? "+" : ""}${offsetMm.toFixed(0)} mm along its line`
+		}),
+		/* @__PURE__ */ jsxs("div", {
+			className: "lab-metric-list",
+			children: [
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "photon energy" }), /* @__PURE__ */ jsxs("strong", { children: [ANNIHILATION_PHOTON_MEV.toFixed(3), " MeV"] })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "released per annihilation" }), /* @__PURE__ */ jsxs("strong", { children: [ANNIHILATION_TOTAL_MEV.toFixed(3), " MeV"] })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "timing places it to" }), /* @__PURE__ */ jsxs("strong", { children: [
+					"±",
+					tofMm.toFixed(0),
+					" mm"
+				] })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "image resolves" }), /* @__PURE__ */ jsxs("strong", { children: [resolution.totalMm.toFixed(1), " mm"] })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "tracer half-life" }), /* @__PURE__ */ jsxs("strong", { children: [PET_TRACERS[tracer].halfLifeMin.toFixed(0), " min"] })] }),
+				/* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("span", { children: "left after an hour" }), /* @__PURE__ */ jsxs("strong", { children: [(tracerRemaining(tracer, 60) * 100).toFixed(1), "%"] })] })
+			]
+		}),
+		/* @__PURE__ */ jsxs("p", { children: [
+			PET_TRACERS[tracer].label,
+			" shows ",
+			PET_TRACERS[tracer].use,
+			". Its positrons travel about",
+			" ",
+			PET_TRACERS[tracer].rangeMm.toFixed(1),
+			" mm before annihilating, which is a limit on resolution that no better detector can lift. Coincidence window here is",
+			" ",
+			(maxTrueTimeDifferenceS(RING_RADIUS_M) * 1e9).toFixed(1),
+			" ns, the longest difference this ring can physically produce."
+		] })
+	] });
+	const runtime = activity ?? (objectives ? {
+		...petScanActivity.source,
+		objectives
+	} : petScanActivity);
+	return /* @__PURE__ */ jsx(AuthoredActivityRuntime, {
+		className: "physics-imaging",
+		focusLayout: "immersive",
+		activity: runtime,
+		activityId: "pet-scan",
+		eyebrow: "Modern physics · imaging",
+		title,
+		description: prompt,
+		controls,
+		evidence,
+		observation: `Each coincidence gives one line, and one line only says the annihilation happened somewhere along it. The picture on the right is built from ${collected} of them and from nothing else. The timing reaches ${tofMm.toFixed(0)} mm either side of the event, against a hot spot ${(PHANTOM.sources[0].radiusM * 2e3).toFixed(0)} mm across, which is why the crossings make the image and the clock does not.`,
+		children: ({ complete }) => /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(AuthoredMetricGate, {
+			conditionId: "scan-complete",
+			met: timeline.progress >= 1,
+			complete
+		}), /* @__PURE__ */ jsx(PetScanScene, {
+			ringRadiusM: RING_RADIUS_M,
+			phantom: PHANTOM,
+			events,
+			grid,
+			peak,
+			photonProgress,
+			tofMm,
+			showTruth: truth
+		})] })
+	});
+}
+
+//#endregion
+export { PetScanLab };

package/dist/physics/modern/imaging/pet-scene.d.mts

@@ -0,0 +1,21 @@
+import { PetEvent, PetPhantom } from "./pet-core.mjs";
+import { ReactNode } from "react";
+//#region src/physics/modern/imaging/pet-scene.d.ts
+interface PetScanSceneProps {
+  ringRadiusM: number;
+  phantom: PetPhantom;
+  /** Events collected so far. The last one is drawn as the live event. */
+  events: readonly PetEvent[];
+  /** Backprojected density, `[row][col]`, and its peak. */
+  grid: readonly number[][];
+  peak: number;
+  /** 0 to 1, how far the live event's photons have flown from the annihilation. */
+  photonProgress: number;
+  /** Half-width of the time-of-flight band, in mm. Null when timing is not being used. */
+  tofMm: number | null;
+  /** Draw where the tracer really is, for comparison against the reconstruction. */
+  showTruth: boolean;
+}
+declare function PetScanScene({ ringRadiusM, phantom, events, grid, peak, photonProgress, tofMm, showTruth }: PetScanSceneProps): ReactNode;
+//#endregion
+export { PetScanScene, PetScanSceneProps };