@descix/frqtl-node 0.6.0-p0.2 → 0.6.0-p1.1

package/dist/frqtl/scenes/dse-tunnel-rebuild.js

@@ -5,7 +5,7 @@
  *
  * 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 (`exp.addObject`) and the render intent are all here; the sugar
+ * 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-tunnel-rebuild).
  */
@@ -13,7 +13,7 @@
 // The double slit built on the TUNNEL OBJECT at physical DSE proportions. The two
 // slit channels are Tunnels — TWO parallel MIRROR walls (guarded bounce, zero leak) — so
 // the slit reflects the beam; the barriers + screen are v2 Walls (destroy / detector-screen
-// preset) so the scene round-trips through codegen on Restart. GEOMETRY: SYMMETRIC —
+// preset), declared in `parts` so a hand edit is a code edit. GEOMETRY: SYMMETRIC —
 // emitter->front of the slit wall equals back of the slit wall->detector. The near-field
 // result is a balanced, central-dominant three-lobe double-slit interference pattern (a
 // stochastic near-field walk; the ray-optics λL/d Fraunhofer regime needs L >> d²/λ ≈ 580px,
@@ -21,8 +21,9 @@
 //
 // ONE MODE-AWARE SOURCE (S3/W2). The mode strip
 // selects the RENDERER the host boots (renderState.renderer), and this scene reads it ONCE,
-// before its world: `three` ⇒ exp.createScene (a 3D world), else exp.createCanvas (2D). `IS3D`
-// then guards the dimensional deltas — there is NO second (`-3d`) source file:
+// before its world: `three` ⇒ exp.createScene (a 3D world), else exp.createCanvas (2D).
+// `parts` is written in the DEFAULT mode, 3D; in 2D the scene declares flat2D(parts), the
+// scene's own statement of its 2D delta — there is NO second (`-3d`) source file:
 //   * the emitter opens the z-axis   (is2D:!IS3D → activeAxes.z, a 3D ball of directions);
 //   * every barrier / tunnel / detector gains the SAME z-slab (z/depth → a 6-element rect),
 //     so the slit wall is a real SLOT-in-a-PLATE and what you SEE is what collides;
@@ -40,108 +41,98 @@
 // (= mass/capacity = 1/wavelength). See the emitter block in the source for the two
 // independent dials (band vs pixel wavelength) and why the fringe geometry is unchanged.
 
-import { CameraControls, FrqtlControlOverlay, FrqtlControlsPanel, SphereEmitter } from '@descix/frqtl-web/parts';
+import { CameraControls, FrqtlControlOverlay, FrqtlControlsPanel, GraphingDetectorWall, SphereEmitter, Tunnel, Wall } from '@descix/frqtl-web/parts';
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 import * as FrqtlDisplay from '@descix/frqtl-web/compat/renderer/display-slot.js';
 import * as SunLook from '@descix/frqtl-web/shim/render/sun-look.js';
 
