@descix/frqtl-node 0.6.1-p3.3 → 0.7.0-p0

package/dist/frqtl/scenes/circuit-sat.js

@@ -1,131 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — Circuit SAT (a half-adder)
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world, the two
- * logic gates, the four rail traces with their input emitters, the two grounded readouts, the live
- * input knobs and the framing are all here; the sugar (LogicGate, Trace, SphereEmitter), the
- * renderer and the engine are imports. Registered by lib/shim/registry/walkthrough.js (rung
- * circuit-sat).
- *
- * Physics (zero new — bench LO1/LO6/LO7 + the Trace wiring): input A and input B are laser
- * emitters that drive quanta down rail traces into an XOR gate (SUM) and an AND gate (CARRY). A
- * gate's valve opens only when its two input ammeters read the logic it embodies, so the circuit
- * SETTLES onto the half-adder's answer: SUM = A xor B, CARRY = A and B, read as the current on each
- * grounded readout. No search algorithm runs.
- *
- * Order (it seeds the run): world → SUM gate → CARRY gate → per lane plan row,
- * the rail trace then its emitter (switched to its input) → the two readouts.
- */
-
-import { FrqtlControlOverlay, FrqtlControlsPanel, LogicGate, SphereEmitter, Trace } from '@descix/frqtl-web/parts';
-import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
-
-// Code-declared on purpose: the emitter centres and rail traces derive from the gates' port geometry and RAIL (a knob rewrites it), and a Trace has no kind — a literal block would restate derived geometry by hand.
-export const parts = {};
-
-export default function buildExperiment(exp) {
-  var W = 760, H = 520;              // THE WORLD this scene states (its co-init call below)
-  var LEFT = 60, TOP = 15;           // the circuit's top-left
-  var RAIL = 6;                      // rail voltage: quanta per tick per input emitter
-  var LEAD = 24, READOUT = 24;       // input-rail and readout trace lengths
-  var INSET = 4;                     // each input emitter sits this far inside its rail's bore mouth
-  var STATE = { a: true, b: false };   // input A HIGH at start: SUM reads 1, CARRY reads 0
-
-  // The input emitter: a narrow 2D laser on the fundamental layer, random ± charge.
-  function emitterBag(center) {
-    var bag = { preset: 'laser', is2D: true, R: 24, orientationDeg: 0, emissionBoxSide: 0,
-                fundamentalDimension: 0, burstSize: RAIL, emitEveryTicks: 1, chargeMode: 'random' };
-    if (center) { bag.center = center; }
-    return bag;
-  }
-
-  // ── WORLD — a 2D canvas + universe; the emitter's own world (its worldCfg) ──
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(emitterBag(null)));
-  exp.declare(parts);
-  var u = exp.universe;
-
-  var MIN = LogicGate.MINIMAL;                                  // bore 3 / wall 3 / length 20
-  var cell = LogicGate.cellSize(MIN.bore, MIN.wallThickness, MIN.length);
-  var gateOpts = { bore: MIN.bore, wallThickness: MIN.wallThickness, length: MIN.length, supplyVoltage: RAIL };
-
-  // ── THE GATES — SUM (XOR) above CARRY (AND) ─────────────────────────────
-  var sum = exp.addObject('LogicGate', Object.assign({ logic: 'XOR', left: LEFT, top: TOP, name: 'SUM', color: [200, 170, 70] }, gateOpts));
-  var carry = exp.addObject('LogicGate', Object.assign({ logic: 'AND', left: LEFT, top: TOP + cell.h, name: 'CARRY', color: [170, 200, 90] }, gateOpts));
-  var gates = { SUM: sum, CARRY: carry };
-
-  // ── THE INPUT RAILS — the lane plan: B and A are SWAPPED on CARRY (AND commutes; the swap buys
-  //    a lane pitch of separation between the two inputs) ──────────────────────────────────────
-  var LANES = [
-    { input: 'A', gate: 'SUM', port: 'inPortA' }, { input: 'B', gate: 'SUM', port: 'inPortB' },
-    { input: 'B', gate: 'CARRY', port: 'inPortA' }, { input: 'A', gate: 'CARRY', port: 'inPortB' }
-  ];
-  var rails = { A: [], B: [] }, traces = [];
-  LANES.forEach(function (row, i) {
-    var port = gates[row.gate][row.port], y = port[1];
-    var t = new Trace(u, { path: [[port[0] - LEAD, y], [port[0], y]], bore: MIN.bore,
-                           wallThickness: MIN.wallThickness, name: 'rail' + row.input + i, color: [90, 120, 200] });
-    var em = exp.addObject('SphereEmitter', Object.assign(emitterBag([t.inPort[0] + INSET, y]),
-                                                          { name: 'input' + row.input + i }));   // parked inside the bore mouth
-    em.setActive(row.input === 'A' ? STATE.a : STATE.b);
-    rails[row.input].push(em);
-    traces.push(t);
-  });
-
-  // ── THE READOUTS — grounded traces off each gate's outlet: their current IS the answer ──
-  function readout(gate, name) {
-    return new Trace(u, { path: [[gate.outPort[0], gate.outPort[1]], [gate.outPort[0] + READOUT, gate.outPort[1]]],
-                          bore: MIN.bore, wallThickness: MIN.wallThickness, ground: true, name: name, color: [60, 160, 220] });
-  }
-  var readouts = { SUM: readout(sum, 'SUM_out'), CARRY: readout(carry, 'CARRY_out') };
-  traces.push(readouts.SUM, readouts.CARRY);
-  traces.forEach(function (p) { p.attachToRunner(exp.runner); });   // every trace reads the tick stream (a declared gate subscribed at addObject)
-
-  function setInput(which, on) {
-    STATE[which] = !!on;
-    rails[which === 'a' ? 'A' : 'B'].forEach(function (em) { em.setActive(STATE[which]); });
-  }
-
-  // ── THE CIRCUIT, PUBLISHED — the parts and the geometry a harness reads (the half-adder
-  //    acceptance rig): each gate's own getState(), each readout's calibrated getDelivered(), the
-  //    input switch, and the layout values its settle budget is computed from. ───────────────
-  exp.circuit = {
-    gates: gates, readouts: readouts,
-    rails: rails, lanes: LANES, setInput: setInput,
-    lead: LEAD, readout: READOUT, inset: INSET
-  };
-
-  // ── THE VIEW — frame the 72x54 px circuit (render only: the 2D camera's distance IS the visible
-  //    physics-px height) ─────────────────────────────────────────────────────────────────────
-  var fp = [LEFT - LEAD, TOP, LEAD + cell.w + READOUT + 4, cell.h * 2];
-  var cam = exp.runner.cameraControl;
-  if (cam && typeof cam.setOrbit === 'function') {
-    cam.setOrbit({ target: { x: fp[0] + fp[2] / 2, y: fp[1] + fp[3] / 2 },
-                   distance: Math.max(fp[3] * 1.35, fp[2] * 1.35 * H / W) });
-  }
-
-  // ── THE KNOBS (on the canvas): the two inputs and the rail ──────────────
-  var registry = ControlRegistry.makeControlRegistry();
-  registry.registerControls('circuit-sat', [
-    { kind: 'scalar', id: 'inputA', label: 'input A', min: 0, max: 1, step: 1, value: STATE.a ? 1 : 0, widget: 'toggle',
-      fmt: function (v) { return v ? '1 (HIGH)' : '0 (LOW)'; }, onChange: function (v) { setInput('a', v); },
-      place: { x: 0.02, y: 0.80 } },
-    { kind: 'scalar', id: 'inputB', label: 'input B', min: 0, max: 1, step: 1, value: STATE.b ? 1 : 0, widget: 'toggle',
-      fmt: function (v) { return v ? '1 (HIGH)' : '0 (LOW)'; }, onChange: function (v) { setInput('b', v); },
-      place: { x: 0.02, y: 0.88 } },
-    { kind: 'scalar', id: 'rail', label: 'rail (burst/tick)', min: 1, max: 16, step: 1, value: RAIL,
-      fmt: function (v) { return String(v) + ' q/tick'; },
-      onChange: function (v) {
-        RAIL = Math.max(0, Math.round(v));
-        sum.setSupplyVoltage(RAIL); carry.setSupplyVoltage(RAIL);
-        rails.A.concat(rails.B).forEach(function (em) { em.setBurstSize(RAIL); });
-      },
-      place: { x: 0.30, y: 0.88 } }
-  ]);
-  // Chrome (a page only): expose the knobs to a host frame, and mount the overlay through the
-  // runner's ONE door (runner.controlHost) — before a canvas is mounted (a notebook pane) there is
-  // none, so the knobs stay in the exposed registry only.
-  FrqtlControlsPanel.exposeRegistry(registry, { runner: exp.runner });
-  if (exp.runner.controlHost) { FrqtlControlOverlay.mount(exp.runner, { registry: registry, name: 'circuit-sat' }); }
-}

