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

package/dist/frqtl/scenes/dse-two-slits.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-slits).
  */
@@ -44,88 +44,92 @@
 // fail-loud realisability check is repeated verbatim so a future λ edit here
 // cannot silently drift from the pair it must match.
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Tunnel, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // Two Slits — reproduces dse-two-emitters' picture with the two point sources built
-  // as SLIT EXITS in a barrier instead of two free emitters. Barrier = Wall segments
-  // (destroy); each slit = a directed Tunnel with the exit gate collapsed + phase-reset
-  // (the dse-tunnel-rebuild composition) so the mouth is a phase-locked point source.
-  var CW = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  // ── THE ONLY LENGTH — IDENTICAL to the canonical-leg pair ───────────────
-  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-two-slits] lamPx ' + lamPx + ' is not realisable as lambda_eff: the ' +
-      'engine can only produce wavelengthArg x floor(fwl/4) = ' + (lamArg * wlScale) + '. (FAIL-LOUD.)');
-  }
-  // ── SLIT SEPARATION — IDENTICAL to dse-two-emitters' source separation ──
-  var legFrac = 1 / 4;
-  var D    = Math.round(lamPx * legFrac);   // 80 — the SAME leg, now measured from the
-                                             // slit EXIT plane, this apparatus's source plane
-  var sep  = lamPx / 2;                     // 160 -> slit centres at y 120 and 280 — the
-                                             // EXACT y positions dse-two-emitters used
-  var cy   = Math.round(H / 2);             // 200
-  var slitCY1 = cy - sep / 2, slitCY2 = cy + sep / 2;   // 120, 280
-  // ── THE BARRIER — one opaque plate, two slit apertures ──────────────────
-  var barrierW = Math.round(lamPx / 8);     // 40 — plate thickness (dimensionless x lamPx,
-                                             // an independent dial from the transverse
-                                             // wavelength, same discipline as dse-tunnel-rebuild)
-  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, slit2Top = slitCY2 - slitH / 2;   // 100, 260
-  var exitX  = barrierL + barrierW;         // 220 — the slit EXIT plane (barrier back face)
-  var detX   = exitX + D;                   // 300 — SAME leg as dse-two-emitters, now
-                                             // measured from the slit exits
-  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 BOTH slits ──
-  // preset 'hemisphere': 180 degrees of FORWARD emission, aimed at the barrier — the
-  // same walk-character (chargeMode/wavelength/fundamentalWaveLength) the slit exits must
-  // carry through so the exit's phase-locked point source is at the SAME λ_eff.
-  var SRC = {
+// Two Slits — reproduces dse-two-emitters' picture with the two point sources built
+// as SLIT EXITS in a barrier instead of two free emitters. Barrier = Wall segments
+// (destroy); each slit = a directed Tunnel with the exit gate collapsed + phase-reset
+// (the dse-tunnel-rebuild composition) so the mouth is a phase-locked point source.
+const CW = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
+// ── THE ONLY LENGTH — IDENTICAL to the canonical-leg pair ───────────────
+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 SEPARATION — IDENTICAL to dse-two-emitters' source separation ──
+const legFrac = 1 / 4;
+const D    = Math.round(lamPx * legFrac);   // 80 — the SAME leg, now measured from the
+                                           // slit EXIT plane, this apparatus's source plane
+const sep  = lamPx / 2;                     // 160 -> slit centres at y 120 and 280 — the
+                                           // EXACT y positions dse-two-emitters used
+const cy   = Math.round(H / 2);             // 200
+const slitCY1 = cy - sep / 2, slitCY2 = cy + sep / 2;   // 120, 280
+// ── THE BARRIER — one opaque plate, two slit apertures ──────────────────
+const barrierW = Math.round(lamPx / 8);     // 40 — plate thickness (dimensionless x lamPx,
+                                           // an independent dial from the transverse
+                                           // wavelength, same discipline as dse-tunnel-rebuild)
+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, slit2Top = slitCY2 - slitH / 2;   // 100, 260
+const exitX  = barrierL + barrierW;         // 220 — the slit EXIT plane (barrier back face)
+const detX   = exitX + D;                   // 300 — SAME leg as dse-two-emitters, now
+                                           // measured from the slit exits
+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 the two slit gaps.
-  exp.addObject('Wall', { rect: [barrierL, 0, barrierW, slit1Top],
-    collisionBehavior: 'destroy', name: 'wall1', color: [200, 60, 60] });
-  exp.addObject('Wall', { rect: [barrierL, slit1Top + slitH, barrierW, slit2Top - (slit1Top + slitH)],
-    collisionBehavior: 'destroy', name: 'wall2', color: [150, 40, 40] });
-  exp.addObject('Wall', { rect: [barrierL, slit2Top + slitH, barrierW, H - (slit2Top + slitH)],
-    collisionBehavior: 'destroy', name: 'wall3', color: [200, 60, 60] });
+  wall1: [Wall, { rect: [barrierL, 0, barrierW, slit1Top],
+    collisionBehavior: 'destroy', color: [200, 60, 60] }],
+  wall2: [Wall, { rect: [barrierL, slit1Top + slitH, barrierW, slit2Top - (slit1Top + slitH)],
+    collisionBehavior: 'destroy', color: [150, 40, 40] }],
+  wall3: [Wall, { rect: [barrierL, slit2Top + slitH, barrierW, H - (slit2Top + slitH)],
+    collisionBehavior: 'destroy', color: [200, 60, 60] }],
   // The two slit channels — directed Tunnels, exit gate COLLAPSED + PHASE-RESET (the
   // dse-tunnel-rebuild composition): each channel's own mouth stands in for a point
   // source at the slit's own y, 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]
-  });
-  exp.addObject('Tunnel', {
+    color: [80, 140, 220]
+  }],
+  slit2_channel: [Tunnel, {
     left: barrierL, top: slit2Top + linerH, length: barrierW, bore: bore,
     wallThickness: linerH, axis: 'x', mode: 'directed',
     exitCollapse: true, exitRecenter: true, exitPhaseReset: true,
-    name: 'slit2_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 the canonical-leg pair: a counting wall that does
   // NOT absorb, at the SAME leg D past the new source plane (the slit exits).
-  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-two-slits] 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 BOTH slits ──
+  // preset 'hemisphere': 180 degrees of FORWARD emission, aimed at the barrier — the
+  // same walk-character (chargeMode/wavelength/fundamentalWaveLength) the slit exits must
+  // carry through so the exit's phase-locked point source is at the SAME λ_eff.
+  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/empty.js

@@ -8,7 +8,10 @@
  * lib/shim/registry/scene-source.js::EMPTY_SCENE (not a walk-through rung).
  */
 
+export const parts = {};
+
 export default function buildExperiment(exp) {
   // THE WORLD: a 600x400 2D canvas + universe on the dim-2 fundamental, λ multiplier 8.
   exp.createCanvas(600, 400, { dimension: 2, wavelengthScale: 8 });
+  exp.declare(parts);
 }

package/dist/frqtl/scenes/laser-buildup.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 r4b-laser-buildup).
  */