-export default function buildExperiment(exp) {
-  // Double Slit (Tunnel) — the two slit channels are MIRROR TUNNELS (guarded
-  // bounce, zero-leak); the detector sits at the SYMMETRIC distance (emitter->front ==
-  // back->detector). X placements are wl-derived (canvas-width-independent); Y is
-  // centered on H (groupCenterY = H/2).
-  // The booted display (the host's renderState.renderer) decides which world this mode makes.
-  var IS3D = FrqtlDisplay.name() === 'three';
-  var CW = 600, H = 400, WORLD_D = 600;   // THE WORLD this scene states (its co-init call below)
-  // GEOMETRY and WAVELENGTH are two INDEPENDENT dials, and they are kept apart on
-  // purpose: `wl` sizes the PLATE (slit height, gap, wall placement) and nothing else,
-  // while `lamPx` is the transverse wavelength in pixels. Doubling lambda must NOT move
-  // the slit wall — if one variable drove both, the aperture would silently walk every
-  // time the beam was re-tuned and no two runs would be comparable.
-  var wl = 64, sh = Math.floor(wl * 0.8), gap = Math.floor(wl * 0.8);   // 51, 51
-  var lamPx = 128;                          // the TRANSVERSE wavelength, in pixels
-  var groupH = sh + gap + sh;               // 153
-  var gcY = H / 2;                          // 300 @ H=600
-  var s1Top = gcY - groupH / 2;             // 223.5
-  var gapTop = s1Top + sh;                  // 274.5
-  var s2Bot = gcY + groupH / 2;             // 376.5
-  var s2Top = s2Bot - sh;                   // 325.5
-  var srcX = 20;                            // source x (left, near the slit wall)
-  var L = wl * 1.5, W = wl;                 // slit-group left 96, width 64 (wall front..back = [96,160])
-  // THE DETECTOR LEG, DERIVED FROM THE RING LADDER (zero free parameters).
-  // A phase-locked POINT source lays down density rings at r_m = (lambda/4)*sqrt((2m+1)^2+1)
-  // measured from the emission point (guide row r3-radius-stall-shells). Each slit exit below
-  // IS such a source, so the plate should be placed where
-  // a NAMED ring crosses it rather than at a symmetric figure. Put the MIDLINE on ring m=2
-  // of BOTH slits: with the exits at +/-halfSep from the midline, that needs a leg of
-  //     D = sqrt(r_2^2 - halfSep^2) = sqrt(163.2^2 - 51^2) = 155
-  // so the two ring-2 circles intersect exactly on the axis and the centre is DOUBLY
-  // reinforced. Rings inside D (m=0 at 45.3, m=1 at 101.2) never reach the plate and
-  // contribute no band — a measured property of the ladder, not an assumption.
-  // This REPLACES the old symmetric-leg figure, whose own comment made it conditional on
-  // the slits becoming directed emitters; the exit gates below are that condition.
-  var ringR = function (m) { return (lamPx / 4) * Math.sqrt((2 * m + 1) * (2 * m + 1) + 1); };
-  var slitCY1 = s1Top + sh / 2, slitCY2 = s2Top + sh / 2;   // 249, 351 — the bore midlines
-  var halfSep = gcY - slitCY1;              // 51
-  var detW = 20;                            // the detector plate's own thickness
-  var D = Math.round(Math.sqrt(ringR(2) * ringR(2) - halfSep * halfSep));   // 155
-  var detX = (L + W) + D;                   // 315
-  var linerH = Math.min(10, Math.floor(sh * 0.2)), bore = sh - 2 * linerH;   // 10, 31
-  // THE 3D DELTA, in ONE place: the plate z-band. Every barrier / tunnel liner / detector
-  // carries the SAME z-slab, so the slit wall is a genuine SLOT IN A PLATE standing in
-  // space (the slits are slots long in z — the 2D figure extruded). In 2D the bag is
-  // EMPTY, so every Object.assign below is byte-identical to the flat scene.
-  var zHalf = Math.round(groupH / 2);                                   // 77 @ wl 64
-  var Z3 = IS3D ? { z: -zHalf, depth: 2 * zHalf } : {};
-  // THE BEAM'S COLOUR — its own frequency band, never a forced recolor. The emitter
-  // emits COLOURLESS leaves (no renderColor arg ⇒ no string_map['render.color']), so the
-  // renderer derives the colour from the ONE authority, LightColor, at the leaf's
-  // fullness. TWO INDEPENDENT dials produce it, both on the emitter:
-  //   fullness  = mass/capacity = 1 / wavelength      -> the spectral BAND (LightColor)
-  //   lambda_px = wavelength x wavelengthScale        -> the transverse wave, in PIXELS
-  // (wavelengthScale = floor(fundamentalWaveLength / 4)). So the band is chosen by
-  // scaling fundamentalWaveLength INVERSELY with the wavelength arg — lambda_px (the
-  // fringe geometry) is untouched. 1/3.2 = 0.3125 sits in the YELLOW band; the rung's
-  // renderState declares the spectrally correct 'roygbiv' ramp, so the beam renders
-  // [255,243,0]. lambda_px = 3.2 x 40 = 128, INDEPENDENT of the 64-derived plate.
-  // THIS BEAM IS LIGHT, so the band is free: these leaves are born AT the universe's
-  // fundamental dimension (leafDimension == fundamentalDimension == 2), and a leaf at the
-  // fundamental ALWAYS steps, P=1, whatever its fullness (bench M1) — the fullness
-  // move-gate (bench M2) simply does not apply, and P=1 draws no RNG. Measured on the
-  // live detector: the fringe histogram is bin-for-bin the SAME as the (64, 16) tuple
-  // (t=30s, 16px profile: 11260 vs 11262 hits, every bin within 1, COM 201.7 both).
-  var lamArg = 3.2;                         // fullness 1/3.2 = 0.3125 -> yellow
-  var fwl    = 4 * (lamPx / lamArg);        // 160 -> wavelengthScale 40 -> lambda_px = 128
-  // The light source — the current SphereEmitter sugar (braided walk), placed at the
-  // original source pixel (srcX, gap-center = H/2).
-  // is2D:!IS3D opens activeAxes.z — the ball-rejected sampler then draws a 3D BALL of
-  // directions (bench S1/S5) instead of the 2D disk.
-  // preset 'hemisphere' = 180 degrees of FORWARD emission (D1): the SAME ball-rejected
-  // sampler with the forward axis' range halved to [0,R], i.e. the spherical distribution
-  // RESTRICTED to the forward half — same physics, pointed one way, so nothing about the
-  // walk changes. Forward is +X, which is where the slit wall stands (orientationDeg stays
-  // 0), so the half of the burst that used to fly LEFT into the back-scatter sink now goes
-  // toward the slits: the same burst size illuminates the aperture roughly twice as hard.
-  var SRC = {
-    preset: 'hemisphere', is2D: !IS3D, center: [srcX, Math.round(gcY)],
+const CW = 600, H = 400, WORLD_D = 600;   // THE WORLD this scene states (its co-init call below)
+// GEOMETRY and WAVELENGTH are two INDEPENDENT dials, and they are kept apart on
+// purpose: `wl` sizes the PLATE (slit height, gap, wall placement) and nothing else,
+// while `lamPx` is the transverse wavelength in pixels. Doubling lambda must NOT move
+// the slit wall — if one variable drove both, the aperture would silently walk every
+// time the beam was re-tuned and no two runs would be comparable.
+const wl = 64, sh = Math.floor(wl * 0.8), gap = Math.floor(wl * 0.8);   // 51, 51
+const lamPx = 128;                          // the TRANSVERSE wavelength, in pixels
+const groupH = sh + gap + sh;               // 153
+const gcY = H / 2;                          // 300 @ H=600
+const s1Top = gcY - groupH / 2;             // 223.5
+const gapTop = s1Top + sh;                  // 274.5
+const s2Bot = gcY + groupH / 2;             // 376.5
+const s2Top = s2Bot - sh;                   // 325.5
+const srcX = 20;                            // source x (left, near the slit wall)
+const L = wl * 1.5, W = wl;                 // slit-group left 96, width 64 (wall front..back = [96,160])
+// THE DETECTOR LEG, DERIVED FROM THE RING LADDER (zero free parameters).
+// A phase-locked POINT source lays down density rings at r_m = (lambda/4)*sqrt((2m+1)^2+1)
+// measured from the emission point (guide row r3-radius-stall-shells). Each slit exit below
+// IS such a source, so the plate should be placed where
+// a NAMED ring crosses it rather than at a symmetric figure. Put the MIDLINE on ring m=2
+// of BOTH slits: with the exits at +/-halfSep from the midline, that needs a leg of
+//     D = sqrt(r_2^2 - halfSep^2) = sqrt(163.2^2 - 51^2) = 155
+// so the two ring-2 circles intersect exactly on the axis and the centre is DOUBLY
+// reinforced. Rings inside D (m=0 at 45.3, m=1 at 101.2) never reach the plate and
+// contribute no band — a measured property of the ladder, not an assumption.
+// This REPLACES the old symmetric-leg figure, whose own comment made it conditional on
+// the slits becoming directed emitters; the exit gates below are that condition.
+const ringR = function (m) { return (lamPx / 4) * Math.sqrt((2 * m + 1) * (2 * m + 1) + 1); };
+const slitCY1 = s1Top + sh / 2, slitCY2 = s2Top + sh / 2;   // 249, 351 — the bore midlines
+const halfSep = gcY - slitCY1;              // 51
+const detW = 20;                            // the detector plate's own thickness
+const D = Math.round(Math.sqrt(ringR(2) * ringR(2) - halfSep * halfSep));   // 155
+const detX = (L + W) + D;                   // 315
+const linerH = Math.min(10, Math.floor(sh * 0.2)), bore = sh - 2 * linerH;   // 10, 31
+// THE 3D DELTA: the plate z-band. Every barrier / tunnel liner / detector in `parts`
+// carries the SAME z-slab (z: -zHalf, depth: 2 * zHalf), so the slit wall is a genuine SLOT
+// IN A PLATE standing in space (the slits are slots long in z — the 2D figure extruded).
+// flat2D (below) deletes the slab, so the 2D scene is the flat figure.
+const zHalf = Math.round(groupH / 2);                                   // 77 @ wl 64
+// THE BEAM'S COLOUR — its own frequency band, never a forced recolor. The emitter
+// emits COLOURLESS leaves (no renderColor arg ⇒ no string_map['render.color']), so the
+// renderer derives the colour from the ONE authority, LightColor, at the leaf's
+// fullness. TWO INDEPENDENT dials produce it, both on the emitter:
+//   fullness  = mass/capacity = 1 / wavelength      -> the spectral BAND (LightColor)
+//   lambda_px = wavelength x wavelengthScale        -> the transverse wave, in PIXELS
+// (wavelengthScale = floor(fundamentalWaveLength / 4)). So the band is chosen by
+// scaling fundamentalWaveLength INVERSELY with the wavelength arg — lambda_px (the
+// fringe geometry) is untouched. 1/3.2 = 0.3125 sits in the YELLOW band; the rung's
+// renderState declares the spectrally correct 'roygbiv' ramp, so the beam renders
+// [255,243,0]. lambda_px = 3.2 x 40 = 128, INDEPENDENT of the 64-derived plate.
+// THIS BEAM IS LIGHT, so the band is free: these leaves are born AT the universe's
+// fundamental dimension (leafDimension == fundamentalDimension == 2), and a leaf at the
+// fundamental ALWAYS steps, P=1, whatever its fullness (bench M1) — the fullness
+// move-gate (bench M2) simply does not apply, and P=1 draws no RNG. Measured on the
+// live detector: the fringe histogram is bin-for-bin the SAME as the (64, 16) tuple
+// (t=30s, 16px profile: 11260 vs 11262 hits, every bin within 1, COM 201.7 both).
+const lamArg = 3.2;                         // fullness 1/3.2 = 0.3125 -> yellow
+const fwl    = 4 * (lamPx / lamArg);        // 160 -> wavelengthScale 40 -> lambda_px = 128
+
+// The light source — the current SphereEmitter sugar (braided walk), placed at the
+// original source pixel (srcX, gap-center = H/2).
+// is2D:!IS3D opens activeAxes.z — the ball-rejected sampler then draws a 3D BALL of
+// directions (bench S1/S5) instead of the 2D disk.
+// preset 'hemisphere' = 180 degrees of FORWARD emission (D1): the SAME ball-rejected
+// sampler with the forward axis' range halved to [0,R], i.e. the spherical distribution
+// RESTRICTED to the forward half — same physics, pointed one way, so nothing about the
+// walk changes. Forward is +X, which is where the slit wall stands (orientationDeg stays
+// 0), so the half of the burst that used to fly LEFT into the back-scatter sink now goes
+// toward the slits: the same burst size illuminates the aperture roughly twice as hard.
+export const parts = {
+  source: [SphereEmitter, {
+    preset: 'hemisphere', is2D: false, center: [srcX, Math.round(gcY)],
     chargeMode: 'random', wavelength: lamArg, burstSize: 8, emitEveryTicks: 1,
     fundamentalDimension: 2, fundamentalWaveLength: fwl
-  };
-  // THE WORLD — first, then parts: a 3D scene + universe (600x400x600) or a 2D canvas + universe.
-  if (IS3D) { exp.createScene(CW, H, WORLD_D, SphereEmitter.worldCfg(SRC)); }
-  else      { exp.createCanvas(CW, H, SphereEmitter.worldCfg(SRC)); }
-  exp.addObject('SphereEmitter', SRC);
+  }],
   // Start wall — a plain sink (collisionBehavior:'destroy', [set is_alive=0]) at the
   // left edge, catching back-scatter. It is TRANSPARENT (alpha 40 of 255): the default
   // camera stands BEHIND the emitter, so an opaque slab here would be the first thing in
-  // frame and would hide the whole experiment. alpha is a DECLARED Wall field, so codegen
-  // captures it and Restart rebuilds the wall just as sheer. Physics is untouched — the
+  // frame and would hide the whole experiment. alpha is a DECLARED Wall field, so the parts block
+  // carries it and Restart rebuilds the wall just as sheer. Physics is untouched — the
   // sink still destroys every back-scattered quantum (render-only, SU1).
-  exp.addObject('Wall', Object.assign({ rect: [0, 0, 10, H] }, Z3, { collisionBehavior: 'destroy', name: 'start_wall', color: [120, 120, 120], alpha: 40 }));
+  start_wall: [Wall, { rect: [0, 0, 10, H], z: -zHalf, depth: 2 * zHalf, collisionBehavior: 'destroy', color: [120, 120, 120], alpha: 40 }],
   // Barrier segments — opaque plain sinks (destroy) leaving the two slit gaps.
-  exp.addObject('Wall', Object.assign({ rect: [L, 0, W, s1Top - 1] }, Z3, { collisionBehavior: 'destroy', name: 'wall1', color: [200, 60, 60] }));
-  exp.addObject('Wall', Object.assign({ rect: [L, gapTop, W, gap - 1] }, Z3, { collisionBehavior: 'destroy', name: 'wall2', color: [150, 40, 40] }));
-  exp.addObject('Wall', Object.assign({ rect: [L, s2Bot, W, (H - s2Bot) - 1] }, Z3, { collisionBehavior: 'destroy', name: 'wall3', color: [200, 60, 60] }));
+  wall1: [Wall, { rect: [L, 0, W, s1Top - 1], z: -zHalf, depth: 2 * zHalf, collisionBehavior: 'destroy', color: [200, 60, 60] }],
+  wall2: [Wall, { rect: [L, gapTop, W, gap - 1], z: -zHalf, depth: 2 * zHalf, collisionBehavior: 'destroy', color: [150, 40, 40] }],
+  wall3: [Wall, { rect: [L, s2Bot, W, (H - s2Bot) - 1], z: -zHalf, depth: 2 * zHalf, collisionBehavior: 'destroy', color: [200, 60, 60] }],
   // The two slit channels as TUNNELS — walls land at the EXACT original liner positions
   // ([L,s1Top,W,10] & [L,s1Top+sh-10,W,10]); the bore is the clear aperture between them.
   // The Tunnel ferries z/depth onto BOTH walls, so a 3D channel is a real corridor.
@@ -168,8 +159,8 @@ export default function buildExperiment(exp) {
   // Unifying this with the SphereEmitter preset vocabulary (one owner, ferried — never a
   // second preset list) is an open contract design;
   // this rung uses the existing flags and documents the mapping.
-  exp.addObject('Tunnel', Object.assign({ left: L, top: s1Top + linerH, length: W, bore: bore, wallThickness: linerH, axis: 'x' }, Z3, { mode: 'directed', exitCollapse: true, exitRecenter: true, exitPhaseReset: true, name: 'slit1_channel', color: [80, 140, 220] }));
-  exp.addObject('Tunnel', Object.assign({ left: L, top: s2Top + linerH, length: W, bore: bore, wallThickness: linerH, axis: 'x' }, Z3, { mode: 'directed', exitCollapse: true, exitRecenter: true, exitPhaseReset: true, name: 'slit2_channel', color: [80, 140, 220] }));
+  slit1_channel: [Tunnel, { left: L, top: s1Top + linerH, length: W, bore: bore, wallThickness: linerH, axis: 'x', z: -zHalf, depth: 2 * zHalf, mode: 'directed', exitCollapse: true, exitRecenter: true, exitPhaseReset: true, color: [80, 140, 220] }],
+  slit2_channel: [Tunnel, { left: L, top: s2Top + linerH, length: W, bore: bore, wallThickness: linerH, axis: 'x', z: -zHalf, depth: 2 * zHalf, mode: 'directed', exitCollapse: true, exitRecenter: true, exitPhaseReset: true, color: [80, 140, 220] }],
   // The detector SCREEN — a NON-ABSORBING COUNTING wall ('transparent-probe':
   // collisionBehavior 'nothing' + the count hook) in BOTH modes. This is the
   // |psi|^2-faithful screen: an ABSORBING plate removes each quantum at first contact,
@@ -187,8 +178,42 @@ export default function buildExperiment(exp) {
   // FAR-EDGE SINK. The screen below COUNTS WITHOUT ABSORBING, so quanta fly on past it;
   // this destroy wall at the right edge is the experiment-boundary sink that keeps the
   // population bounded (Invariant 5/7 — only an experiment boundary may destroy).
-  exp.addObject('Wall', Object.assign({ rect: [CW - 10, 0, 10, H] }, Z3, { collisionBehavior: 'destroy', name: 'far_sink', color: [120, 120, 120], alpha: 40 }));
-  exp.addObject(IS3D ? 'GraphingDetectorWall' : 'Wall', Object.assign({ rect: [detX, 0, detW, H] }, Z3, { preset: 'transparent-probe', name: 'screen', color: [120, 200, 120] }, IS3D ? { alpha: 220, binPx: 12 } : {}));
+  far_sink: [Wall, { rect: [CW - 10, 0, 10, H], z: -zHalf, depth: 2 * zHalf, collisionBehavior: 'destroy', color: [120, 120, 120], alpha: 40 }],
+  screen: [GraphingDetectorWall, { rect: [detX, 0, detW, H], z: -zHalf, depth: 2 * zHalf, preset: 'transparent-probe', color: [120, 200, 120], alpha: 220, binPx: 12 }],
+};
+
+/**
+ * flat2D(parts) — THE 2D MODE of this scene, derived from its 3D `parts`: the same keys in the same order,
+ * each entry's props copied with the z-slab (z, depth) deleted, is2D set true (by assignment, so the key
+ * keeps its position), and the GraphingDetectorWall plate a plain counting Wall without its paint
+ * (alpha, binPx). Pure: it reads only its argument. A hand-added entry flattens by the same rule.
+ */
+function flat2D(parts) {
+  var out = {};
+  Object.keys(parts).forEach(function (key) {
+    var K = parts[key][0];
+    var props = Object.assign({}, parts[key][1]);
+    delete props.z;
+    delete props.depth;
+    if ('is2D' in props) { props.is2D = true; }
+    if (K === GraphingDetectorWall) { K = Wall; delete props.alpha; delete props.binPx; }
+    out[key] = [K, props];
+  });
+  return out;
+}
+
+export default function buildExperiment(exp) {
+  // Double Slit (Tunnel) — the two slit channels are MIRROR TUNNELS (guarded
+  // bounce, zero-leak); the detector sits at the SYMMETRIC distance (emitter->front ==
+  // back->detector). X placements are wl-derived (canvas-width-independent); Y is
+  // centered on H (groupCenterY = H/2).
+  // The booted display (the host's renderState.renderer) decides which world this mode makes.
+  var IS3D = FrqtlDisplay.name() === 'three';
+  var P = IS3D ? parts : flat2D(parts);
+  // THE WORLD — first, then parts: a 3D scene + universe (600x400x600) or a 2D canvas + universe.
+  if (IS3D) { exp.createScene(CW, H, WORLD_D, SphereEmitter.worldCfg(P.source[1])); }
+  else      { exp.createCanvas(CW, H, SphereEmitter.worldCfg(P.source[1])); }
+  exp.declare(P);
   if (IS3D) {
     // SCENE Z-COLLIMATORS — two INVISIBLE full-canvas destroy boundaries flush OUTSIDE
     // the plate z-band (the cl1a-mirror-3d pattern): the emitted ball's z-tail diffuses,

package/dist/frqtl/scenes/dse-two-emitters.js

@@ -5,7 +5,7 @@
  *
  * 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 (`exp.addObject`) and the render intent are all here; the sugar
+ * 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-two-emitters).
  */
@@ -71,19 +71,70 @@
 // the title lines and the `var NSRC` line — lib/frqtl/scenes/test/scene-files.test.mjs
 // fails if any other line diverges, so the A/B the pair exists to make stays an A/B.
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+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';
+
+export const parts = {
+  // 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) {
   var NSRC = 2;
-  var 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.
-  var lamPx  = 320;
   var lamArg = 3.2;                       // capacity/mass -> fullness 1/3.2 = 0.3125 (yellow)
   var fwl    = 4 * (lamPx / lamArg);      // 400 -> wavelengthScale floor(400/4) = 100
   var wlScale = Math.floor(fwl / 4);      // 100
@@ -91,26 +142,7 @@ export default function buildExperiment(exp) {
     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.)');
   }
-  // ── 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.
-  var legFrac = 1 / 4;
-  var D    = Math.round(lamPx * legFrac); // 80
-  var srcX = Math.round(lamPx / 16);      // 20 — launch room; the canvas edge is the back sink
   var cy   = Math.round(H / 2);           // 200 — the source plane's midline
-  var 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.
-  var detW = Math.round(lamPx / 64);      // 5   — plate thickness
-  var sinkW = Math.round(lamPx / 16);     // 20  — far-edge sink thickness
   // 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
@@ -137,33 +169,7 @@ export default function buildExperiment(exp) {
   for (var si = 0; si < srcYs.length; si++) {
     exp.addObject('SphereEmitter', Object.assign({}, SRC, { center: [srcX, Math.round(srcYs[si])] }));
   }
-  // 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.
-  exp.addObject('Wall', { rect: [CW - sinkW, 0, sinkW, H], collisionBehavior: 'destroy',
-    name: 'far_sink', color: [120, 120, 120], alpha: 40 });
-  // ── 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.
-  var detectorPreset = 'transparent-probe';
-  // 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.
-  var screen = exp.addObject('Wall', { rect: [detX, 0, detW, H],
-    preset: detectorPreset, markTag: 'plate', name: 'screen', color: [120, 200, 120] });
+  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
@@ -189,7 +195,7 @@ export default function buildExperiment(exp) {
   // 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: screen, orientation: 90,
+    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
   });