@descix/frqtl-node 0.6.1-p3.3 → 0.7.0-p0

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

@@ -1,201 +0,0 @@
-/* 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 (`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-emitters).
- */
-
-// ── H1 AT THE CANONICAL DETECTOR LEG ─────────────────────────────────────────
-//
-// 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 ONE source entry. The two files differ ONLY in the
-// title lines, this note, and their `source*` entries of `parts` (with the world call naming the first
-// of them) — lib/frqtl/scenes/test/scene-files.test.mjs fails if anything else diverges, so the A/B the
-// pair exists to make stays an A/B.
-
-import { SphereEmitter, Wall } from '@descix/frqtl-web/parts';
-
-const CW = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
-// ── THE ONLY LENGTH ─────────────────────────────────────────────────────
-// lamPx is lambda_eff in pixels. 320 is chosen for RESOLUTION, not for how many
-// orders fit: the feature this rung exists to show (the minimum just inside the
-// band and the peak riding outside it) is 0.025*lambda wide, which is 8 px at
-// lambda 320 and 3 px at lambda 128. A stage that cannot separate them shows a
-// smooth hump and leaves you unable to say whether the physics or the sampling
-// was at fault. One well-resolved pair beats three mushy ones.
-const lamPx  = 320;
-const sinkW = Math.round(lamPx / 16);     // 20  — far-edge sink thickness
-
-// ── THE DETECTOR LEG — ONE NAMED CONSTANT ───────────────────────────────
-// D = legFrac * lambda, measured from the SOURCE (there is no barrier, so the
-// emitter itself is the reference point of the ladder). legFrac = 1/4 is the
-// leg the ring formula was written for; see the block comment above.
-const legFrac = 1 / 4;
-const D    = Math.round(lamPx * legFrac); // 80
-const srcX = Math.round(lamPx / 16);      // 20 — launch room; the canvas edge is the back sink
-const detX = srcX + D;                    // 100 — the plate's FRONT FACE
-// PLATE THICKNESS IS AN OPTICAL CHOICE UNDER A FLUX DETECTOR, not trim. A flux
-// probe counts every tick a quantum overlaps it, so it integrates the density
-// ACROSS its thickness — and the ring crest is a CIRCLE about the source, not a
-// plane. At the m=0 band the crest's slope is dy/dx = -D/y = -1, so a slab t px
-// thick smears the band over ~t px of y. Against an 8 px feature a lambda/8 (40
-// px) plate would guarantee mush. lambda/64 = 5 px keeps the smear sub-feature
-// and is still unjumpable (a quantum steps at most 2 px/axis/tick). A 'hits'
-// plate would not care — it counts at first contact, i.e. at the front face —
-// which is exactly why the reference H1 runs could afford a lambda/8 slab.
-const detW = Math.round(lamPx / 64);      // 5   — plate thickness
-// ── THE PLATE — A COUNTING WALL THAT DOES NOT ABSORB ────────────────────
-// ONE NAMED CONSTANT, so the reading can be swapped in a single edit and the two
-// instruments compared rather than argued about:
-//   'transparent-probe' = collisionBehavior 'nothing' + mark/count. FLUX. The
-//       quantum is counted on every tick it overlaps the plate and then flies on,
-//       so the reading is the OCCUPANCY INTEGRAL at the plate plane — the density
-//       at that plane. This is the shipped choice.
-//   'detector-screen'   = destroy + count. HITS. Each quantum is counted once, at
-//       arrival, and removed: a transit census, the headcount a photographic plate
-//       would report. It is what the H1 reference runs used.
-// NEITHER ABSORBS. 'absorb' stores the arriving mass and re-radiates it — that is
-// the photoelectric experiment, and it saturates.
-const detectorPreset = 'transparent-probe';
-
-const lamArg = 3.2;                       // capacity/mass -> 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
-const cy   = Math.round(H / 2);           // 200 — the source plane's midline
-// 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.
-const sep  = lamPx / 2;                   // 160 -> sources at y 120 and 280
-// ── 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.
-const SRC = {
-  preset: 'hemisphere', is2D: true, chargeMode: 'random',
-  wavelength: lamArg, fundamentalDimension: 2, fundamentalWaveLength: fwl,
-  burstSize: 8, emitEveryTicks: 1
-};
-
-export const parts = {
-  source1: [SphereEmitter, { ...SRC, center: [srcX, Math.round(cy - sep / 2)] }],
-  source2: [SphereEmitter, { ...SRC, center: [srcX, Math.round(cy + sep / 2)] }],
-  // FAR-EDGE SINK. The plate below counts WITHOUT removing, so quanta fly on past
-  // it; this is the experiment-boundary sink downstream of the plate. It is not
-  // load-bearing (wrap is false, so the canvas edge would remove them anyway) — it
-  // is where the population bound is STATED rather than inferred.
-  far_sink: [Wall, { rect: [CW - sinkW, 0, sinkW, H], collisionBehavior: 'destroy',
-    color: [120, 120, 120], alpha: 40 }],
-  // markTag — the plate's PROVENANCE stamp. The mark hook fires ONLY when the
-  // collision trigger does (genuine overlap), whereas the engine buffers every
-  // frame inside the LO's mb_w-PADDED search rect whether it triggered or not. So a
-  // raw frame count off the buffer is a padded-occupancy reading and the
-  // mark-filtered count is the trigger-gated census: two different instruments, and
-  // an offline reader needs the tag to tell them apart.
-  screen: [Wall, { rect: [detX, 0, detW, H],
-    preset: detectorPreset, markTag: 'plate', color: [120, 200, 120] }],
-};
-
-export default function buildExperiment(exp) {
-  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.)');
-  }
-  exp.createCanvas(CW, H, SphereEmitter.worldCfg(parts.source1[1]));   // THE WORLD: a 2D canvas + universe — first, then parts
-  const p = exp.declare(parts);
-  // ── THE INSTRUMENT — the live count-by-y histogram, REGISTERED TO THE PLATE ──
-  // The panel takes the plate's OWN rect y-origin (0) and height (H), so the two
-  // are co-extensive on the bin axis at any canvas size, and it starts just past
-  // 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: p.screen, orientation: 90,
-    rect: [detX + detW + 8, 0, Math.max(60, CW - (detX + detW + 8) - 8), H],
-    series: 'line', label: 'count by y', refreshMs: 100, color: [24, 32, 46], alpha: 225
-  });
-}

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