@@ -26,24 +26,31 @@
 
 import { SphereEmitter, Tunnel } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // Laser Build-Up — gain source + resonant bore + output coupler.
-  // Geometry and per-leaf creation conditions come from the ONE scene-spec authority,
-  // Tunnel.pointExitSpec() (setupTunnelPointExit.sceneSpec), so this rung and the standalone page cannot drift.
-  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-  var spec = Tunnel.pointExitSpec({
-    canvasW: W, canvasH: H,
-    tunnelLength: 240,        // REBUILD-class: corridor geometry, re-authored not dragged
-    wavelengthScale: 16,      // eff lambda 256px — the self-interference golden's own regime
-    exitRecenter: true,       // output coupler collapses the mouth to a point
-    exitPhaseReset: false     // coherence OFF by default — turning it ON is the experiment
-  });
+// Laser Build-Up — gain source + resonant bore + output coupler.
+// Geometry and per-leaf creation conditions come from the ONE scene-spec authority,
+// Tunnel.pointExitSpec() (setupTunnelPointExit.sceneSpec), so this rung and the standalone page cannot drift.
+const W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
+const SPEC = Tunnel.pointExitSpec({
+  canvasW: W, canvasH: H,
+  tunnelLength: 240,        // REBUILD-class: corridor geometry, re-authored not dragged
+  wavelengthScale: 16,      // eff lambda 256px — the self-interference golden's own regime
+  exitRecenter: true,       // output coupler collapses the mouth to a point
+  exitPhaseReset: false     // coherence OFF by default — turning it ON is the experiment
+});
+// The spec names its tunnel; in `parts` the key is the name.
+const { name: _tunnelName, ...TUNNEL } = SPEC.tunnel;
+
+export const parts = {
   // 1. THE GAIN SOURCE — a hemisphere emitter just inside the input mouth, so the whole
   //    burst is aimed down the bore instead of half of it escaping backwards.
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(spec.emitter));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', spec.emitter);
+  emitter: [SphereEmitter, { ...SPEC.emitter }],
   // 2+3. THE BORE AND THE OUTPUT COUPLER — one directed Tunnel carrying the exit gate.
   //    mode 'directed': every wall hit re-emits forward within 180 degrees of the axis.
   //    exitRecenter / exitPhaseReset are the two coupler flags, both live in the Inspector.