package/dist/frqtl/scenes/collision-matrix-3d.js

@@ -1,110 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — 3D Collisions Lab
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The 3D world, the
- * seven head-on lanes of equal-mass voxel pairs, their live knobs and the look are all here; the
- * lane density table (`collisionMatrixLanes`), the renderer and the engine are imports.
- * Registered by lib/shim/registry/walkthrough.js (rung collision-matrix-3d).
- *
- * Physics (zero new — bench C2, C3, C5, SU1): each lane fires two equal bodies at each other at
- * speed_prob 1 along x; a lane's density (mass / capacity) sets how hard the bodies are — rigid
- * bodies bounce cleanly, soft ones press into each other before parting. The lanes sit on a 3x3
- * y/z grid, so the same contact happens at seven depths: collision is identical on any axis
- * (2D ≡ 3D). The same engine that makes light makes mechanics — no second physics.
- *
- * Order (it seeds the run): world → collisions on → the voxel layer →
- * per lane, body A then body B (engine-built, capacity read back once) → seat every body.
- */
-
-import { CameraControls, FrqtlControlOverlay, FrqtlControlsPanel } from '@descix/frqtl-web/parts';
-import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
-import { collisionMatrixLanes } from '@descix/frqtl-web/objects/setup/_collisionMatrixLanes.js';
-
-export const parts = {};
-
-export default function buildExperiment(exp) {
-  var W = 700, H = 700, D = 700;    // THE WORLD this scene states (its co-init call below)
-  var LEVEL = 6;                    // the voxel layer: 64 px bodies, capacity 4096
-
-  // ── WORLD — a 3D scene + universe W×H×D, fundamental layer 0, λ multiplier 1 ──
-  exp.createScene(W, H, D, { dimension: 0, wavelengthScale: 1 });
-  exp.declare(parts);
-  var u = exp.universe;
-  u.withInterQuantumCollisions = true;
-  u.addDimension(LEVEL);
-  exp.runner.setRateLimits({ tpsLimit: 240 });   // pacing only: wall-clock, never the ticks
-
-  var lanesTable = collisionMatrixLanes;   // the ONE lane density table (imported)
-  var voxel = Math.pow(2, LEVEL), half = voxel / 2;
-  var midX = Math.floor(W * 0.5);
-  var ax0 = midX - Math.floor(1.5 * voxel);       // body A, left of centre
-  var bx0 = midX + Math.floor(1.5 * voxel);       // body B, right of centre
-  var N = lanesTable.LANE_DENSITIES.length;       // 7 lanes
-  var spacing = Math.round(H / 4);
-  var laneYs = [], laneZs = [];
-  for (var k = 0; k < N; k++) {
-    laneYs.push(Math.round(H / 2 + (Math.floor(k / 3) - 1) * spacing));   // rows 0,0,0,1,1,1,2
-    laneZs.push(((k % 3) - 1) * spacing);                                 // cols 0,1,2,…
-  }
-
-  // The live knobs: an offset (the bodies miss by that much) and an angle (vy against vx).
-  var offsetPx = 0, angleVy = 0;
-  function seat(qid, cx, cy, cz, dirX, mass) {
-    u.setFrameProperty(qid, 'x', cx);
-    u.setFrameProperty(qid, 'y', cy + dirX * offsetPx);
-    u.setFrameProperty(qid, 'z', cz);
-    u.setFrameProperty(qid, 'vx', dirX);
-    u.setFrameProperty(qid, 'vy', -dirX * angleVy);
-    u.setFrameProperty(qid, 'vz', 0);
-    u.setFrameProperty(qid, 'mass', mass);
-    u.setFrameProperty(qid, 'speed_prob', 1.0);
-  }
-
-  // ── THE BODIES — A then B per lane; the capacity is read back from the engine, never assumed ──
-  var built = [], capacity = null;
-  for (var i = 0; i < N; i++) {
-    var a = u.makeLeafFrame(ax0 - half, laneYs[i] - half, LEVEL, null, 1, 0, true, 0, null);
-    u.injectFrame(a);
-    var aQid = u.getFrameQuantumId(a);
-    var b = u.makeLeafFrame(bx0 - half, laneYs[i] - half, LEVEL, null, -1, 0, true, 0, null);
-    u.injectFrame(b);
-    var bQid = u.getFrameQuantumId(b);
-    if (capacity === null) { capacity = u.getFrameProperty(aQid, 'mass'); }
-    built.push({ aQid: aQid, bQid: bQid });
-  }
-  var masses = lanesTable.laneMassesForCapacity(capacity);
-  var lanes = built.map(function (q, i) {
-    return { aQid: q.aQid, bQid: q.bQid, mass: masses[i], laneY: laneYs[i], laneZ: laneZs[i] };
-  });
-  function reseatAll() {
-    lanes.forEach(function (l) {
-      seat(l.aQid, ax0, l.laneY, l.laneZ, 1, l.mass);
-      seat(l.bQid, bx0, l.laneY, l.laneZ, -1, l.mass);
-    });
-  }
-  reseatAll();
-
-  // ── THE LOOK — lit spheres, coloured by fullness (sparse red → dense violet) ──
-  exp.render({ shape: 'sphere', colorScheme: 'roygbiv' });
-
-  // ── THE KNOBS (on the canvas) + MOVE/LOOK pads ──
-  var registry = ControlRegistry.makeControlRegistry();
-  registry.registerControls('collision-matrix-3d', [
-    { kind: 'scalar', id: 'offset', label: 'offset', min: 0, max: 48, step: 4, value: 0,
-      fmt: function (v) { return String(v); }, onChange: function (v) { offsetPx = v; reseatAll(); },
-      place: { x: 0.02, y: 0.03 } },
-    { kind: 'scalar', id: 'angle', label: 'angle', min: 0, max: 1, step: 0.1, value: 0,
-      fmt: function (v) { return v.toFixed(1); }, onChange: function (v) { angleVy = v; reseatAll(); },
-      place: { x: 0.02, y: 0.12 } }
-  ]);
-  // Chrome (a page only): expose the knobs to a host frame, and mount the overlay through the
-  // runner's ONE door (runner.controlHost) — before a canvas is mounted (a notebook pane) there is
-  // none, so the knobs stay in the exposed registry only.
-  FrqtlControlsPanel.exposeRegistry(registry, { runner: exp.runner });
-  if (exp.runner.controlHost) { FrqtlControlOverlay.mount(exp.runner, { registry: registry, name: 'collision-matrix-3d' }); }
-  if (typeof document !== 'undefined') {
-    if (exp.runner.controlHost) { CameraControls.attach(exp.runner, exp.runner.controlHost); }
-  }
-}

