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

package/dist/frqtl/scenes/atomic-model.js

@@ -24,6 +24,8 @@ import { Rectangle } from '@descix/frqtl-web/parts';
 import * as OrbitBag from '@descix/frqtl-web/compat/renderer/orbit-bag.js';
 import { engine } from '@descix/frqtl-web/compat/engine.js';
 
+export const parts = {};
+
 export default function buildExperiment(exp) {
   var W = 600, H = 600;          // THE WORLD this scene states (its co-init call below)
 
@@ -34,6 +36,7 @@ export default function buildExperiment(exp) {
 
   // ── WORLD — a 2D canvas + universe: quark layer fundamental, λ multiplier 1, quarks confined ──
   exp.createCanvas(W, H, { dimension: QUARK_LAYER, wavelengthScale: 1, bonding: true });
+  exp.declare(parts);
   var u = exp.universe;
 
   var quarkDim = u.addDimension(QUARK_LAYER);

package/dist/frqtl/scenes/big-bang.js

@@ -18,6 +18,8 @@
 
 import { PointSource } from '@descix/frqtl-web/parts';
 
+export const parts = {};
+
 export default function buildExperiment(exp) {
   var W = 600, H = 600;          // THE WORLD this scene states (its co-init call below)
 
@@ -29,6 +31,7 @@ export default function buildExperiment(exp) {
   // iframeIntervalSeconds 1/60: parents are generated EVERY tick (the engine freezes the interval at
   // init, so it rides the world cfg — at the default 1 s, Phase B ran every 60 ticks).
   exp.createCanvas(W, H, { dimension: 0, wavelengthScale: 1, frames: true, iframeIntervalSeconds: 1 / 60 });
+  exp.declare(parts);
   var u = exp.universe;
 
   // ── THE SOURCE — at the centre, no initial momentum, random charge ──────

package/dist/frqtl/scenes/blackbody.js

@@ -21,18 +21,27 @@
  * the oven, the thermostat, the sink. Same calls, same order, same seed ⇒ the same RNG stream.
  */
 
-import { CollisionActions, CollisionTypes, FrqtlControlOverlay, FrqtlControlsPanel, Rectangle } from '@descix/frqtl-web/parts';
+import { CollisionActions, CollisionTypes, FrqtlControlOverlay, FrqtlControlsPanel, LargeObject, Rectangle } from '@descix/frqtl-web/parts';
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 
-export default function buildExperiment(exp) {
-  var W = 600, H = 400;        // THE WORLD this scene states (its co-init call below)
+const W = 600, H = 400;        // THE WORLD this scene states (its co-init call below)
+const SINK_DEPTH = 30;         // the absorbing strip at the right canvas edge (px)
+
+export const parts = {
+  // ── THE SINK — the experiment boundary on the slit side ─────────────────
+  radiation_sink: [LargeObject, {
+    rect: { left: W - SINK_DEPTH, top: 0, w: SINK_DEPTH, h: H },
+    collision_type: CollisionTypes.NONE, actions: [CollisionActions.ABSORB],
+    reposition: 'closest', color: [0, 0, 0]
+  }],
+};
 
+export default function buildExperiment(exp) {
   var TEMPERATURE = 1500;      // target quanta inside the cavity (the knob below)
   var QUANTUM_DIM = 3;         // the layer leaves promote into: an 8 px box edge, 64 cells of capacity in 2D
   var BOX_FRACTION = 1 / 3;    // the cavity's outer box, as a fraction of the canvas
   var WALL = 10;               // wall thickness (px)
   var SLIT_HEIGHT = 60;        // the radiation slit in the right wall (px)
-  var SINK_DEPTH = 30;         // the absorbing strip at the right canvas edge (px)
 
   // ── WORLD — a 2D canvas + universe, fundamental layer 0 (1x1 leaves), λ multiplier 1 ──
   exp.createCanvas(W, H, { dimension: 0, wavelengthScale: 1 });
@@ -57,13 +66,7 @@ export default function buildExperiment(exp) {
   });
   u.experimentTickFunctions[thermostatSlot] = oven.getTemperatureTickFunction();
 
-  // ── THE SINK — the experiment boundary on the slit side ─────────────────
-  exp.addObject('LargeObject', {
-    name: 'radiation_sink',
-    rect: { left: W - SINK_DEPTH, top: 0, w: SINK_DEPTH, h: H },
-    collision_type: CollisionTypes.NONE, actions: [CollisionActions.ABSORB],
-    reposition: 'closest', color: [0, 0, 0]
-  });
+  exp.declare(parts);   // the sink (parts.radiation_sink)
 
   // ── THE KNOB — temperature, live (the oven's own thermostat target) ─────
   var registry = ControlRegistry.makeControlRegistry();

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

@@ -22,6 +22,8 @@
 import { FrqtlControlOverlay, FrqtlControlsPanel, LogicGate, SphereEmitter, Trace } from '@descix/frqtl-web/parts';
 import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
 
+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
@@ -40,6 +42,7 @@ export default function buildExperiment(exp) {
 
   // ── 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
@@ -57,7 +60,7 @@ export default function buildExperiment(exp) {
     { 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: [] }, parts = [];
+  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,
@@ -66,7 +69,7 @@ export default function buildExperiment(exp) {
                                                           { name: 'input' + row.input + i }));   // parked inside the bore mouth
     em.setActive(row.input === 'A' ? STATE.a : STATE.b);
     rails[row.input].push(em);
-    parts.push(t);
+    traces.push(t);
   });
 
   // ── THE READOUTS — grounded traces off each gate's outlet: their current IS the answer ──
@@ -75,8 +78,8 @@ export default function buildExperiment(exp) {
                           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') };
-  parts.push(readouts.SUM, readouts.CARRY);
-  parts.forEach(function (p) { p.attachToRunner(exp.runner); });   // every trace reads the tick stream (a declared gate subscribed at addObject)
+  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;

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

@@ -22,12 +22,15 @@ import { CameraControls, FrqtlControlOverlay, FrqtlControlsPanel } from '@descix
 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);

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
   });