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

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

@@ -5,31 +5,35 @@
  *
  * 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 cl1c-counting-wall-3d).
  */
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // 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.
-  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  var cy = Math.round(H / 2);
-  var SRC = {
+// 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
-  };
-  exp.createScene(W, H, 600, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
-  exp.addObject('SphereEmitter', SRC);
-  var screen = exp.addObject('Wall', {
+  }],
+  screen: [Wall, {
     rect: [Math.round(W * 0.6), 0, 20, H], z: -80, depth: 160,
-    preset: 'detector-screen', name: 'screen', color: [120, 200, 120]
-  });
+    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: screen,
+    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

@@ -5,33 +5,37 @@
  *
  * 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 cl1c-counting-wall).
  */
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // 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.
-  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  var cy = Math.round(H / 2);
-  var SRC = {
+// 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
-  };
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
-  var screen = exp.addObject('Wall', {
+  }],
+  screen: [Wall, {
     rect: [Math.round(W * 0.6), 0, 20, H],
-    preset: 'detector-screen', name: 'screen', color: [120, 200, 120]
-  });
+    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: screen,
+    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

@@ -17,10 +17,13 @@
 
 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);

package/dist/frqtl/scenes/dse-one-emitter.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-one-emitter).
  */
@@ -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 = 1;
-  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
   });

package/dist/frqtl/scenes/dse-one-slit.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-one-slit).
  */