-  exp.addObject('Tunnel', spec.tunnel);
+  point_exit_tunnel: [Tunnel, { ...TUNNEL }],
+};
+
+export default function buildExperiment(exp) {
+  exp.createCanvas(W, H, SphereEmitter.worldCfg(parts.emitter[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.declare(parts);
 }

package/dist/frqtl/scenes/mirror-3d.js

@@ -5,40 +5,39 @@
  *
  * 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 cl1a-mirror-3d).
  */
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // Collision Lab 1A · 3D — a collimated LASER (particle-walk pins PURE +x in 2D AND
-  // 3D) into a 3D mirror SLAB (depth → z-slab containing z=0), rendered as a box;
-  // orbit to view. Same LASER tuning as the 2D 1A: single positive
-  // charge, wavelength 1, wavelengthScale 1 (fundamentalWaveLength 4), tiny burst.
-  // FACE-ON default: orientation 0 presents the full
-  // drawn face to the beam → retro-reflection (beam straight back, recolored) — the
-  // one mirror visual that reads correctly from EVERY camera azimuth. (A tilted
-  // default's L-shaped 2th exit is correct optics but its mirror-flipped projection
-  // reads as pass-through from presets that view the xy-plane from behind — measured:
-  // zero leaves ever behind the face; the read was projection handedness, not physics.)
-  // Rotate the orientation slider to steer: 45 -> straight up, 30 -> R(120), etc.
-  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 1A · 3D — a collimated LASER (particle-walk pins PURE +x in 2D AND
+// 3D) into a 3D mirror SLAB (depth → z-slab containing z=0), rendered as a box;
+// orbit to view. Same LASER tuning as the 2D 1A: single positive
+// charge, wavelength 1, wavelengthScale 1 (fundamentalWaveLength 4), tiny burst.
+// FACE-ON default: orientation 0 presents the full
+// drawn face to the beam → retro-reflection (beam straight back, recolored) — the
+// one mirror visual that reads correctly from EVERY camera azimuth. (A tilted
+// default's L-shaped 2th exit is correct optics but its mirror-flipped projection
+// reads as pass-through from presets that view the xy-plane from behind — measured:
+// zero leaves ever behind the face; the read was projection handedness, not physics.)
+// Rotate the orientation slider to steer: 45 -> straight up, 30 -> R(120), etc.
+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: false, center: [Math.round(W * 0.15), cy],
     chargeMode: 'positive', fundamentalDimension: 2, wavelength: 1,
     fundamentalWaveLength: 4, burstSize: 2, emitEveryTicks: 1
-  };
-  exp.createScene(W, H, 600, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
-  exp.addObject('SphereEmitter', SRC);
-  exp.addObject('Wall', {
+  }],
+  mirror: [Wall, {
     rect: [Math.round(W * 0.6), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
     z: -80, depth: 160,
     collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: 0,
-    name: 'mirror', color: [255, 120, 0], hooks: ['recolor']
-  });
+    color: [255, 120, 0], hooks: ['recolor']
+  }],
   // SCENE Z-COLLIMATOR (without it the z lets things pass through instead of
   // reflecting): the beam's z-tail DIFFUSES over time (measured:
   // |z| at the wall trending 68 of the 80 rim within seconds), and any quantum
@@ -49,8 +48,13 @@ export default function buildExperiment(exp) {
   // dying at the canvas edge) — so the mirror provably faces EVERY alive quantum
   // and nothing can ever appear past the plate. 40px deep: un-jumpable (max z
   // step is ±2/tick).
-  exp.addObject('Wall', { rect: [0, 0, W, H], z: 80, depth: 40,
-    collisionBehavior: 'destroy', name: 'zClipFar', visible: false });
-  exp.addObject('Wall', { rect: [0, 0, W, H], z: -120, depth: 40,
-    collisionBehavior: 'destroy', name: 'zClipNear', visible: false });
+  zClipFar: [Wall, { rect: [0, 0, W, H], z: 80, depth: 40,
+    collisionBehavior: 'destroy', visible: false }],
+  zClipNear: [Wall, { rect: [0, 0, W, H], z: -120, depth: 40,
+    collisionBehavior: 'destroy', visible: false }],
+};
+
+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
+  exp.declare(parts);
 }

package/dist/frqtl/scenes/mirror-route.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 cl1d-mirror-route).
  */