@@ -1,136 +0,0 @@
-/* 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 (`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).
- */
-
-// ── TWO SLITS AT THE CANONICAL LEG ───────────────────────────────────────────
-//
-// 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", 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, Tunnel, Wall } from '@descix/frqtl-web/parts';
-
-// 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
-  }],
-  // Barrier segments — opaque destroy sinks, leaving the two slit gaps.
-  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.
-  slit1_channel: [Tunnel, {
-    left: barrierL, top: slit1Top + linerH, length: barrierW, bore: bore,
-    wallThickness: linerH, axis: 'x', mode: 'directed',
-    exitCollapse: true, exitRecenter: true, exitPhaseReset: true,
-    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,
-    color: [80, 140, 220]
-  }],
-  // FAR-EDGE SINK — the same experiment-boundary sink the canonical-leg pair uses.
-  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).
-  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: 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

@@ -1,17 +0,0 @@
-/* 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 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

@@ -1,56 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — 4B · Laser Build-Up
- *
- * 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 (`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).
- */
-
-// LASER BUILD-UP (D4) — the three
-// components of a laser assembled one at a time on top of the earlier Light Lab rungs:
-//   1. a GAIN SOURCE   — the hemisphere emitter (rung 3's omni source, restricted forward)
-//   2. a RESONANT BORE — the directed corridor, which re-aims every wall hit forward
-//   3. an OUTPUT COUPLER — the exit gate, optionally collapsing the mouth to a point and
-//      optionally re-phase-locking what leaves it
-// The two exit flags are INDEPENDENT and both live, which is what lets the rung separate
-// "does the point source matter?" from "does coherence matter?".
-//
-// SINGLE AUTHORITY: the emitter + tunnel configs come from `setupTunnelPointExit.sceneSpec()`
-// — the SAME pure function the standalone `tunnel-point-exit` page's factory consumes. The
-// rung is the addObject form (so STUDIO can select and edit the objects); the page is the
-// slider-driven form. They share the numbers rather than each hand-carrying a copy.
-
-import { SphereEmitter, Tunnel } from '@descix/frqtl-web/parts';
-
-// 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.
-  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.
-  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

@@ -1,60 +0,0 @@
-/* Copyright 2023-2026 by Essam Abadir */
-
-/**
- * SCENE — 1A · Mirror (3D)
- *
- * 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 (`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, Wall } from '@descix/frqtl-web/parts';
-
-// 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
-  }],
-  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,
-    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
-  // beyond the plate's z-band would sail BESIDE the plate — reading as pass-
-  // through from rooftop. Two INVISIBLE full-canvas destroy boundaries flush with
-  // the plate's z-band clamp the scene to the mirror's face: the universe z-edge
-  // moved inward (the sanctioned experiment-boundary sink, same as 2D strays
-  // 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).
-  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);
-}