@@ -36,78 +36,82 @@
 //   diffraction hump" expectation, which this engine's per-source ring mechanism
 //   does NOT predict — if that is what appears instead, it is a real null.)
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Tunnel, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // One Slit -- the SAME apparatus as dse-two-slits with slit 2 WALLED OFF. Barrier =
-  // Wall segments (destroy); the surviving slit 1 = a directed Tunnel with the exit
-  // gate collapsed + phase-reset (identical to dse-two-slits' slit1_channel).
-  var CW = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  // ── THE ONLY LENGTH — IDENTICAL to the canonical-leg pair and dse-two-slits ─────
-  var lamPx  = 320;
-  var lamArg = 3.2;                       // 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
-  if (Math.abs(lamArg * wlScale - lamPx) > 1e-9) {
-    throw new Error('[dse-one-slit] lamPx ' + lamPx + ' is not realisable as lambda_eff: the ' +
-      'engine can only produce wavelengthArg x floor(fwl/4) = ' + (lamArg * wlScale) + '. (FAIL-LOUD.)');
-  }
-  // ── SLIT 1's POSITION — IDENTICAL to dse-two-slits' slit-1 aperture ─────────────
-  // sep is kept only to DERIVE slitCY1 at the exact same y dse-two-slits used (120) —
-  // there is no slit 2 in this rung, so it is never used to place a second aperture.
-  var legFrac = 1 / 4;
-  var D    = Math.round(lamPx * legFrac);   // 80 — the SAME leg, measured from the
-                                             // (single) slit EXIT plane
-  var sep  = lamPx / 2;                     // 160 — dse-two-slits' source separation,
-                                             // reused ONLY to derive slit 1's y below
-  var cy   = Math.round(H / 2);             // 200
-  var slitCY1 = cy - sep / 2;               // 120 — IDENTICAL y to dse-two-slits' slit 1
-  // ── THE BARRIER — one opaque plate, ONE slit aperture (slit 2 walled off) ───────
-  var barrierW = Math.round(lamPx / 8);     // 40 — plate thickness
-  var slitH  = Math.round(lamPx / 8);       // 40 — slit aperture height (before liners)
-  var linerH = Math.round(lamPx / 64);      // 5  — liner thickness (unjumpable: max step 2px/tick)
-  var bore   = slitH - 2 * linerH;          // 30 — the clear aperture between the liners
-  var srcX   = Math.round(lamPx / 16);      // 20 — the emitter, well behind the barrier
-  var barrierL = srcX + Math.round(lamPx / 2);   // 180 — half a wavelength of travel room
-  var slit1Top = slitCY1 - slitH / 2;       // 100 -- slit 1 spans y 100..140
-  var exitX  = barrierL + barrierW;         // 220 — the slit EXIT plane (barrier back face)
-  var detX   = exitX + D;                   // 300 — SAME leg as dse-two-slits
-  var detW   = Math.round(lamPx / 64);      // 5   — plate thickness (flux probe, sub-feature)
-  var sinkW  = Math.round(lamPx / 16);      // 20  — far-edge sink thickness
-  // ── THE LIGHT SOURCE — ONE emitter, behind the barrier, lighting the one slit ───
-  var SRC = {
+// One Slit -- the SAME apparatus as dse-two-slits with slit 2 WALLED OFF. Barrier =
+// Wall segments (destroy); the surviving slit 1 = a directed Tunnel with the exit
+// gate collapsed + phase-reset (identical to dse-two-slits' slit1_channel).
+const CW = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
+// ── THE ONLY LENGTH — IDENTICAL to the canonical-leg pair and dse-two-slits ─────
+const lamPx  = 320;
+const lamArg = 3.2;                       // 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
+// ── SLIT 1's POSITION — IDENTICAL to dse-two-slits' slit-1 aperture ─────────────
+// sep is kept only to DERIVE slitCY1 at the exact same y dse-two-slits used (120) —
+// there is no slit 2 in this rung, so it is never used to place a second aperture.
+const legFrac = 1 / 4;
+const D    = Math.round(lamPx * legFrac);   // 80 — the SAME leg, measured from the
+                                           // (single) slit EXIT plane
+const sep  = lamPx / 2;                     // 160 — dse-two-slits' source separation,
+                                           // reused ONLY to derive slit 1's y below
+const cy   = Math.round(H / 2);             // 200
+const slitCY1 = cy - sep / 2;               // 120 — IDENTICAL y to dse-two-slits' slit 1
+// ── THE BARRIER — one opaque plate, ONE slit aperture (slit 2 walled off) ───────
+const barrierW = Math.round(lamPx / 8);     // 40 — plate thickness
+const slitH  = Math.round(lamPx / 8);       // 40 — slit aperture height (before liners)
+const linerH = Math.round(lamPx / 64);      // 5  — liner thickness (unjumpable: max step 2px/tick)
+const bore   = slitH - 2 * linerH;          // 30 — the clear aperture between the liners
+const srcX   = Math.round(lamPx / 16);      // 20 — the emitter, well behind the barrier
+const barrierL = srcX + Math.round(lamPx / 2);   // 180 — half a wavelength of travel room
+const slit1Top = slitCY1 - slitH / 2;       // 100 -- slit 1 spans y 100..140
+const exitX  = barrierL + barrierW;         // 220 — the slit EXIT plane (barrier back face)
+const detX   = exitX + D;                   // 300 — SAME leg as dse-two-slits
+const detW   = Math.round(lamPx / 64);      // 5   — plate thickness (flux probe, sub-feature)
+const sinkW  = Math.round(lamPx / 16);      // 20  — far-edge sink thickness
+
+export const parts = {
+  source: [SphereEmitter, {
     preset: 'hemisphere', is2D: true, chargeMode: 'random', center: [srcX, cy],
     wavelength: lamArg, fundamentalDimension: 2, fundamentalWaveLength: fwl,
     burstSize: 8, emitEveryTicks: 1
-  };
-  exp.createCanvas(CW, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
+  }],
   // Barrier segments — opaque destroy sinks, leaving ONE slit gap (slit 1 only). Where
   // dse-two-slits had wall2 (a short strip between the two slits) + a slit-2 Tunnel +
   // wall3 (below slit 2), this rung has ONE solid wall from slit 1's bottom liner all
   // the way to the far edge — slit 2's aperture is WALLED, not narrowed or moved.
-  exp.addObject('Wall', { rect: [barrierL, 0, barrierW, slit1Top],
-    collisionBehavior: 'destroy', name: 'wall1', color: [200, 60, 60] });
-  exp.addObject('Wall', { rect: [barrierL, slit1Top + slitH, barrierW, H - (slit1Top + slitH)],
-    collisionBehavior: 'destroy', name: 'wall2_blocked_slit2', color: [150, 40, 40] });
+  wall1: [Wall, { rect: [barrierL, 0, barrierW, slit1Top],
+    collisionBehavior: 'destroy', color: [200, 60, 60] }],
+  wall2_blocked_slit2: [Wall, { rect: [barrierL, slit1Top + slitH, barrierW, H - (slit1Top + slitH)],
+    collisionBehavior: 'destroy', color: [150, 40, 40] }],
   // The one surviving slit channel — directed Tunnel, exit gate COLLAPSED + PHASE-RESET
   // (the dse-tunnel-rebuild composition): its own mouth stands in for a point source at
   // y=120, phase-locked — what a SphereEmitter would do at that pixel.
-  exp.addObject('Tunnel', {
+  slit1_channel: [Tunnel, {
     left: barrierL, top: slit1Top + linerH, length: barrierW, bore: bore,
     wallThickness: linerH, axis: 'x', mode: 'directed',
     exitCollapse: true, exitRecenter: true, exitPhaseReset: true,
-    name: 'slit1_channel', color: [80, 140, 220]
-  });
+    color: [80, 140, 220]
+  }],
   // FAR-EDGE SINK — the same experiment-boundary sink the canonical-leg pair uses.
-  exp.addObject('Wall', { rect: [CW - sinkW, 0, sinkW, H], collisionBehavior: 'destroy',
-    name: 'far_sink', color: [120, 120, 120], alpha: 40 });
+  far_sink: [Wall, { rect: [CW - sinkW, 0, sinkW, H], collisionBehavior: 'destroy',
+    color: [120, 120, 120], alpha: 40 }],
   // ── THE PLATE — SAME instrument as dse-two-slits: a counting wall that does NOT
   // absorb, at the SAME leg D past the new source plane (the one slit exit).
-  var screen = exp.addObject('Wall', { rect: [detX, 0, detW, H],
-    preset: 'transparent-probe', markTag: 'plate', name: 'screen', color: [120, 200, 120] });
+  screen: [Wall, { rect: [detX, 0, detW, H],
+    preset: 'transparent-probe', markTag: 'plate', color: [120, 200, 120] }],
+};
+
+export default function buildExperiment(exp) {
+  if (Math.abs(lamArg * wlScale - lamPx) > 1e-9) {
+    throw new Error('[dse-one-slit] lamPx ' + lamPx + ' is not realisable as lambda_eff: the ' +
+      'engine can only produce wavelengthArg x floor(fwl/4) = ' + (lamArg * wlScale) + '. (FAIL-LOUD.)');
+  }
+  // ── THE LIGHT SOURCE — ONE emitter, behind the barrier, lighting the one slit ───
+  exp.createCanvas(CW, H, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
+  const p = exp.declare(parts);
   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
   });

package/dist/frqtl/scenes/dse-photoelectric.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-photoelectric).
  */