@@ -37,6 +37,8 @@
 import { CameraControls, SphereEmitter } from '@descix/frqtl-web/parts';
 import * as FrqtlDisplay from '@descix/frqtl-web/compat/renderer/display-slot.js';
 
+export const parts = {};
+
 export default function buildExperiment(exp) {
   // The booted display (the host's renderState.renderer) decides which world this mode makes.
   var IS3D = FrqtlDisplay.name() === 'three';
@@ -101,6 +103,7 @@ export default function buildExperiment(exp) {
   // THE WORLD — first, then parts: a 3D scene + universe (600x400x600) or a 2D canvas + universe.
   if (IS3D) { exp.createScene(W, H, WORLD_D, SphereEmitter.worldCfg(SRC)); }
   else      { exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC)); }
+  exp.declare(parts);
   exp.addObject('SphereEmitter', SRC);
   // The ten mirrors at the star vertices — each its own colour + the recolor tag. In 3D each is a
   // SLAB (z-slab −SD/2..SD/2); in 2D the bag is EMPTY, so the wall is the flat mirror.

package/dist/frqtl/scenes/mirror.js

@@ -5,34 +5,38 @@
  *
  * 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 cl1a-mirror).
  */
 
-import { SphereEmitter } from '@descix/frqtl-web/parts';
+import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  // Collision Lab 1A (Mirror) — a collimated LASER aimed at a rotatable Bounce/Reflect
-  // Wall. LASER TUNING: particle-walk pins PURE +x momentum (the
-  // tightest constrained-angle the emitter supports — zero angular spread); a SINGLE
-  // (positive) charge removes the random transverse braiding; wavelength 1 → the
-  // minimal transverse wiggle; fundamentalWaveLength 4 → wavelengthScale 1 (the
-  // 256px scale-spread REMOVED — that spray was the 'visually non-sensical' look);
-  // a TINY burst (2/tick) keeps it a thin beam (frame-rate protection). Rotate the
-  // mirror to steer the reflected beam: 45 -> straight-up exit, 30 -> R(120) exit.
-  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 1A (Mirror) — a collimated LASER aimed at a rotatable Bounce/Reflect
+// Wall. LASER TUNING: particle-walk pins PURE +x momentum (the
+// tightest constrained-angle the emitter supports — zero angular spread); a SINGLE
+// (positive) charge removes the random transverse braiding; wavelength 1 → the
+// minimal transverse wiggle; fundamentalWaveLength 4 → wavelengthScale 1 (the
+// 256px scale-spread REMOVED — that spray was the 'visually non-sensical' look);
+// a TINY burst (2/tick) keeps it a thin beam (frame-rate protection). Rotate the
+// mirror to steer the reflected beam: 45 -> straight-up exit, 30 -> R(120) exit.
+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.12), cy],
     orientationDeg: 0, chargeMode: 'positive', fundamentalDimension: 2, wavelength: 1,
     fundamentalWaveLength: 4, burstSize: 2, emitEveryTicks: 1
