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

package/dist/frqtl/scenes/double-slit.js

@@ -0,0 +1,31 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — Double slit (the SDK's artifact page)
+ *
+ * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The world (its
+ * co-init call, `exp.createCanvas` — the one place its size is written), the parts and their order
+ * are all here; the sugar (SlitScreen, SlitLightSource, DetectorWall, LargeObject), the renderer
+ * and the engine are imports. Shipped as `dist/artifact/double-slit.html`: the generator
+ * (lib/shim/engine/artifact-shell.js, ARTIFACT_SCENE) embeds THIS file's text verbatim.
+ *
+ * The parts are setupDoubleSlit's at its defaults (slit screen at 1.5 λ, an absorbing start wall,
+ * the slit light source at a 10° step, the detector 3 λ past the screen), so the seeded run is
+ * that factory's, tick for tick (lib/shim/engine/test/artifact-shell-sketch.test.mjs holds it on
+ * the WASM engine). Zero new physics.
+ */
+
+import { CollisionTypes, DetectorWall, LargeObject, SlitLightSource, SlitScreen } from '@descix/frqtl-web/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
+  var u = exp.universe;
+
+  var slits = new SlitScreen(u, WAVELENGTH * 1.5, WAVELENGTH, S, WAVELENGTH, true, 1);
+  new LargeObject(u, [0, 0, 10, S], CollisionTypes.ABSORB, [], 'start_wall', 'closest', null, 1, [120, 120, 120]);
+  var light = new SlitLightSource(u, slits, 10);
+  new DetectorWall(u, u.universe_rect, slits.wall1.rect.left + slits.wall1.rect.w + 3 * WAVELENGTH);
+  u.experimentTickFunctions.push(light.getTickFunction());
+}

package/dist/frqtl/scenes/dse-one-emitter.js

@@ -0,0 +1,196 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — One Emitter 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-one-emitter).
+ */
+
+// ── 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-two-emitters.js` is the SAME apparatus with NSRC = 2. 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 = 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
+  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-one-slit.js

@@ -0,0 +1,114 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — One Slit 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-one-slit).
+ */
+
+// ── ONE SLIT AT THE CANONICAL LEG (frqtl-visual-bite, 2026-08-04) ────────────
+//
+// The companion arm to `dse-two-slits`: the IDENTICAL apparatus (same emitter, same
+// barrier x-position, same slit-1 aperture at y=120, same leg D, same plate, same
+// chart) with slit 2 (the y=280 aperture) WALLED OFF — a single opaque barrier
+// segment stands where `wall2` + the slit-2 `Tunnel` + `wall3` stood in
+// `dse-two-slits`. Nothing else moves: this rung and `dse-two-slits` differ by
+// exactly one declared thing — how many apertures the barrier has.
+//
+// PRE-FLIGHT PREDICTION (recorded before capture; see the ring ladder in
+// the header comment of scenes/dse-one-emitter.js, and `dse-one-emitter`'s use of the same
+// ladder off-centre here): a slit's exit is a phase-locked point source at its own
+// y (the `dse-tunnel-rebuild` composition), so with ONLY slit 1 open the surviving
+// population is governed by ONE point source at y=120, D=lambda_eff/4=80 past the
+// exit plane. Its own ladder (y0 +/- lambda/4, +/- 3*lambda/4, ...) places bands at
+// y = 120-80=40, 120+80=200, and (the m=1 term) 120+240=360 -- the m=1 LOWER term
+// (120-240=-120) falls off the 400px canvas and does not exist.
+//   PREDICTED: three bands at y=40, y=200, y=360; a dip/minimum on either side of
+//   each; NO claim about height relative to `dse-two-slits` — degree of
+//   reinforcement is a different question this bite does not ask. The claim under
+//   test is PRESENCE AND POSITION: does structure appear at all with one aperture,
+//   and does it land on this specific off-centre ladder rather than smearing into
+//   a single broad structureless lobe centred on y=120 (the naive "single-slit
+//   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';
+
+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 = {
+    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] });
+  // 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', {
+    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]
+  });
+  // 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 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] });
+  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-photoelectric.js