@@ -24,46 +24,50 @@
 // counts the RADIATED quanta (the photoelectron detector) — and its own live arrivals chart
 // shows them being counted. SU1 — the LO5 absorb/radiate golden, composed, zero new physics.
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // 2B (Photoelectric) — light stream → ABSORB wall (charges + radiates) → a Detector
-  // Screen BEHIND counting the radiated photoelectrons. Two live charts: the wall's
-  // charge ledger (absorberStats) and the rear detector's arrivals.
-  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  var cy = Math.round(H / 2);
-  // The incoming light stream: a thin +x beam of oppositely-charged dim-2 leaves. A
-  // SPARSE flux (1 leaf / 2 ticks) keeps the slow absorb/radiate drip radiation-dominated
-  // (a dense beam saturates the wall, which then leaks past it — the deferred emergent-
-  // probability threshold would gate that; see 2B prose).
-  var SRC = {
+// 2B (Photoelectric) — light stream → ABSORB wall (charges + radiates) → a Detector
+// Screen BEHIND counting the radiated photoelectrons. Two live charts: the wall's
+// charge ledger (absorberStats) and the rear detector's arrivals.
+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: 'particle-walk', is2D: true, center: [Math.round(W * 0.1), cy],
     chargeMode: 'random', fundamentalDimension: 2, wavelength: 32,
     burstSize: 1, emitEveryTicks: 2
-  };
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
+  }],
   // The absorbing wall (ABSORB v2): charges up to capacity, then radiates lower-dim
   // leaves out its back (mass conserved) — the photocathode.
-  var absorber = exp.addObject('Wall', {
+  absorber: [Wall, {
     rect: [Math.round(W * 0.45), Math.round(H * 0.25), 20, Math.round(H * 0.5)],
-    collisionBehavior: 'absorb', capacity: 64, name: 'absorber', color: [150, 90, 210]
-  });
+    collisionBehavior: 'absorb', capacity: 64, color: [150, 90, 210]
+  }],
   // The photoelectron detector: a Detector Screen (destroy + count) BEHIND the absorber,
   // counting the radiated quanta that emerge past it.
-  var photodetector = exp.addObject('Wall', {
+  photodetector: [Wall, {
     rect: [Math.round(W * 0.72), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
-    preset: 'detector-screen', name: 'photodetector', color: [120, 200, 120]
-  });
+    preset: 'detector-screen', color: [120, 200, 120]
+  }],
+};
+
+export default function buildExperiment(exp) {
+  // The incoming light stream: a thin +x beam of oppositely-charged dim-2 leaves. A
+  // SPARSE flux (1 leaf / 2 ticks) keeps the slow absorb/radiate drip radiation-dominated
+  // (a dense beam saturates the wall, which then leaks past it — the deferred emergent-
+  // probability threshold would gate that; see 2B prose).
+  exp.createCanvas(W, H, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
+  const p = exp.declare(parts);
   // The wall's charge ledger (stored / absorbed / radiated) — the absorb-stats series.
   exp.addObject('LiveChart', {
-    source: absorber, projector: 'absorberStats',
+    source: p.absorber, projector: 'absorberStats',
     rect: [Math.round(W * 0.04), Math.round(H * 0.03), Math.round(W * 0.32), Math.round(H * 0.28)],
     series: 'bar', label: 'wall charge (stored/absorbed/radiated)', refreshMs: 100, color: [30, 22, 44], alpha: 230
   });
   // The photoelectron count beyond the wall — the rear detector's live arrivals.
   exp.addObject('LiveChart', {
-    source: photodetector,
+    source: p.photodetector,
     rect: [Math.round(W * 0.63), Math.round(H * 0.03), Math.round(W * 0.32), Math.round(H * 0.28)],
     series: 'bar', label: 'photoelectrons counted', refreshMs: 100, color: [22, 40, 30], alpha: 230
   });