-  };
-  exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
-  exp.addObject('Wall', {
+  }],
+  mirror: [Wall, {
     rect: [Math.round(W * 0.6), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
     collisionBehavior: 'bounce', bounceDirection: 'reflect',
-    orientationDeg: 45, name: 'mirror', color: [255, 120, 0], hooks: ['recolor']
-  });
+    orientationDeg: 45, color: [255, 120, 0], hooks: ['recolor']
+  }],
+};
+
+export default function buildExperiment(exp) {
+  exp.createCanvas(W, H, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.declare(parts);
 }

package/dist/frqtl/scenes/omni-3d.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 r7-3d).
  */
@@ -14,13 +14,16 @@
 
 import { CameraControls, SphereEmitter } from '@descix/frqtl-web/parts';
 
+export const parts = {
+  source: [SphereEmitter, { preset: 'spherical', is2D: false }],
+};
+
 export default function buildExperiment(exp) {
   // is2D:false opens the z-axis: the ball-rejected sampler draws a 3D BALL of
   // directions (bench S1). three renderer + perspective camera come from renderState.
   // CameraControls.attach = reusable FAIL-SOFT joystick sugar (no-op in 2D).
-  var SRC = { preset: 'spherical', is2D: false };
-  exp.createScene(600, 400, 600, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
-  exp.addObject('SphereEmitter', SRC);
+  exp.createScene(600, 400, 600, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
+  exp.declare(parts);
   if (typeof document !== 'undefined' && exp.runner) {
     if (exp.runner.controlHost) { CameraControls.attach(exp.runner, exp.runner.controlHost); }
   }

package/dist/frqtl/scenes/omni-source.js

@@ -5,18 +5,21 @@
  *
  * 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 r3-omni-source).
  */
 
 import { SphereEmitter } from '@descix/frqtl-web/parts';
 
+export const parts = {
+  source: [SphereEmitter, { preset: 'spherical', is2D: true }],
+};
+
 export default function buildExperiment(exp) {
   // Rung 3 — full dispersion: the spherical preset draws (vx,vy) across the whole
   // ball; in 2D the ball-rejected sampler collapses to an even DISK of directions
   // (bench S5). One omni point source = the sun disk.
-  var SRC = { preset: 'spherical', is2D: true };
-  exp.createCanvas(600, 400, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
+  exp.createCanvas(600, 400, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.declare(parts);
 }

package/dist/frqtl/scenes/self-interference.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
  * (rungs r4-self-interference, r5-fountain-pool).
  */
@@ -19,6 +19,16 @@
 
 import { SphereEmitter } from '@descix/frqtl-web/parts';
 
+export const parts = {
+  source: [SphereEmitter, {
+    is2D: true, preset: 'spherical',
+    emissionShell: 'surface', innerR: 16,
+    fundamentalDimension: 2, wavelength: 32,
+    chargeMode: 'random', fundamentalWaveLength: 64,
+    burstSize: 72, emitEveryTicks: 1
+  }],
+};
+
 export default function buildExperiment(exp) {
   // The classic self-interference tuple (matches self-interference-preset.png):
   //   dim 2 (capacity 16) + wavelength 32 -> clamped to 16 -> mass 1 (fullness 1/16);
@@ -27,13 +37,6 @@ export default function buildExperiment(exp) {
   //   emissionShell 'surface' + innerR 16 -> RING launch (empty center, sharp bands);
   //   burst 72/tick. Red is DERIVED from fullness 1/16 (ROYGBIV low end), not forced.
   //   Pattern = radial BRAIDED BANDS (not concentric rings).
-  var SRC = {
-    is2D: true, preset: 'spherical',
-    emissionShell: 'surface', innerR: 16,
-    fundamentalDimension: 2, wavelength: 32,
-    chargeMode: 'random', fundamentalWaveLength: 64,
-    burstSize: 72, emitEveryTicks: 1
-  };
-  exp.createCanvas(600, 400, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
+  exp.createCanvas(600, 400, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.declare(parts);
 }

package/dist/frqtl/scenes/smoking-gun.js

@@ -56,24 +56,27 @@
 
 import { CameraControls, CollisionTypes, LargeObject, SphereEmitter } from '@descix/frqtl-web/parts';
 
-export default function buildExperiment(exp) {
-  var W = 600, H = 600, D = 600;          // THE WORLD this scene states (its co-init call below)
-  var BURST = 20;                          // quanta per tick at the muzzle, before the wind-down
-  var BULLET_SIDE = 10;                    // the bullet cube's edge = the muzzle slit's height (px)
-  var RAMP_START = 180, RAMP_END = 600;    // the wind-down: full burst until RAMP_START, zero at RAMP_END
-  var GUN_W = 150, GUN_H = 84;             // the painted gun body (px); its right edge is the muzzle
+const W = 600, H = 600, D = 600;          // THE WORLD this scene states (its co-init call below)
+const BURST = 20;                          // quanta per tick at the muzzle, before the wind-down
+const BULLET_SIDE = 10;                    // the bullet cube's edge = the muzzle slit's height (px)
+const MUZZLE_X = Math.floor(W / 2), MUZZLE_Y = Math.floor(H / 2);
 
-  var MUZZLE_X = Math.floor(W / 2), MUZZLE_Y = Math.floor(H / 2);
-  var SRC = {
+export const parts = {
+  muzzle: [SphereEmitter, {
     preset: 'particle-walk', is2D: false,             // pure +X momentum in 2D and 3D
     center: [MUZZLE_X, MUZZLE_Y, 0],
     emissionBox: { x: 0, y: BULLET_SIDE, z: 0 },      // the 1×10 slit
     chargeMode: 'negative', burstSize: BURST, emitEveryTicks: 1,
     fundamentalDimension: 0, fundamentalWaveLength: 64   // λ scale floor(64/4) = 16
-  };
+  }],
+};
+
+export default function buildExperiment(exp) {
+  var RAMP_START = 180, RAMP_END = 600;    // the wind-down: full burst until RAMP_START, zero at RAMP_END
+  var GUN_W = 150, GUN_H = 84;             // the painted gun body (px); its right edge is the muzzle
 
   // ── WORLD — a 3D scene + universe W×H×D, fundamental layer 0, λ multiplier 16 ──
-  exp.createScene(W, H, D, SphereEmitter.worldCfg(SRC));
+  exp.createScene(W, H, D, SphereEmitter.worldCfg(parts.muzzle[1]));
   var u = exp.universe;
   u.brownianMotion = true;
   u.withInterQuantumCollisions = true;
@@ -83,7 +86,8 @@ export default function buildExperiment(exp) {
   exp.runner.setRateLimits({ tpsLimit: 60 });   // pacing only: 60 ticks = 1 s of wall-clock
 
   // ── THE MUZZLE ──
-  var muzzle = exp.addObject('SphereEmitter', SRC);
+  const p = exp.declare(parts);
+  var muzzle = p.muzzle;
 
   // ── THE WIND-DOWN — the burst falls linearly from BURST at RAMP_START to zero at RAMP_END ──
   // The burst setter's floor is one quantum per tick, so zero is the muzzle's cut, issued once.

package/dist/frqtl/scenes/straight-walk.js

@@ -5,18 +5,21 @@
  *
  * 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 r1-straight-walk).
  */
 
 import { SphereEmitter } from '@descix/frqtl-web/parts';
 
+export const parts = {
+  source: [SphereEmitter, { preset: 'particle-walk', is2D: true }],
+};
+
 export default function buildExperiment(exp) {
   // Rung 1 — deterministic +X drift (particle-walk preset pins vx=[R,R], vy=vz=0)
   // with the tiny always-armed transverse coin. Born AT the fundamental (dim 0)
   // so it is 'light' — steps every tick (fast straight drift).
-  var SRC = { preset: 'particle-walk', is2D: true };
-  exp.createCanvas(600, 400, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
-  exp.addObject('SphereEmitter', SRC);
+  exp.createCanvas(600, 400, SphereEmitter.worldCfg(parts.source[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.declare(parts);
 }