@@ -0,0 +1,70 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — Photoelectric
+ *
+ * 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-photoelectric).
+ */
+
+// ── DSE Lab (CEO 2026-07-24, DSE-rebuild-before-republish; consolidated 2026-07-26)
+//    — the photoelectric experiment + THE double-slit, built on the full new
+//    component set (SphereEmitter chargeMode random, v2 Walls + presets, in-scene
+//    LiveChart). The single canonical double-slit is 2C (on the Tunnel object); the
+//    old Light-Lab r9 and DSE 2A double-slit rungs were retired.
+// 2B — the photoelectric effect on the new component set (CEO ruling 2026-07-24:
+// "leave as is now" = the CURRENT absorb/radiate drip, NO workFunction threshold).
+// An incoming light stream charges an ABSORBING Wall (ABSORB v2 real backing-frame mass:
+// fills to capacity, then per-tick radiates lower-dimension leaves out its back with
+// p=1/capacity, mass conserved). A LiveChart on the absorber's absorb-stats series shows
+// stored/absorbed/radiated as the wall charges; a second Detector Screen BEHIND the wall
+// counts the RADIATED quanta (the photoelectron detector) — and its own live arrivals chart
+// shows them being counted. SU1 — the LO5 absorb/radiate golden, composed, zero new physics.
+
+import { SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  // 2B (Photoelectric) — light stream → ABSORB wall (charges + radiates) → a Detector
+  // Screen BEHIND counting the radiated photoelectrons. Two live charts: the wall's
+  // charge ledger (absorberStats) and the rear detector's arrivals.
+  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
+  var cy = Math.round(H / 2);
+  // The incoming light stream: a thin +x beam of oppositely-charged dim-2 leaves. A
+  // SPARSE flux (1 leaf / 2 ticks) keeps the slow absorb/radiate drip radiation-dominated
+  // (a dense beam saturates the wall, which then leaks past it — the deferred emergent-
+  // probability threshold would gate that; see 2B prose).
+  var SRC = {
+    preset: 'particle-walk', is2D: true, center: [Math.round(W * 0.1), cy],
+    chargeMode: 'random', fundamentalDimension: 2, wavelength: 32,
+    burstSize: 1, emitEveryTicks: 2
+  };
+  exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.addObject('SphereEmitter', SRC);
+  // The absorbing wall (ABSORB v2): charges up to capacity, then radiates lower-dim
+  // leaves out its back (mass conserved) — the photocathode.
+  var absorber = exp.addObject('Wall', {
+    rect: [Math.round(W * 0.45), Math.round(H * 0.25), 20, Math.round(H * 0.5)],
+    collisionBehavior: 'absorb', capacity: 64, name: 'absorber', color: [150, 90, 210]
+  });
+  // The photoelectron detector: a Detector Screen (destroy + count) BEHIND the absorber,
+  // counting the radiated quanta that emerge past it.
+  var photodetector = exp.addObject('Wall', {
+    rect: [Math.round(W * 0.72), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
+    preset: 'detector-screen', name: 'photodetector', color: [120, 200, 120]
+  });
+  // The wall's charge ledger (stored / absorbed / radiated) — the absorb-stats series.
+  exp.addObject('LiveChart', {
+    source: absorber, projector: 'absorberStats',
+    rect: [Math.round(W * 0.04), Math.round(H * 0.03), Math.round(W * 0.32), Math.round(H * 0.28)],
+    series: 'bar', label: 'wall charge (stored/absorbed/radiated)', refreshMs: 100, color: [30, 22, 44], alpha: 230
+  });
+  // The photoelectron count beyond the wall — the rear detector's live arrivals.
+  exp.addObject('LiveChart', {
+    source: photodetector,
+    rect: [Math.round(W * 0.63), Math.round(H * 0.03), Math.round(W * 0.32), Math.round(H * 0.28)],
+    series: 'bar', label: 'photoelectrons counted', refreshMs: 100, color: [22, 40, 30], alpha: 230
+  });
+}