@descix/frqtl-node 0.0.0-stage → 0.6.0-p0.1

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

@@ -0,0 +1,244 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — Double Slit (Tunnel, symmetric)
+ *
+ * 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
+ * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
+ * (rung dse-tunnel-rebuild).
+ */
+
+// The double slit built on the TUNNEL OBJECT at physical DSE proportions. The two
+// slit channels are Tunnels — TWO parallel MIRROR walls (guarded bounce, zero leak) — so
+// the slit reflects the beam; the barriers + screen are v2 Walls (destroy / detector-screen
+// preset) so the scene round-trips through codegen on Restart. GEOMETRY: SYMMETRIC —
+// emitter->front of the slit wall equals back of the slit wall->detector. The near-field
+// result is a balanced, central-dominant three-lobe double-slit interference pattern (a
+// stochastic near-field walk; the ray-optics λL/d Fraunhofer regime needs L >> d²/λ ≈ 580px,
+// larger than a 600px canvas allows).
+//
+// ONE MODE-AWARE SOURCE (S3/W2, CEO-ratified 2026-07-26; CEO Q21 2026-10-12). The mode strip
+// selects the RENDERER the host boots (renderState.renderer), and this scene reads it ONCE,
+// before its world: `three` ⇒ exp.createScene (a 3D world), else exp.createCanvas (2D). `IS3D`
+// then guards the dimensional deltas — there is NO second (`-3d`) source file:
+//   * the emitter opens the z-axis   (is2D:!IS3D → activeAxes.z, a 3D ball of directions);
+//   * every barrier / tunnel / detector gains the SAME z-slab (z/depth → a 6-element rect),
+//     so the slit wall is a real SLOT-in-a-PLATE and what you SEE is what collides;
+//   * two invisible `destroy` z-collimators sit flush OUTSIDE the plate z-band (the
+//     cl1a-mirror-3d pattern — the universe z-edge moved inward, the sanctioned
+//     experiment-boundary sink), so no quantum can sail BESIDE a plate and read as
+//     pass-through, and every alive quantum provably faces the barrier;
+//   * 3D makes the detector a GraphingDetectorWall that paints its hits over its OWN
+//     face (y,z), spatially registered — the fringes read as BANDS on the plate, in the
+//     place the physics put them. In 2D the screen is a plain counting Wall.
+// The 3D physics is the SAME engine physics (2D≡3D, bench H2a/H2b) — zero new physics.
+//
+// COLOUR: the beam is YELLOW because it IS a yellow-band beam — the leaves are emitted
+// COLOURLESS and the renderer derives their colour from LightColor at their fullness
+// (= mass/capacity = 1/wavelength). See the emitter block in the source for the two
+// independent dials (band vs pixel wavelength) and why the fringe geometry is unchanged.
+
+import { CameraControls, FrqtlControlOverlay, FrqtlControlsPanel, SphereEmitter } from '@descix/frqtl-web/parts';
+import * as ControlRegistry from '@descix/frqtl-web/shim/controls/registry.js';
+import * as FrqtlDisplay from '@descix/frqtl-web/compat/renderer/display-slot.js';
+import * as SunLook from '@descix/frqtl-web/shim/render/sun-look.js';
+
+export default function buildExperiment(exp) {
+  // Double Slit (Tunnel) — the two slit channels are MIRROR TUNNELS (guarded
+  // bounce, zero-leak); the detector sits at the SYMMETRIC distance (emitter->front ==
+  // back->detector). X placements are wl-derived (canvas-width-independent); Y is
+  // centered on H (groupCenterY = H/2).
+  // The booted display (the host's renderState.renderer) decides which world this mode makes.
+  var IS3D = FrqtlDisplay.name() === 'three';
+  var CW = 600, H = 400, WORLD_D = 600;   // THE WORLD this scene states (its co-init call below)
+  // GEOMETRY and WAVELENGTH are two INDEPENDENT dials, and they are kept apart on
+  // purpose: `wl` sizes the PLATE (slit height, gap, wall placement) and nothing else,
+  // while `lamPx` is the transverse wavelength in pixels. Doubling lambda must NOT move
+  // the slit wall — if one variable drove both, the aperture would silently walk every
+  // time the beam was re-tuned and no two runs would be comparable.
+  var wl = 64, sh = Math.floor(wl * 0.8), gap = Math.floor(wl * 0.8);   // 51, 51
+  var lamPx = 128;                          // the TRANSVERSE wavelength, in pixels
+  var groupH = sh + gap + sh;               // 153
+  var gcY = H / 2;                          // 300 @ H=600
+  var s1Top = gcY - groupH / 2;             // 223.5
+  var gapTop = s1Top + sh;                  // 274.5
+  var s2Bot = gcY + groupH / 2;             // 376.5
+  var s2Top = s2Bot - sh;                   // 325.5
+  var srcX = 20;                            // source x (left, near the slit wall)
+  var L = wl * 1.5, W = wl;                 // slit-group left 96, width 64 (wall front..back = [96,160])
+  // THE DETECTOR LEG, DERIVED FROM THE RING LADDER (zero free parameters).
+  // A phase-locked POINT source lays down density rings at r_m = (lambda/4)*sqrt((2m+1)^2+1)
+  // measured from the emission point (guide row r3-radius-stall-shells;
+  // docs/internal/records/2026-07-30-dse-ring-campaign.md). Each slit exit below
+  // IS such a source, so the plate should be placed where
+  // a NAMED ring crosses it rather than at a symmetric figure. Put the MIDLINE on ring m=2
+  // of BOTH slits: with the exits at +/-halfSep from the midline, that needs a leg of
+  //     D = sqrt(r_2^2 - halfSep^2) = sqrt(163.2^2 - 51^2) = 155
+  // so the two ring-2 circles intersect exactly on the axis and the centre is DOUBLY
+  // reinforced. Rings inside D (m=0 at 45.3, m=1 at 101.2) never reach the plate and
+  // contribute no band — a measured property of the ladder, not an assumption.
+  // This REPLACES the old symmetric-leg figure, whose own comment made it conditional on
+  // the slits becoming directed emitters; the exit gates below are that condition.
+  var ringR = function (m) { return (lamPx / 4) * Math.sqrt((2 * m + 1) * (2 * m + 1) + 1); };
+  var slitCY1 = s1Top + sh / 2, slitCY2 = s2Top + sh / 2;   // 249, 351 — the bore midlines
+  var halfSep = gcY - slitCY1;              // 51
+  var detW = 20;                            // the detector plate's own thickness
+  var D = Math.round(Math.sqrt(ringR(2) * ringR(2) - halfSep * halfSep));   // 155
+  var detX = (L + W) + D;                   // 315
+  var linerH = Math.min(10, Math.floor(sh * 0.2)), bore = sh - 2 * linerH;   // 10, 31
+  // THE 3D DELTA, in ONE place: the plate z-band. Every barrier / tunnel liner / detector
+  // carries the SAME z-slab, so the slit wall is a genuine SLOT IN A PLATE standing in
+  // space (the slits are slots long in z — the 2D figure extruded). In 2D the bag is
+  // EMPTY, so every Object.assign below is byte-identical to the flat scene.
+  var zHalf = Math.round(groupH / 2);                                   // 77 @ wl 64
+  var Z3 = IS3D ? { z: -zHalf, depth: 2 * zHalf } : {};
+  // THE BEAM'S COLOUR — its own frequency band, never a forced recolor. The emitter
+  // emits COLOURLESS leaves (no renderColor arg ⇒ no string_map['render.color']), so the
+  // renderer derives the colour from the ONE authority, LightColor, at the leaf's
+  // fullness. TWO INDEPENDENT dials produce it, both on the emitter:
+  //   fullness  = mass/capacity = 1 / wavelength      -> the spectral BAND (LightColor)
+  //   lambda_px = wavelength x wavelengthScale        -> the transverse wave, in PIXELS
+  // (wavelengthScale = floor(fundamentalWaveLength / 4)). So the band is chosen by
+  // scaling fundamentalWaveLength INVERSELY with the wavelength arg — lambda_px (the
+  // fringe geometry) is untouched. 1/3.2 = 0.3125 sits in the YELLOW band; the rung's
+  // renderState declares the spectrally correct 'roygbiv' ramp, so the beam renders
+  // [255,243,0]. lambda_px = 3.2 x 40 = 128, INDEPENDENT of the 64-derived plate.
+  // THIS BEAM IS LIGHT, so the band is free: these leaves are born AT the universe's
+  // fundamental dimension (leafDimension == fundamentalDimension == 2), and a leaf at the
+  // fundamental ALWAYS steps, P=1, whatever its fullness (bench M1) — the fullness
+  // move-gate (bench M2) simply does not apply, and P=1 draws no RNG. Measured on the
+  // live detector: the fringe histogram is bin-for-bin the SAME as the (64, 16) tuple
+  // (t=30s, 16px profile: 11260 vs 11262 hits, every bin within 1, COM 201.7 both).
+  var lamArg = 3.2;                         // fullness 1/3.2 = 0.3125 -> yellow
+  var fwl    = 4 * (lamPx / lamArg);        // 160 -> wavelengthScale 40 -> lambda_px = 128
+  // The light source — the current SphereEmitter sugar (braided walk), placed at the
+  // original source pixel (srcX, gap-center = H/2).
+  // is2D:!IS3D opens activeAxes.z — the ball-rejected sampler then draws a 3D BALL of
+  // directions (bench S1/S5) instead of the 2D disk.
+  // preset 'hemisphere' = 180 degrees of FORWARD emission (D1): the SAME ball-rejected
+  // sampler with the forward axis' range halved to [0,R], i.e. the spherical distribution
+  // RESTRICTED to the forward half — same physics, pointed one way, so nothing about the
+  // walk changes. Forward is +X, which is where the slit wall stands (orientationDeg stays
+  // 0), so the half of the burst that used to fly LEFT into the back-scatter sink now goes
+  // toward the slits: the same burst size illuminates the aperture roughly twice as hard.
+  var SRC = {
+    preset: 'hemisphere', is2D: !IS3D, center: [srcX, Math.round(gcY)],
+    chargeMode: 'random', wavelength: lamArg, burstSize: 8, emitEveryTicks: 1,
+    fundamentalDimension: 2, fundamentalWaveLength: fwl
+  };
+  // THE WORLD — first, then parts: a 3D scene + universe (600x400x600) or a 2D canvas + universe.
+  if (IS3D) { exp.createScene(CW, H, WORLD_D, SphereEmitter.worldCfg(SRC)); }
+  else      { exp.createCanvas(CW, H, SphereEmitter.worldCfg(SRC)); }
+  exp.addObject('SphereEmitter', SRC);
+  // Start wall — a plain sink (collisionBehavior:'destroy', [set is_alive=0]) at the
+  // left edge, catching back-scatter. It is TRANSPARENT (alpha 40 of 255): the default
+  // camera stands BEHIND the emitter, so an opaque slab here would be the first thing in
+  // frame and would hide the whole experiment. alpha is a DECLARED Wall field, so codegen
+  // captures it and Restart rebuilds the wall just as sheer. Physics is untouched — the
+  // sink still destroys every back-scattered quantum (render-only, SU1).
+  exp.addObject('Wall', Object.assign({ rect: [0, 0, 10, H] }, Z3, { collisionBehavior: 'destroy', name: 'start_wall', color: [120, 120, 120], alpha: 40 }));
+  // Barrier segments — opaque plain sinks (destroy) leaving the two slit gaps.
+  exp.addObject('Wall', Object.assign({ rect: [L, 0, W, s1Top - 1] }, Z3, { collisionBehavior: 'destroy', name: 'wall1', color: [200, 60, 60] }));
+  exp.addObject('Wall', Object.assign({ rect: [L, gapTop, W, gap - 1] }, Z3, { collisionBehavior: 'destroy', name: 'wall2', color: [150, 40, 40] }));
+  exp.addObject('Wall', Object.assign({ rect: [L, s2Bot, W, (H - s2Bot) - 1] }, Z3, { collisionBehavior: 'destroy', name: 'wall3', color: [200, 60, 60] }));
+  // The two slit channels as TUNNELS — walls land at the EXACT original liner positions
+  // ([L,s1Top,W,10] & [L,s1Top+sh-10,W,10]); the bore is the clear aperture between them.
+  // The Tunnel ferries z/depth onto BOTH walls, so a 3D channel is a real corridor.
+  // mode 'directed' (D2): the channel walls are no longer mirrors — a wall hit ejects the
+  // quantum back into the bore and RE-EMITS it in a uniformly random direction within 180°
+  // of the corridor axis (+x here, derived from axis:'x'). That is what makes the slit
+  // itself behave as a semi-circular emitter, which is the classical picture of what a
+  // slit does to a wavefront — and it supersedes the mirror mode FOR THIS RUNG: a
+  // collimating mirror channel preserves the incoming direction, so the two slits could
+  // only ever project two beams. Re-emission is what gives each slit its own angular
+  // spread to interfere with. Mirror mode stays available on the object (mode:'mirror',
+  // still the default) for the waveguide/light-pipe case it was built for.
+  // THE TUNNEL IS A CONFIGURED EMITTER (CEO 2026-07-30). The exit gate's flags are not
+  // plumbing details — they ARE the emitter vocabulary, one-to-one:
+  //   exitRecenter ON  + exitPhaseReset ON  -> a POINT SOURCE (every quantum leaves the
+  //        same pixel with the same phase) — what this rung uses, and what makes the ring
+  //        ladder sharp: any spread at birth blurs every ring by exactly that spread.
+  //   exitRecenter OFF + exitPhaseReset ON  -> an EXTENDED LOCKED APERTURE, the
+  //        plane-wave analog (phase-flat across a finite mouth).
+  //   mode 'directed' spread                -> the ANGULAR PRESET (here 180 deg about the
+  //        corridor axis — the hemisphere preset, expressed at a slit).
+  // In 3D the recenter pins the TRANSVERSE axis only, so the slot stays extended in z:
+  // each slit is a LINE source and the bands extrude along z — the plate picture.
+  // Unifying this with the SphereEmitter preset vocabulary (one owner, ferried — never a
+  // second preset list) is a contract design flagged for architect + CEO ratification;
+  // this rung uses the existing flags and documents the mapping.
+  exp.addObject('Tunnel', Object.assign({ left: L, top: s1Top + linerH, length: W, bore: bore, wallThickness: linerH, axis: 'x' }, Z3, { mode: 'directed', exitCollapse: true, exitRecenter: true, exitPhaseReset: true, name: 'slit1_channel', color: [80, 140, 220] }));
+  exp.addObject('Tunnel', Object.assign({ left: L, top: s2Top + linerH, length: W, bore: bore, wallThickness: linerH, axis: 'x' }, Z3, { mode: 'directed', exitCollapse: true, exitRecenter: true, exitPhaseReset: true, name: 'slit2_channel', color: [80, 140, 220] }));
+  // The detector SCREEN — a NON-ABSORBING COUNTING wall ('transparent-probe':
+  // collisionBehavior 'nothing' + the count hook) in BOTH modes. This is the
+  // |psi|^2-faithful screen: an ABSORBING plate removes each quantum at first contact,
+  // so the reading becomes a first-arrival caustic that drifts with the leg D and lands
+  // at the WRONG radii; counting WITHOUT absorbing reproduces the ring ladder exactly,
+  // because the census at a plane IS the density at that plane. The far-edge sink above bounds the
+  // population that now flies past. The KIND follows the detector's dimensionality. In 2D it is a plain Wall.
+  // In 3D the detector is a PLATE, so it
+  // is a GraphingDetectorWall: it paints its OWN hit grid onto its own faces, spatially
+  // REGISTERED (a hot cell sits exactly where the collisions landed) — the wall is the
+  // axis, so there is no chart chrome in the scene. Both broad faces carry the map, so it
+  // never disappears as you orbit (the back reads as the through-the-window mirror).
+  // NOTE: a wall's collided-frame buffer may be drained by ONE consumer per tick — the
+  // heatmap painter IS that consumer in 3D.
+  // FAR-EDGE SINK. The screen below COUNTS WITHOUT ABSORBING, so quanta fly on past it;
+  // this destroy wall at the right edge is the experiment-boundary sink that keeps the
+  // population bounded (Invariant 5/7 — only an experiment boundary may destroy).
+  exp.addObject('Wall', Object.assign({ rect: [CW - 10, 0, 10, H] }, Z3, { collisionBehavior: 'destroy', name: 'far_sink', color: [120, 120, 120], alpha: 40 }));
+  exp.addObject(IS3D ? 'GraphingDetectorWall' : 'Wall', Object.assign({ rect: [detX, 0, detW, H] }, Z3, { preset: 'transparent-probe', name: 'screen', color: [120, 200, 120] }, IS3D ? { alpha: 220, binPx: 12 } : {}));
+  if (IS3D) {
+    // SCENE Z-COLLIMATORS — two INVISIBLE full-canvas destroy boundaries flush OUTSIDE
+    // the plate z-band (the cl1a-mirror-3d pattern): the emitted ball's z-tail diffuses,
+    // and any quantum beyond the plate band would sail BESIDE the barrier and read as
+    // pass-through. Clamping the scene to the plate band makes the barrier provably face
+    // EVERY alive quantum. 40px deep: un-jumpable (max z step is +/-2/tick).
+    exp.addObject('Wall', { rect: [0, 0, CW, H], z: zHalf, depth: 40,
+      collisionBehavior: 'destroy', name: 'zClipFar', visible: false });
+    exp.addObject('Wall', { rect: [0, 0, CW, H], z: -zHalf - 40, depth: 40,
+      collisionBehavior: 'destroy', name: 'zClipNear', visible: false });
+    // THE SWITCH (CEO 2026-10-13): god-rays computed from the light particles only (godraySource
+    // 'leaf'), at the sun's settings — the ONE owner of those numbers is lib/shim/render/sun-look.js
+    // (SunLook); this file types none of them. Default OFF (the first-contact picture is
+    // unchanged). OFF restores EXACTLY what was live before the last ON (a host row, a STUDIO
+    // slider), through the same declared door; a value the renderer does not declare THROWS there.
+    // The knob shows its last written value (a render write has no read-back). The picture changes
+    // at the next drawn tick, so in a paused (Design) view it shows once the scene runs.
+    var RAYS_ON = Object.assign({}, SunLook.SUN_GODRAYS, { godraySource: 'leaf' });
+    var raysPrior = null;   // the three live values captured at ON; written back at OFF
+    var knobs = ControlRegistry.makeControlRegistry();
+    knobs.registerControls('dse-tunnel-rebuild', [
+      { kind: 'scalar', id: 'godrays', label: 'god rays', channel: 'render', widget: 'toggle',
+        min: 0, max: 1, step: 1, value: 0,
+        fmt: function (v) { return v ? 'on' : 'off'; },
+        onChange: function (v) {
+          if (v) {
+            raysPrior = {};
+            Object.keys(RAYS_ON).forEach(function (k) { raysPrior[k] = exp.runner.getRenderOption(k); });
+            exp.runner.setRenderOptions(RAYS_ON);
+          } else if (raysPrior) {
+            exp.runner.setRenderOptions(raysPrior);
+            raysPrior = null;
+          }
+          // OFF with nothing captured: the control is at its initial OFF and has written nothing — no write.
+        },
+        place: { x: 0.02, y: 0.04 } }
+    ]);
+    // Chrome (a page only): expose the knob to a host frame, and mount the overlay through the
+    // runner's ONE door (runner.controlHost) — before a canvas is mounted (a notebook pane) there is
+    // none, so the knob stays in the exposed registry only.
+    FrqtlControlsPanel.exposeRegistry(knobs, { runner: exp.runner });
+    if (exp.runner.controlHost) { FrqtlControlOverlay.mount(exp.runner, { registry: knobs, name: 'dse-tunnel-rebuild' }); }
+    // THE 3D INSTRUMENT IS THE DETECTOR ITSELF (the GraphingDetectorWall above): the
+    // hits are binned over the detector FACE (y,z) and painted where they landed, so the
+    // interference structure reads as BANDS on the plate, in the place the physics put
+    // them. No free-floating chart panel.
+    // MOVE/LOOK camera joysticks — the OMNI_3D pattern (FAIL-SOFT no-op in 2D).
+    if (typeof document !== 'undefined' && exp.runner) {
+      if (exp.runner.controlHost) { CameraControls.attach(exp.runner, exp.runner.controlHost); }
+    }
+  }
+}

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

