Learning instruments

std-learn-arrangement

a config-declared roster of items (each with a correct position index and an optional hint) is tapped one at a time from a remaining-items button row onto a growing sequence of ordered slots rendered on a math-canvas; a tapped item becomes unavailable, an Undo button removes the last placement, and once every slot is filled a Check button grades the arrangement with per-slot correct/wrong coloring, a score readout, and a verdict badge. Retry clears the placements and keeps the same roster. Item vocabulary is entirely config-declared, so the same mechanism serves any ordering task (process steps, chronology, procedure, ranking) standalone. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnArrangementScene (runtime)

Traits

Config knobs

std-learn-classify

items are presented one at a time on a current-item card (with an optional config-declared hint), the learner picks a category from an ordered stacked-backdrop ladder (the picked rung rings, the correct rung glows green, a wrong pick glows red), an explicit verdict beat shows a correct/incorrect badge plus a config-declared explanation, a progress readout tracks item k of n and a running score, and after the last item the learner reaches an end-of-round summary with a per-category breakdown and a Retry affordance. Category and item vocabulary is entirely config-declared, so the same mechanism serves any classification domain (needs hierarchies, checks-and-balances, sociological imagination, and beyond) on a biology-canvas. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnClassifyScene (runtime)

Traits

Config knobs

std-learn-compare

two instances of the same config-declared curve family (power y = A·xᴮ, linear y = A + B·x, or sine y = A·sin(B·x)) render overlaid on one canvas, each side driven by its own parameter pair of sliders, with a live delta readout of the two values at the midpoint x. Changing either side recomputes immediately, so the learner sees exactly how the two settings diverge. All labels and defaults are config-declared, so the same mechanism serves any side-by-side contrast: two interest rates compounding, two spring constants, two demand elasticities, two wave frequencies. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: CompareScene (runtime)

Traits

Config knobs

std-learn-coupled-sim

two named quantities evolve each tick under a config-selected interaction family (predator-prey: dP = aP − bPQ, dQ = cbPQ − dQ; epidemic: dS = −aSI, dI = aSI − bI; kinetics: dP = −aP, dQ = aP − bQ), drawn live as two time-series curves while Run is engaged. The two governing rates are exposed as sliders the learner can retune mid-run, and shock buttons inject or remove a burst of the first quantity so the learner feels how the coupled system absorbs disturbance. All names, coefficients, and scales are config-declared, so one mechanism serves rabbits and foxes, infection and recovery, reactant and product, adopters and churn. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: CoupledSimScene (runtime)

Traits

Config knobs

std-learn-derivation

config-declared starting lines (facts and two-sided links) sit in a scrollable derivation panel with per-line badges, a roster of config-declared candidate steps render as buttons, and picking one dynamically matches it against the CURRENT lines (a left/right side of some link plus a same/opposite negation sense) to derive a new line, appending it with config-declared badge styling on success or surfacing a config-declared feedback string on failure; an inline clock can auto-apply the first applicable candidate every autoApplyIntervalMs while running, a Reset restores the starting lines, and the goal is reached when a derived line's label matches the config-declared goal label. Left/right and same/opposite are structural roles, not domain vocabulary, so the same matching mechanism serves propositional inference, chained implications, precursor/product chemistry, or any other two-sided-relation derivation on a biology-canvas-free text panel. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnDerivationScene (runtime)

Traits

Config knobs

std-learn-diagram

Generic annotated-diagram instrument. Contract: a config-declared roster of labeled parts (id, label, description, x, y, radius, color) plus optional connector links (from, to, color, label); the whole diagram renders as circles connected by lines with always-visible part labels on a biology-canvas; the learner selects a part via its choice-button and the selected part is visually emphasized with a highlight ring and enlarged radius while its description renders in a caption card alongside a "part k of n selected" readout; a Clear button returns to the no-selection overview state where the caption card shows a config-declared overview text. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnDiagramScene (runtime)

Traits

Config knobs

std-learn-doser

the learner adds a quantity in large or small config-declared increments (or lets it auto-drip on its own inline clock) and watches an accumulated dose climb through a config-declared roster of bands/zones (thresholds, labels, colors all config), rendered as a reservoir/source vessel pair plus a dose-history trace on a canvas. Crossing into a terminal band is irreversible — done latches true and only Reset revives it. Standalone by default it renders its own control strip AND scene canvas; set showCanvas false to embed only the control strip (via @trait.<name>) beneath a composed sibling trait that owns the domain-accurate scene — see std-chem-titration for the transport-sibling shape. Behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: DoserScene (runtime)

Traits

Config knobs