package/dist/frqtl/scenes/counting-wall-3d.js

@@ -1,40 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — 1C · Counting Wall (3D)
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world
- * (its co-init call, `exp.createCanvas` / `exp.createScene` — the one place its size is written),
- * the parts (`export const parts` + `exp.declare`, or `exp.addObject`) and the render intent are all here; the sugar
- * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
- * (rung cl1c-counting-wall-3d).
- */
-
-import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
-
-// Collision Lab 1C · 3D — a volumetric source into a 3D Detector Screen slab
-// (destroy+count) + a LIVE in-scene chart, textured in three; orbit to view.
-const W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-const cy = Math.round(H / 2);
-
-export const parts = {
-  source: [SphereEmitter, {
-    preset: 'spherical', is2D: false, center: [Math.round(W * 0.15), cy],
-    chargeMode: 'random', fundamentalDimension: 2, wavelength: 32,
-    burstSize: 24, emitEveryTicks: 1
-  }],
-  screen: [Wall, {
-    rect: [Math.round(W * 0.6), 0, 20, H], z: -80, depth: 160,
-    preset: 'detector-screen', color: [120, 200, 120]
-  }],
-};
-
-export default function buildExperiment(exp) {
-  exp.createScene(W, H, 600, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
-  const p = exp.declare(parts);
-  exp.addObject('LiveChart', {
-    source: p.screen,
-    rect: [Math.round(W * 0.66), Math.round(H * 0.08), Math.round(W * 0.28), Math.round(H * 0.5)],
-    series: 'bar', label: 'arrivals by y', refreshMs: 100, color: [24, 32, 46]
-  });
-}

package/dist/frqtl/scenes/counting-wall.js

@@ -1,42 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — 1C · Counting Wall
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world
- * (its co-init call, `exp.createCanvas` / `exp.createScene` — the one place its size is written),
- * the parts (`export const parts` + `exp.declare`, or `exp.addObject`) and the render intent are all here; the sugar
- * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
- * (rung cl1c-counting-wall).
- */
-
-import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
-
-// Collision Lab 1C (Counting Wall) — the Detector Screen preset (destroy + count),
-// with a LIVE in-scene LiveChart of the running y-histogram placed beside it.
-const W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-const cy = Math.round(H / 2);
-
-export const parts = {
-  source: [SphereEmitter, {
-    preset: 'spherical', is2D: true, center: [Math.round(W * 0.15), cy],
-    chargeMode: 'random', fundamentalDimension: 2, wavelength: 32,
-    burstSize: 24, emitEveryTicks: 1
-  }],
-  screen: [Wall, {
-    rect: [Math.round(W * 0.6), 0, 20, H],
-    preset: 'detector-screen', color: [120, 200, 120]
-  }],
-};
-
-export default function buildExperiment(exp) {
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
-  const p = exp.declare(parts);
-  // The interactive counting demo: a live chart of the detector's histogram,
-  // placed to the RIGHT of the screen (past where the quanta are absorbed).
-  exp.addObject('LiveChart', {
-    source: p.screen,
-    rect: [Math.round(W * 0.66), Math.round(H * 0.08), Math.round(W * 0.28), Math.round(H * 0.5)],
-    series: 'bar', label: 'arrivals by y', refreshMs: 100, color: [24, 32, 46]
-  });
-}

package/dist/frqtl/scenes/double-slit.js

@@ -1,34 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — Double slit (the SDK's artifact page)
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world (its
- * co-init call, `exp.createCanvas` — the one place its size is written), the parts and their order
- * are all here; the sugar (SlitScreen, SlitLightSource, DetectorWall, LargeObject), the renderer
- * and the engine are imports. Shipped as `dist/artifact/double-slit.html`: the generator
- * (lib/shim/engine/artifact-shell.js, ARTIFACT_SCENE) embeds THIS file's text verbatim.
- *
- * The parts are setupDoubleSlit's at its defaults (slit screen at 1.5 λ, an absorbing start wall,
- * the slit light source at a 10° step, the detector 3 λ past the screen), so the seeded run is
- * that factory's, tick for tick (lib/shim/engine/test/artifact-shell-sketch.test.mjs holds it on
- * the WASM engine). Zero new physics.
- */
-
-import { CollisionTypes, DetectorWall, LargeObject, SlitLightSource, SlitScreen } from '@descix/frqtl-web/parts';
-
-export const parts = {};
-
-export default function buildExperiment(exp) {
-  var S = 480, WAVELENGTH = 64;   // THE WORLD this scene states (its co-init call below) and its one geometry knob
-
-  exp.createCanvas(S, S, { dimension: 2, wavelengthScale: Math.floor(WAVELENGTH / 16) });   // a 2D canvas + universe, S x S
-  exp.declare(parts);
-  var u = exp.universe;
-
-  var slits = new SlitScreen(u, WAVELENGTH * 1.5, WAVELENGTH, S, WAVELENGTH, true, 1);
-  new LargeObject(u, [0, 0, 10, S], CollisionTypes.ABSORB, [], 'start_wall', 'closest', null, 1, [120, 120, 120]);
-  var light = new SlitLightSource(u, slits, 10);
-  new DetectorWall(u, u.universe_rect, slits.wall1.rect.left + slits.wall1.rect.w + 3 * WAVELENGTH);
-  u.experimentTickFunctions.push(light.getTickFunction());
-}