@@ -0,0 +1,196 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — Two Emitters at the Canonical Leg
+ *
+ * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world
+ * (its co-init call, `exp.createCanvas` / `exp.createScene` — the one place its size is written),
+ * the parts (`exp.addObject`) and the render intent are all here; the sugar
+ * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
+ * (rung dse-two-emitters).
+ */
+
+// ── H1 AT THE CANONICAL DETECTOR LEG (CEO 2026-08-03) ────────────────────────
+//
+// The competence baseline: the most basic thing, done right, seen with eyes. One
+// emitter, then two, with the plate PRE-COMPUTED at the leg the ring formula was
+// written for and the count-by-y chart registered to that plate. No barrier, no
+// slits, no tunnels — nothing between the source and the plate, so a band on the
+// chart can have come from nothing but the walk.
+//
+// WHY THESE EXIST BESIDE `dse-tunnel-rebuild`. That rung places its plate at
+// D = 155 px against λ_eff = 128 px — 4.84× the reference leg — which pushes the
+// low orders inside the leg where they never reach the plate at all, so only high-m
+// rings can land. These two rungs put the plate ON the reference leg instead.
+//
+// THE GEOMETRY, and it is not re-derived here. λ is the ONLY length; every other
+// length below is a dimensionless constant × λ (the `published/dse/scene.js`
+// discipline). The ring ladder quoted in CLAUDE.md,
+//
+//     r_m = (λ/4)·√((2m+1)² + 1)                       [slant, from the emission point]
+//
+// is the hypotenuse of a right triangle whose TRANSVERSE leg is ρ_m = (2m+1)·λ/4
+// and whose AXIAL leg is λ/4 — the "+1" under the root IS the (λ/4)² axial term.
+// Solve for the axial leg order by order and every order returns λ/4, so the leg is
+// not fitted per-order: it is the one leg the formula was written for. At that leg
+// the on-plate bands are ρ_m = (2m+1)·λ/4 from the source's own y, spacing λ/2.
+//
+// MEASURED, not assumed. `published/dse/h1/` ran exactly this apparatus (bare
+// source, plate at D = λ/4 from the emitter, seed 1, detector 'hits') at λ = 160 /
+// 320 / 640 and found a symmetric feature on the plate at |Δy| = λ/4 − 4 px — 36 /
+// 76 / 156 px — holding that offset to the pixel across a 4× sweep while moving 120
+// px in absolute terms. The raw histogram's shape is: a flat PLATEAU across the
+// centre, a sharp MINIMUM just inside ±λ/4, and a PEAK riding immediately outside it
+// at ±λ/4. At λ=640, counts by Δy/λ: −0.250 → 1107 | −0.225 → 306 | 0.000 → 1011 |
+// +0.225 → 297 | +0.250 → 1125. At λ=320 the same shape, shallower. TWO points on
+// the wall at ¼ λ_eff, with a plateau — not a hole — between them.
+//
+// AND THAT IS WHY λ IS 320 HERE. The dip-to-peak separation is 0.025λ: 16 px at
+// λ=640, 8 px at λ=320, 4 px at λ=160 — which is why the λ=160 run reads as a broad
+// hump with the feature only recoverable by a windowed search on a smoothed profile.
+// Below ~λ=300 this stage cannot resolve the thing it exists to show. So this rung
+// shows ONE well-resolved band pair per source rather than three mushy ones. The 4 px
+// pedestal does NOT scale with λ (it is engine scale — a quantum steps ≤2 px/axis/
+// tick) and no mechanism is offered for it here. The m ≥ 1 rungs of the ladder are
+// NOT established: of the H1 runs' 8 predicted positions, 3 matched, and the m=1
+// positions carried minima.
+//
+// THE LEG IS ONE NAMED CONSTANT (`legFrac`), and so is the plate's DETECTOR MODE —
+// both so they can be moved deliberately from a one-line edit and the consequence
+// re-derived, rather than being literals nobody chose.
+//
+// The beam is the `dse-tunnel-rebuild` beam and the H1 beam, unchanged: wavelength
+// arg 3.2 → mass 5 / capacity 16 → fullness 0.3125, which LightColor renders yellow,
+// and λ_eff = 3.2 × wavelengthScale. The leaves are emitted COLOURLESS; the colour
+// is DERIVED from fullness, never forced.
+//
+// 2D ONLY, deliberately. There is no `modes` strip and no `exp.is3D` guard: these
+// rungs declare one world each. A second dimensional variant would be a separate
+// recipe declaration, not a mode.
+// THE PAIR. `dse-one-emitter.js` is the SAME apparatus with NSRC = 1. The two files differ ONLY in
+// 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';
+
+export default function buildExperiment(exp) {
+  var NSRC = 2;
+  var CW = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
+  // ── THE ONLY LENGTH ─────────────────────────────────────────────────────
+  // lamPx is lambda_eff in pixels. 320 is chosen for RESOLUTION, not for how many
+  // orders fit: the feature this rung exists to show (the minimum just inside the
+  // band and the peak riding outside it) is 0.025*lambda wide, which is 8 px at
+  // lambda 320 and 3 px at lambda 128. A stage that cannot separate them shows a
+  // smooth hump and leaves you unable to say whether the physics or the sampling
+  // was at fault. One well-resolved pair beats three mushy ones.
+  var lamPx  = 320;
+  var lamArg = 3.2;                       // capacity/mass -> fullness 1/3.2 = 0.3125 (yellow)
+  var fwl    = 4 * (lamPx / lamArg);      // 400 -> wavelengthScale floor(400/4) = 100
+  var wlScale = Math.floor(fwl / 4);      // 100
+  if (Math.abs(lamArg * wlScale - lamPx) > 1e-9) {
+    throw new Error('[dse-h1] lamPx ' + lamPx + ' is not realisable as lambda_eff: the engine ' +
+      'can only produce wavelengthArg x floor(fwl/4) = ' + (lamArg * wlScale) + '. (FAIL-LOUD.)');
+  }
+  // ── 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
+  // midline y = H/2 (source 1's lower band and source 2's upper band coincide
+  // there) — the doubly-reinforced central peak, equidistant from both emitters,
+  // exactly where the one-source rung has no peak at all.
+  var sep  = lamPx / 2;                   // 160 -> sources at y 120 and 280
+  var srcYs = (NSRC === 2) ? [cy - sep / 2, cy + sep / 2] : [cy];
+  // ── THE LIGHT SOURCE ────────────────────────────────────────────────────
+  // preset 'hemisphere' = 180 degrees of FORWARD (+X) emission: the SAME
+  // ball-rejected sampler as the omni source with the forward axis' range halved,
+  // so nothing about the walk changes, it is simply pointed at the plate. The
+  // default emission box is 0 for this preset, so the source is a single PIXEL —
+  // load-bearing, because any spread at birth blurs every band by that spread.
+  // NO START WALL: the backward population is empty by construction, and `wrap` is
+  // false, so the canvas edge kills whatever transverse wiggle out-runs its
+  // forward component. One sink, not two.
+  var SRC = {
+    preset: 'hemisphere', is2D: true, chargeMode: 'random',
+    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
+  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] });
+  // ── THE INSTRUMENT — the live count-by-y histogram, REGISTERED TO THE PLATE ──
+  // The panel takes the plate's OWN rect y-origin (0) and height (H), so the two
+  // are co-extensive on the bin axis at any canvas size, and it starts just past
+  // the plate's far face so it reads as sitting behind it. orientation 90 = bars
+  // stacked along y; the chart contract reverses the y scale when horizontal, so
+  // bin 0 (the SMALLEST y) sits at the TOP, matching the y-DOWN world.
+  // HONEST LIMIT (inherited from the shipped 2D block, and it is real): the bin
+  // axis is a CATEGORY axis over the bins that actually received hits, not a linear
+  // 0..H axis. Registration is exact in ORDER and DIRECTION always, and exact in
+  // absolute screen height only insofar as the hits span the wall. Here the plate
+  // is a full-height flux probe under a 180-degree source, so the occupied span
+  // fills the wall within a few hundred ticks and the axis is very nearly linear —
+  // but the ladder positions below must be read off the raw census, never measured
+  // with a ruler on the panel.
+  // SERIES 'line', NOT 'bar', AND THAT IS A MEASUREMENT NOT A TASTE. The bins are
+  // per-pixel y, so a full-height plate produces ~400 categories in a ~240 px plot:
+  // each bar is sub-pixel TALL, its 0.55 fill alpha is diluted by the coverage, and
+  // the profile collapses into a faint sliver hugging the axis. Measured identically
+  // on the shipped 1C Counting Wall rung, so it is the chart contract's behaviour at
+  // this bin count and not something these rungs introduced. A line joins the same 400
+  // points into one continuous curve, which reads as the profile it is. CAVEAT, stated
+  // because it bites: Chart.js does not begin a LINE value axis at zero, so once the
+  // profile's floor rises the curve compresses toward the left edge. Read positions off
+  // it, not magnitudes; magnitudes come from getCollisionHistogram().
+  exp.addObject('LiveChart', {
+    source: 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-two-slits.js

@@ -0,0 +1,132 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — Two Slits at the Canonical Leg
+ *
+ * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world
+ * (its co-init call, `exp.createCanvas` / `exp.createScene` — the one place its size is written),
+ * the parts (`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).
+ */
+
+// ── TWO SLITS AT THE CANONICAL LEG (frqtl-visual-bite, 2026-08-03) ───────────
+//
+// The SAME apparatus as `dse-two-emitters` — same λ, same separation, same leg,
+// same detector, same chart — but the two point sources are now SLIT EXITS in
+// an opaque barrier rather than two free emitters. ONE emitter sits behind the
+// barrier and feeds BOTH slit channels; each channel is a `directed` Tunnel
+// with the exit gate COLLAPSED + PHASE-RESET, exactly the composition
+// `dse-tunnel-rebuild` already uses to make a slit's own mouth stand in for a
+// point source ("THE TUNNEL IS A CONFIGURED EMITTER", CEO 2026-07-30, see that
+// rung's source comment for the flag-by-flag mapping). Composed only: Wall +
+// Tunnel, zero new parts, zero engine code.
+//
+// WHY THE NUMBERS ARE THE SAME AS `dse-two-emitters`. That rung places its two
+// SOURCES at y = cy∓sep/2 (120, 280) and its plate at D = λ_eff/4 past the
+// SOURCE plane (srcX). Here the slit CENTRES sit at the identical y = 120, 280
+// (`sep` unchanged), and the plate sits at the identical D = λ_eff/4 — now
+// measured past the SLIT EXIT plane (the barrier's back face), which is this
+// apparatus's new "source plane". If the exit gate's point-source claim holds,
+// the two apparatuses must draw the SAME picture: a central peak at y = 200
+// (source 1's lower band and source 2's upper band coincide there) flanked by
+// the outer bands at y = 40 and y = 360 — because nothing about the DERIVATION
+// of those positions used "free emitter" anywhere; it only used "point source
+// at (x0, y0), phase-locked, λ_eff". A slit exit under `exitPhaseReset` is
+// exactly that.
+//
+// λ_eff, the leg, and the plate/instrument are the scenes/dse-one-emitter.js numbers,
+// copied rather than referenced because this rung's body is shaped completely
+// differently (a barrier + two Tunnels stand where two bare SphereEmitters
+// stood) — there is no shared statement to factor without re-introducing the
+// exact config-mirror risk the emitter pair's line-diff test guards elsewhere.
+// The bare numbers (320 / 3.2 / 400 / 80 / 160) are the SAME numbers, and the
+// 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';
+
+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 = {
+    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] });
+  // 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', {
+    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', {
+    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]
+  });
+  // 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 });
+  // ── 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] });
+  exp.addObject('LiveChart', {
+    source: 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

@@ -0,0 +1,14 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — Empty Universe
+ *
+ * STUDIO's blank world, a scene like every other: it states its world in its first (and only)
+ * statement and constructs nothing — the palette authors into it. Named by
+ * lib/shim/registry/scene-source.js::EMPTY_SCENE (not a walk-through rung).
+ */
+
+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 });
+}