std-learn-estimate

a config-declared prompt roster asks for a quantity, the learner commits an estimate on a slider and locks it in, and the guess is graded by relative-error band: within the exact band scores full points, within the close band partial, outside none, with the true answer and the learner's percentage error revealed after each lock-in and a running score across the round. All vocabulary and bands are config-declared, so the same mechanism serves any quantitative intuition: orders of magnitude, unit conversions, historical dates, population sizes, physical constants, probabilities. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: EstimateScene (runtime)

Traits

Config knobs

std-learn-fx-cues

correct/wrong beats, streak glow at a threshold, and a celebration on completion. Cues are typed FxCue config values carrying their own style (position, ttl, screen effect, color), so a lab opts in with two uses lines plus an overlay node and restyles or disables any cue purely through config; the instruments never learn about visuals, and this atom never learns about subjects. A new judged event elsewhere in the substrate means a new arm here — this listens list is the closed extension point. Renders nothing.

Entity: LearnFxCuesScene (runtime)

Traits

Config knobs

std-learn-goal-seek

a config-declared target curve is drawn from a hidden parameter pair, and the learner tunes their own two parameters with sliders until their curve matches it, then presses Check to be graded against an RMS-distance tolerance. The curve family (power y = A·xᴮ, linear y = A + B·x, or sine y = A·sin(B·x)), the hidden target parameters, the tolerance, and every label are config-declared, so the same mechanism serves any inverse problem: fit a demand curve, match a projectile arc, tune a growth rate, recover a wave's amplitude and frequency. A live distance readout (optionally hidden for a harder variant) plays warmer/colder. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: GoalSeekScene (runtime)

Traits

Config knobs

std-learn-grid-sim