package/dist/frqtl/scenes/dse-one-emitter.js

@@ -1,200 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — One Emitter at the Canonical Leg
- *
- * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world
- * (its co-init call, `exp.createCanvas` / `exp.createScene` — the one place its size is written),
- * the parts (`export const parts` + `exp.declare`, or `exp.addObject`) and the render intent are all here; the sugar
- * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
- * (rung dse-one-emitter).
- */
-
-// ── H1 AT THE CANONICAL DETECTOR LEG ─────────────────────────────────────────
-//
-// The competence baseline: the most basic thing, done right, seen with eyes. One
-// emitter, then two, with the plate PRE-COMPUTED at the leg the ring formula was
-// written for and the count-by-y chart registered to that plate. No barrier, no
-// slits, no tunnels — nothing between the source and the plate, so a band on the
-// chart can have come from nothing but the walk.
-//
-// WHY THESE EXIST BESIDE `dse-tunnel-rebuild`. That rung places its plate at
-// D = 155 px against λ_eff = 128 px — 4.84× the reference leg — which pushes the
-// low orders inside the leg where they never reach the plate at all, so only high-m
-// rings can land. These two rungs put the plate ON the reference leg instead.
-//
-// THE GEOMETRY, and it is not re-derived here. λ is the ONLY length; every other
-// length below is a dimensionless constant × λ (the `published/dse/scene.js`
-// discipline). The ring ladder quoted in CLAUDE.md,
-//
-//     r_m = (λ/4)·√((2m+1)² + 1)                       [slant, from the emission point]
-//
-// is the hypotenuse of a right triangle whose TRANSVERSE leg is ρ_m = (2m+1)·λ/4
-// and whose AXIAL leg is λ/4 — the "+1" under the root IS the (λ/4)² axial term.
-// Solve for the axial leg order by order and every order returns λ/4, so the leg is
-// not fitted per-order: it is the one leg the formula was written for. At that leg
-// the on-plate bands are ρ_m = (2m+1)·λ/4 from the source's own y, spacing λ/2.
-//
-// MEASURED, not assumed. `published/dse/h1/` ran exactly this apparatus (bare
-// source, plate at D = λ/4 from the emitter, seed 1, detector 'hits') at λ = 160 /
-// 320 / 640 and found a symmetric feature on the plate at |Δy| = λ/4 − 4 px — 36 /
-// 76 / 156 px — holding that offset to the pixel across a 4× sweep while moving 120
-// px in absolute terms. The raw histogram's shape is: a flat PLATEAU across the
-// centre, a sharp MINIMUM just inside ±λ/4, and a PEAK riding immediately outside it
-// at ±λ/4. At λ=640, counts by Δy/λ: −0.250 → 1107 | −0.225 → 306 | 0.000 → 1011 |
-// +0.225 → 297 | +0.250 → 1125. At λ=320 the same shape, shallower. TWO points on
-// the wall at ¼ λ_eff, with a plateau — not a hole — between them.
-//
-// AND THAT IS WHY λ IS 320 HERE. The dip-to-peak separation is 0.025λ: 16 px at
-// λ=640, 8 px at λ=320, 4 px at λ=160 — which is why the λ=160 run reads as a broad
-// hump with the feature only recoverable by a windowed search on a smoothed profile.
-// Below ~λ=300 this stage cannot resolve the thing it exists to show. So this rung
-// shows ONE well-resolved band pair per source rather than three mushy ones. The 4 px
-// pedestal does NOT scale with λ (it is engine scale — a quantum steps ≤2 px/axis/
-// tick) and no mechanism is offered for it here. The m ≥ 1 rungs of the ladder are
-// NOT established: of the H1 runs' 8 predicted positions, 3 matched, and the m=1
-// positions carried minima.
-//
-// THE LEG IS ONE NAMED CONSTANT (`legFrac`), and so is the plate's DETECTOR MODE —
-// both so they can be moved deliberately from a one-line edit and the consequence
-// re-derived, rather than being literals nobody chose.
-//
-// The beam is the `dse-tunnel-rebuild` beam and the H1 beam, unchanged: wavelength
-// arg 3.2 → mass 5 / capacity 16 → fullness 0.3125, which LightColor renders yellow,
-// and λ_eff = 3.2 × wavelengthScale. The leaves are emitted COLOURLESS; the colour
-// is DERIVED from fullness, never forced.
-//
-// 2D ONLY, deliberately. There is no `modes` strip and no `exp.is3D` guard: these
-// rungs declare one world each. A second dimensional variant would be a separate
-// recipe declaration, not a mode.
-// THE PAIR. `dse-two-emitters.js` is the SAME apparatus with TWO source entries. The two files differ ONLY in the
-// title lines, this note, and their `source*` entries of `parts` (with the world call naming the first
-// of them) — lib/frqtl/scenes/test/scene-files.test.mjs fails if anything else diverges, so the A/B the
-// pair exists to make stays an A/B.
-
-import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
-
-const CW = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-// ── THE ONLY LENGTH ─────────────────────────────────────────────────────
-// lamPx is lambda_eff in pixels. 320 is chosen for RESOLUTION, not for how many
-// orders fit: the feature this rung exists to show (the minimum just inside the
-// band and the peak riding outside it) is 0.025*lambda wide, which is 8 px at
-// lambda 320 and 3 px at lambda 128. A stage that cannot separate them shows a
-// smooth hump and leaves you unable to say whether the physics or the sampling
-// was at fault. One well-resolved pair beats three mushy ones.
-const lamPx  = 320;
-const sinkW = Math.round(lamPx / 16);     // 20  — far-edge sink thickness
-
-// ── THE DETECTOR LEG — ONE NAMED CONSTANT ───────────────────────────────
-// D = legFrac * lambda, measured from the SOURCE (there is no barrier, so the
-// emitter itself is the reference point of the ladder). legFrac = 1/4 is the
-// leg the ring formula was written for; see the block comment above.
-const legFrac = 1 / 4;
-const D    = Math.round(lamPx * legFrac); // 80
-const srcX = Math.round(lamPx / 16);      // 20 — launch room; the canvas edge is the back sink
-const detX = srcX + D;                    // 100 — the plate's FRONT FACE
-// PLATE THICKNESS IS AN OPTICAL CHOICE UNDER A FLUX DETECTOR, not trim. A flux
-// probe counts every tick a quantum overlaps it, so it integrates the density
-// ACROSS its thickness — and the ring crest is a CIRCLE about the source, not a
-// plane. At the m=0 band the crest's slope is dy/dx = -D/y = -1, so a slab t px
-// thick smears the band over ~t px of y. Against an 8 px feature a lambda/8 (40
-// px) plate would guarantee mush. lambda/64 = 5 px keeps the smear sub-feature
-// and is still unjumpable (a quantum steps at most 2 px/axis/tick). A 'hits'
-// plate would not care — it counts at first contact, i.e. at the front face —
-// which is exactly why the reference H1 runs could afford a lambda/8 slab.
-const detW = Math.round(lamPx / 64);      // 5   — plate thickness
-// ── THE PLATE — A COUNTING WALL THAT DOES NOT ABSORB ────────────────────
-// ONE NAMED CONSTANT, so the reading can be swapped in a single edit and the two
-// instruments compared rather than argued about:
-//   'transparent-probe' = collisionBehavior 'nothing' + mark/count. FLUX. The
-//       quantum is counted on every tick it overlaps the plate and then flies on,
-//       so the reading is the OCCUPANCY INTEGRAL at the plate plane — the density
-//       at that plane. This is the shipped choice.
-//   'detector-screen'   = destroy + count. HITS. Each quantum is counted once, at
-//       arrival, and removed: a transit census, the headcount a photographic plate
-//       would report. It is what the H1 reference runs used.
-// NEITHER ABSORBS. 'absorb' stores the arriving mass and re-radiates it — that is
-// the photoelectric experiment, and it saturates.
-const detectorPreset = 'transparent-probe';
-
-const lamArg = 3.2;                       // capacity/mass -> fullness 1/3.2 = 0.3125 (yellow)
-const fwl    = 4 * (lamPx / lamArg);      // 400 -> wavelengthScale floor(400/4) = 100
-const wlScale = Math.floor(fwl / 4);      // 100
-const cy   = Math.round(H / 2);           // 200 — the source plane's midline
-// TWO-SOURCE SEPARATION. Two sources reinforce when their separation is a
-// multiple of lambda/2, and the coupling falls as (lambda/d)^2, so lambda/2 is
-// the strongest case. At this leg it also puts a band of EACH source on the
-// midline y = H/2 (source 1's lower band and source 2's upper band coincide
-// there) — the doubly-reinforced central peak, equidistant from both emitters,
-// exactly where the one-source rung has no peak at all.
-const sep  = lamPx / 2;                   // 160 -> sources at y 120 and 280
-// ── THE LIGHT SOURCE ────────────────────────────────────────────────────
-// preset 'hemisphere' = 180 degrees of FORWARD (+X) emission: the SAME
-// ball-rejected sampler as the omni source with the forward axis' range halved,
-// so nothing about the walk changes, it is simply pointed at the plate. The
-// default emission box is 0 for this preset, so the source is a single PIXEL —
-// load-bearing, because any spread at birth blurs every band by that spread.
-// NO START WALL: the backward population is empty by construction, and `wrap` is
-// false, so the canvas edge kills whatever transverse wiggle out-runs its
-// forward component. One sink, not two.
-const SRC = {
-  preset: 'hemisphere', is2D: true, chargeMode: 'random',
-  wavelength: lamArg, fundamentalDimension: 2, fundamentalWaveLength: fwl,
-  burstSize: 8, emitEveryTicks: 1
-};
-
-export const parts = {
-  source: [SphereEmitter, { ...SRC, center: [srcX, cy] }],
-  // FAR-EDGE SINK. The plate below counts WITHOUT removing, so quanta fly on past
-  // it; this is the experiment-boundary sink downstream of the plate. It is not
-  // load-bearing (wrap is false, so the canvas edge would remove them anyway) — it
-  // is where the population bound is STATED rather than inferred.
-  far_sink: [Wall, { rect: [CW - sinkW, 0, sinkW, H], collisionBehavior: 'destroy',
-    color: [120, 120, 120], alpha: 40 }],
-  // markTag — the plate's PROVENANCE stamp. The mark hook fires ONLY when the
-  // collision trigger does (genuine overlap), whereas the engine buffers every
-  // frame inside the LO's mb_w-PADDED search rect whether it triggered or not. So a
-  // raw frame count off the buffer is a padded-occupancy reading and the
-  // mark-filtered count is the trigger-gated census: two different instruments, and
-  // an offline reader needs the tag to tell them apart.
-  screen: [Wall, { rect: [detX, 0, detW, H],
-    preset: detectorPreset, markTag: 'plate', color: [120, 200, 120] }],
-};
-
-export default function buildExperiment(exp) {
-  if (Math.abs(lamArg * wlScale - lamPx) > 1e-9) {
-    throw new Error('[dse-h1] lamPx ' + lamPx + ' is not realisable as lambda_eff: the engine ' +
-      'can only produce wavelengthArg x floor(fwl/4) = ' + (lamArg * wlScale) + '. (FAIL-LOUD.)');
-  }
-  exp.createCanvas(CW, H, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
-  const p = exp.declare(parts);
-  // ── THE INSTRUMENT — the live count-by-y histogram, REGISTERED TO THE PLATE ──
-  // The panel takes the plate's OWN rect y-origin (0) and height (H), so the two
-  // are co-extensive on the bin axis at any canvas size, and it starts just past
-  // the plate's far face so it reads as sitting behind it. orientation 90 = bars
-  // stacked along y; the chart contract reverses the y scale when horizontal, so
-  // bin 0 (the SMALLEST y) sits at the TOP, matching the y-DOWN world.
-  // HONEST LIMIT (inherited from the shipped 2D block, and it is real): the bin
-  // axis is a CATEGORY axis over the bins that actually received hits, not a linear
-  // 0..H axis. Registration is exact in ORDER and DIRECTION always, and exact in
-  // absolute screen height only insofar as the hits span the wall. Here the plate
-  // is a full-height flux probe under a 180-degree source, so the occupied span
-  // fills the wall within a few hundred ticks and the axis is very nearly linear —
-  // but the ladder positions below must be read off the raw census, never measured
-  // with a ruler on the panel.
-  // SERIES 'line', NOT 'bar', AND THAT IS A MEASUREMENT NOT A TASTE. The bins are
-  // per-pixel y, so a full-height plate produces ~400 categories in a ~240 px plot:
-  // each bar is sub-pixel TALL, its 0.55 fill alpha is diluted by the coverage, and
-  // the profile collapses into a faint sliver hugging the axis. Measured identically
-  // on the shipped 1C Counting Wall rung, so it is the chart contract's behaviour at
-  // this bin count and not something these rungs introduced. A line joins the same 400
-  // points into one continuous curve, which reads as the profile it is. CAVEAT, stated
-  // because it bites: Chart.js does not begin a LINE value axis at zero, so once the
-  // profile's floor rises the curve compresses toward the left edge. Read positions off
-  // it, not magnitudes; magnitudes come from getCollisionHistogram().
-  exp.addObject('LiveChart', {
-    source: p.screen, orientation: 90,
-    rect: [detX + detW + 8, 0, Math.max(60, CW - (detX + detW + 8) - 8), H],
-    series: 'line', label: 'count by y', refreshMs: 100, color: [24, 32, 46], alpha: 225
-  });
-}