a tappable cellular grid evolves under a config-selected local rule: life (Conway's birth-3, survive-2-or-3), spread (anything with an active 4-neighbour activates — wavefronts, fire, contagion), or diffusion (each cell relaxes toward its neighbourhood average with decay — heat, concentration). The learner seeds the world by tapping cells directly on the canvas, then Runs, Pauses, or single-Steps the evolution, with a generation counter and live active-cell census. Rule, grid dimensions, seeds, and palette are all config-declared, so one mechanism serves emergence, percolation, epidemic fronts, heat flow, and any local-rules-global-behaviour lesson. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: GridSimScene (runtime)

Traits

Config knobs

std-learn-hotspot

a config-declared roster of labeled hotspots (id, label, x, y, radius, color) renders on a learning-canvas, and a config-declared prompt roster asks the learner to tap the right part directly on the canvas: a first-try hit scores, a miss names what was actually tapped and invites another try, and a hit reveals the part's explanation with a highlight ring before advancing. All vocabulary is config-declared, so the same mechanism serves any labeled scene: organs on a cell, countries on a sketch map, components on a circuit, bones on a skeleton. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: HotspotScene (runtime)

Traits

Config knobs

std-learn-live-sim

the live-integration sibling of std-physics-projectile: config-declared initial bodies (position, velocity, radius, color) fall under gravity, lose speed to damping, and bounce off the world bounds every tick while Run is engaged; Pause freezes the simulation and Reset restores the initial bodies. Gravity and damping are each exposed as a range-slider so the learner can retune the dynamics live, with a readout of elapsed ticks and a sample body's current speed. So the same mechanism serves any bouncing-particle domain (gas molecules, falling objects, orbit sketches, and beyond) on a physics-canvas. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LiveSimScene (runtime)

Traits

Config knobs

std-learn-measure

a config-declared signal (sine A·sin(B·t), growth A·(1+B)ᵗ, or half-life decay A·(1/2)^(t/B)) evolves live while Run is engaged, drawing its trace across the chart, and the learner presses Probe to record the instantaneous value as a data point: recorded points accumulate on the chart with a running sample count and mean, teaching the discipline of sampling a changing quantity rather than reading a printed table. Pause freezes time mid-run and Reset clears the experiment. All vocabulary and dynamics are config-declared, so the same mechanism serves any measure-the-system exercise: temperature during a reaction, voltage on a discharging capacitor, population through a season, a pendulum's displacement. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: MeasureScene (runtime)

Traits

Config knobs

std-learn-param-explorer

two sliders drive a config-selected curve family (power y = A·xᴮ, linear y = A + B·x, or sine y = A·sin(B·x)) sampled onto a math-canvas, with a live readout of both parameters and the curve's value at the midpoint x. Subject atoms narrow the curve family and parameter labels through config; this atom owns only the sample-and-recompute mechanics. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: ParamExplorerScene (runtime)

Traits

Config knobs

std-learn-perturb

a single named quantity relaxes each tick toward an adjustable setpoint at an adjustable recovery rate (dV = k·(E − V)), drawn live against the setpoint line. Shock buttons knock the quantity up or down mid-run and the learner watches it recover; moving the setpoint slider mid-run makes the system chase a new equilibrium, and the recovery-rate slider shows sluggish versus snappy regulation. All names and scales are config-declared, so one mechanism serves every negative-feedback lesson: body temperature homeostasis, a thermostat, market price around equilibrium, blood glucose, reservoir level, ecological resilience. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: PerturbScene (runtime)

Traits

Config knobs

std-learn-predict

each config-declared scenario states a setup and a question, the learner commits to one of the predicted outcomes, and only then does the outcome play out: a timed reveal draws the scenario's declared value frames one by one as a growing curve with per-frame captions, ending in a verdict against the committed prediction and the scenario's explanation, with a running score across scenarios. All vocabulary is config-declared, so the same mechanism serves any commit-before-you-see teaching beat: what happens to the population, which way does the price move, does the reaction speed up, where does the phase go next. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: PredictScene (runtime)

Traits

Config knobs

std-learn-sample-accumulator

a Draw button adds a batch of pseudo-random samples from a config-selected source (uniform 0..1, or a coin flip weighted by bias) into a fixed-bin histogram on a math-canvas, with running sample count, running mean, and (for the coin source) observed proportion vs bias. Subject atoms narrow the source kind and labels through config; this atom owns only the draw-and-accumulate mechanics. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: SampleAccumulatorScene (runtime)

Traits

Config knobs

std-learn-sandbox

a config-declared roster of elements (each with a weight and a default enabled state) sits on a biology-canvas connected by config-declared links; each element has a toggle button, and toggling recomputes a derived total (the summed weight of enabled elements) against a config-declared threshold, with a readout stating whether the system currently holds. Links to or from a disabled element render dimmed. Reset restores every element to its config-declared default. Element and link vocabulary is entirely config-declared, so the same mechanism serves any threshold-system exploration (coalition building, load balancing, ecosystem tipping points, circuit continuity) standalone. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnSandboxScene (runtime)

Traits

Config knobs

std-learn-scatter-fit

points on a math-canvas (config-declared axis ranges/labels/colors) with a live least-squares refit: slope, intercept, r, and R² recompute as points are added (button or auto-add tick, up to maxPoints) or dragged. An optional guess-then-reveal mode lets the learner drag slope/intercept sliders to propose a line, scored against the fit until Reveal Fit; dashed residual segments and the r/R² readout are config-toggleable. Run/Pause drives a fixed-interval auto-add tick, Reset reseeds from the configured point roster. SCATTER_FIT_UPDATED broadcasts the fit after every learner action, tick, or reset. Every button label, caption, curve label/color, and narration phrase is config-declared so the same mechanism serves any scatter-fit domain (correlation, physics data fitting, trend lines, and beyond) on a math-canvas. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnScatterFitScene (runtime)

Traits

Config knobs

std-learn-scenario

a config-declared node graph of situations and choices plays out as a choose-your-path story with modeled consequences: every choice shifts two config-named metrics, appends to a visible decision log, and moves to its declared next node, until a node with no choices ends the run with the final metrics and the full path. This simulates decisions rather than browsing records: the learner feels trade-offs compound. All vocabulary is config-declared, so the same mechanism serves any consequence-chain lesson: fiscal policy choices, ecosystem interventions, historical what-ifs, medical triage, engineering trade-offs. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: ScenarioScene (runtime)

Traits

Config knobs

std-learn-sim-3d

a Play/Pause toggle, Reset and a SPEED_SET 0.5x/1x/2x/4x group (legacy RUN, PAUSE and SPEED_HALF/NORMAL/DOUBLE/QUAD events are still honored) drive a running flag and speed multiplier, and a 32ms tick advances steps and simTime by dt x speedMultiplier, emitting SIM_3D_TICK { dt, simTime } each step WITHOUT rendering; a composed sibling trait transitions directly on the SIM_3D_TICK / SIM_3D_UPDATED broadcasts (the same bare-event cascade the lab routers use), applies the domain physics, and owns the scene render — this atom renders no canvas. A caption readout shows steps, sim time, and current speed. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: Learn3DSimScene (runtime)

Traits

Config knobs

std-learn-slope-probe

the slope dy/dx, a tangent-line segment of half-width window centered on the contact point, a rise-over-run triangle (run triRun, rise slope·run), and the glow window of curve samples around the contact — all written to a [runtime, shared] entity so the board renders the math the player is physically riding. Emits the sparse SLOPE_CHANGED signal only when the slope crosses a 0.5 bucket boundary, so fx and HUD meters react to changes in steepness without paying a per-tick event. The curve is the same sample table the body skates and the canvas draws — one source, three views. Renders nothing.

Entity: SlopeProbeState (runtime)

Traits

Config knobs

std-learn-speed-drill

a config-declared item roster of prompt + options runs against a live countdown: answering while the clock runs scores the base points plus a speed bonus proportional to the time left, letting the clock hit zero counts as a miss and reveals the answer, and a streak counter rewards consecutive hits with an end-of-round summary of score and best streak. All vocabulary and timing is config-declared, so the same mechanism serves any fluency drill: times tables, sight vocabulary, chemical symbols, flag recognition, interval identification — anywhere fast retrieval is the skill. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: SpeedDrillScene (runtime)

Traits

Config knobs

std-learn-stepper

the learner moves a Next/Prev cursor across an ordered roster of stages laid out as a timeline: a legend names each category color, the cursor stage rings and grows while past/future stages stay visually distinct by reveal state, the current stage label and description render prominently in a card, a per-category running tally updates live, progress reads stage k of n, and the Prev/Next cursor clamps deliberately at either end with a narrated note rather than silently doing nothing. The category-lens filter dims non-matching stages instead of hiding them, keeping the whole timeline in view. Stage and category vocabulary is entirely config-declared, so the same mechanism serves any ordered-sequence domain (periodization timelines, phase cycles, stellar evolution, and beyond) on a math-canvas. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnStepperScene (runtime)

Traits

Config knobs

std-learn-tour-3d

either way the camera retargets onto the selected station's x/y/z, the station enlarges, a name — caption narration renders, and a progress readout tracks visited stations until every station has been toured. A backdrop knob renders non-station scene geometry under the stations (painted, never toured). SYNC_STATIONS hot-swaps the roster mid-flight (a composed preset coordinator emits it with new stations/edges/backdrop; the tour adopts them and restarts progress at the first new station) — the single-writer entry point for dynamic rosters. Composed of a biology-canvas in 3D mode plus a tour state machine. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: Learn3DTourScene (runtime)

Traits

Config knobs

std-learn-trace-player

the timed-autoplay sibling of std-learn-stepper: a config-declared ordered roster of frames (each frame a label, caption, and a numeric value snapshot with optional highlighted indices) advances on a fixed tick while Play is engaged, Pause freezes the cursor in place, and Restart rewinds to the first frame; reaching the last frame either loops back to the start (config loop) or stops and emits a completion signal. The current frame's values render as bars on an algorithm-canvas with highlighted indices picked out by color, alongside a frame k of n readout and a caption card narrating what changed, so the same mechanism serves any ordered numeric-trace domain (sorting steps, iterative approximations, simulation snapshots, and beyond). Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: TracePlayerScene (runtime)

Traits

Config knobs

std-learn-transport

the substrate twin of std-learn-sim-3d for discrete-step instruments. Contract: the atom owns the Step/Run-Pause/Reset transport and the clock but NOT the subject computation — STEP advances one step manually, TOGGLE_RUN engages a 32ms tick that accumulates elapsed time and fires one step every stepIntervalMs, RESET zeroes the counters and restores autoRun. Every step (button or clock) broadcasts LEARN_STEP; a composed sibling trait transitions directly on the LEARN_STEP / LEARN_RESET / LEARN_UPDATED broadcasts (the same bare-event cascade the lab routers use), applies the domain computation, halts the clock by setting the shared entity's done flag (the sibling is done's ONLY writer — it must also clear it on LEARN_RESET), and owns the scene render — this atom renders only its control strip and step caption. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnTransportScene (runtime)

Traits

Config knobs

std-learn-tree

inserts values one by one from a config-declared sequence, each value descends left/right by comparison against the current node and attaches as a leaf; the tree renders on algo-graph-canvas (layout: tree, auto-positioned from the parent/child edges), settled nodes green, the descent cursor red, the comparison trail amber. Traverse sweeps the tree to the chosen order (inorder/preorder/levelorder) one node per press or on auto-run, narrating the visit order so far. Vocabulary, sample values, colors, and labels are entirely config-declared, so the same mechanism serves any ordered-tree domain. Standalone by default; behind a lab router set matchMode and it renders only when MODE_SELECTED matches.

Entity: LearnTreeScene (runtime)

Traits

Config knobs

One ui-* behavior per UI pattern, generated 1:1 from the pattern registry: its config knobs are the pattern's props.