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

package/dist/frqtl/scenes/laser-buildup.js

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

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

@@ -0,0 +1,56 @@
+/* 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 (`exp.addObject`) and the render intent are all here; the sugar
+ * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
+ * (rung cl1a-mirror-3d).
+ */
+
+import { SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  // Collision Lab 1A · 3D — a collimated LASER (particle-walk pins PURE +x in 2D AND
+  // 3D) into a 3D mirror SLAB (depth → z-slab containing z=0), rendered as a box;
+  // orbit to view. Same LASER tuning as the 2D 1A: single positive
+  // charge, wavelength 1, wavelengthScale 1 (fundamentalWaveLength 4), tiny burst.
+  // FACE-ON default: orientation 0 presents the full
+  // drawn face to the beam → retro-reflection (beam straight back, recolored) — the
+  // one mirror visual that reads correctly from EVERY camera azimuth. (A tilted
+  // default's L-shaped 2th exit is correct optics but its mirror-flipped projection
+  // reads as pass-through from presets that view the xy-plane from behind — measured:
+  // zero leaves ever behind the face; the read was projection handedness, not physics.)
+  // Rotate the orientation slider to steer: 45 -> straight up, 30 -> R(120), etc.
+  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
+  var cy = Math.round(H / 2);
+  var SRC = {
+    preset: 'particle-walk', is2D: false, center: [Math.round(W * 0.15), cy],
+    chargeMode: 'positive', fundamentalDimension: 2, wavelength: 1,
+    fundamentalWaveLength: 4, burstSize: 2, emitEveryTicks: 1
+  };
+  exp.createScene(W, H, 600, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
+  exp.addObject('SphereEmitter', SRC);
+  exp.addObject('Wall', {
+    rect: [Math.round(W * 0.6), Math.round(H * 0.2), 20, Math.round(H * 0.6)],
+    z: -80, depth: 160,
+    collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: 0,
+    name: 'mirror', color: [255, 120, 0], hooks: ['recolor']
+  });
+  // 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).
+  exp.addObject('Wall', { rect: [0, 0, W, H], z: 80, depth: 40,
+    collisionBehavior: 'destroy', name: 'zClipFar', visible: false });
+  exp.addObject('Wall', { rect: [0, 0, W, H], z: -120, depth: 40,
+    collisionBehavior: 'destroy', name: 'zClipNear', visible: false });
+}

package/dist/frqtl/scenes/mirror-route.js

@@ -0,0 +1,140 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — 1D · Mirror Loop (10-mirror {10/3} star)
+ *
+ * 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 cl1d-mirror-route).
+ */
+
+// A CLOSED {10/3} STAR BILLIARD: a 2-particle-wide laser loops
+// m1→m2→…→m10→m1 FOREVER. Ten mirrors at the vertices of a regular decagon; each tilt solved
+// from its in/out chords so the reflected centre-line hits the next mirror, and the star's
+// symmetry closes the tenth leg back into the first. Each mirror tags the beam with its own
+// colour (recolor hook) → the beam re-colours every bounce. No detector: the loop has no exit.
+// The emitter's DECLARED emission gate (emissionCap/gateCounter — the blackbody pattern as
+// captured descriptor DATA) keeps the population bounded so FPS stays healthy, Restart-safe.
+//
+// ONE MODE-AWARE SOURCE. The mode strip selects the RENDERER the host boots
+// (renderState.renderer), and this scene reads it ONCE, before its world: `three` ⇒
+// exp.createScene (a 600x400x600 world), else exp.createCanvas (600x400). The ring geometry,
+// tilts, colours, laser and gate are the SAME in both modes (2D≡3D); `IS3D` guards exactly
+// these deltas:
+//   (a) every mirror is a 3D SLAB — a z-slab centred on the beam plane z=0, rendered as a plate;
+//   (b) the laser is VOLUMETRIC (is2D:false — it braids in y AND z; the slab depth catches the
+//       z-braid; its tilted xy faces reflect by the 2θ law, its near/far z-faces bounce vz);
+//   (c) two invisible destroy z-collimators flush with the slab z-band;
+//   (d) the population counter carries a z-slab covering the WHOLE universe z-band;
+//   (e) MOVE/LOOK camera joysticks (the OMNI_3D pattern).
+// The 3D mode's render intent — god-rays at the sun's settings, computed from the light
+// particles only (godraySource 'leaf'), and the 'table-top' camera — rides the registry mode's
+// renderState (lib/shim/registry/walkthrough.js), whose god-ray VALUES are the sun's, owned by
+// lib/shim/render/sun-look.js.
+
+import { CameraControls, SphereEmitter } from '@descix/frqtl-web/parts';
+import * as FrqtlDisplay from '@descix/frqtl-web/compat/renderer/display-slot.js';
+
+export default function buildExperiment(exp) {
+  // The booted display (the host's renderState.renderer) decides which world this mode makes.
+  var IS3D = FrqtlDisplay.name() === 'three';
+  var W = 600, H = 400, WORLD_D = 600;   // THE WORLD this scene states (its co-init call below)
+  var f = Math.min(W, H) / 600;
+  // R 225·f: adjacent decagon vertices sit 2R·sin18° ≈ 0.618R apart vs slab
+  // height ~110·f, so the mirrors separate with clear gaps. Fit: R + rotated-slab half-diagonal
+  // (≈55·f) stays inside min(W,H)/2 with margin.
+  var CX = Math.round(W / 2), CY = Math.round(H / 2), R = Math.round(225 * f), HOP = 3, ROT = 12;
+  // CAP 6400 / burst 8 (brightness retune): a VERY BRIGHT braid. The cap is
+  // LIVE-controllable off the population counter (select 'population' in Layers → Inspector
+  // 'Population Gate').
+  var SW = Math.max(10, Math.round(14 * f)), SH = Math.max(70, Math.round(110 * f)), CAP = 6400;
+  // SD — the 3D slab z-depth: a 2:1 tile (twice the slab height, z-centred on the beam plane).
+  // The scene z-collimator clamps ALL quanta to this band, so every mirror provably faces every
+  // alive quantum.
+  var SD = 2 * SH;
+  // Each mirror a DIFFERENT colour = its identity (a red→magenta rainbow); the recolor hook
+  // stamps that colour onto every particle it reflects (string_map['render.color']).
+  var PAL = [[255,60,60],[255,140,0],[255,220,0],[150,230,40],[40,210,90],[0,210,190],[0,170,255],[70,90,255],[150,70,235],[235,50,190]];
+  // Hit-order vertices of the {10/3} star (m1..m10 named IN the order the beam visits them).
+  var order = []; for (var k = 0; k < 10; k++) { order.push((k * HOP) % 10); }
+  var D2R = Math.PI / 180;
+  var vpos = function (v) { var a = (v * 36 + ROT) * D2R; return [CX + R * Math.cos(a), CY + R * Math.sin(a)]; };
+  var pos = order.map(vpos);
+  var deg = function (a) { return ((a * 180 / Math.PI) % 360 + 360) % 360; };
+  var angOf = function (p, q) { return deg(Math.atan2(q[1] - p[1], q[0] - p[0])); };
+  // Per-mirror IN-PLANE orientation from the in/out chords: ori = (in+out−180)/2, branch chosen
+  // so the engine reflect law out = 180 + 2·ori − in reproduces the outgoing chord exactly.
+  // Orientation is z-axis rotation, so the 3D slab depth adds NO new angle.
+  var ORI = [];
+  for (var j = 0; j < 10; j++) {
+    var pr = pos[(j + 9) % 10], cu = pos[j], nx = pos[(j + 1) % 10];
+    var inA = angOf(pr, cu), outA = angOf(cu, nx);
+    var o = (((inA + outA - 180) / 2) % 360 + 360) % 360;
+    var op = ((180 + 2 * o - inA) % 360 + 360) % 360;
+    if (Math.abs(((op - outA + 540) % 360) - 180) > 0.5) { o = (o + 90) % 360; }
+    ORI.push(o);
+  }
+  // The NARROW STRAIGHT-WALK laser (the exemplar): the SAME emitter as Rung 1
+  // (Straight Walk) — preset 'particle-walk', every walk-character field INHERITED from the same
+  // factory defaults (chargeMode 'positive', dim 0 = 'light' P=1, fundamentalWaveLength 64 → the
+  // λ16 braided transverse ripple) — with ONLY the deliberate loop deltas: (a) a 2px source line
+  // (emissionBoxSide 2 vs r1's default 10), (b) seated on the m10→m1 leg JUST CLEAR of m10 (70·f
+  // past its vertex > the rotated-slab half-diagonal ≈55·f) and aimed along the leg (the longest
+  // clear throw: leg 1.618R ≈ 364·f), (c) a burst of 8/tick, and (d) the DECLARED emission gate.
+  var pS = pos[9], p0 = pos[0];
+  var dx = p0[0] - pS[0], dy = p0[1] - pS[1], L = Math.hypot(dx, dy), ux = dx / L, uy = dy / L;
+  var emit = [Math.round(pS[0] + 70 * f * ux), Math.round(pS[1] + 70 * f * uy)];
+  // EMISSION-CAP GATE as DECLARED DATA (the blackbody-thermostat pattern):
+  // emissionCap + gateCounter compile at CONSTRUCTION into a host tick-fn reading
+  // Wall.getLiveCount on the background counter named 'population' (placed below — the by-name
+  // reference resolves lazily on the first tick). The closed loop has NO sink, so the gate pauses
+  // emission at the cap and resumes below it: the population plateaus. Restart-safe: codegen
+  // captures the two fields and the rebuilt emitter recompiles the gate (no free recipe tick-fn).
+  // is2D:!IS3D opens activeAxes.z in 3D — the volumetric laser.
+  var SRC = {
+    preset: 'particle-walk', is2D: !IS3D, center: emit, orientationDeg: angOf(pS, p0),
+    emissionBoxSide: 2, burstSize: 8,
+    emissionCap: CAP, gateCounter: 'population'
+  };
+  // THE WORLD — first, then parts: a 3D scene + universe (600x400x600) or a 2D canvas + universe.
+  if (IS3D) { exp.createScene(W, H, WORLD_D, SphereEmitter.worldCfg(SRC)); }
+  else      { exp.createCanvas(W, H, SphereEmitter.worldCfg(SRC)); }
+  exp.addObject('SphereEmitter', SRC);
+  // The ten mirrors at the star vertices — each its own colour + the recolor tag. In 3D each is a
+  // SLAB (z-slab −SD/2..SD/2); in 2D the bag is EMPTY, so the wall is the flat mirror.
+  var ZSLAB = IS3D ? { z: -Math.round(SD / 2), depth: SD } : {};
+  for (var i = 0; i < 10; i++) {
+    var p = pos[i];
+    exp.addObject('Wall', Object.assign(
+      { rect: [Math.round(p[0] - SW / 2), Math.round(p[1] - SH / 2), SW, SH] }, ZSLAB,
+      { collisionBehavior: 'bounce', bounceDirection: 'reflect', orientationDeg: ORI[i],
+        name: 'm' + (i + 1), color: PAL[i], hooks: ['recolor'] }));
+  }
+  if (IS3D) {
+    // SCENE Z-COLLIMATOR (without it the z lets things pass through instead of
+    // reflecting): the legs' z-braid diffuses lap over lap; any quantum beyond the mirrors'
+    // z-band would sail BESIDE a plate on the leg line — reading as a beam passing THROUGH the
+    // mirror. Two INVISIBLE full-canvas destroy boundaries flush with the slab z-band clamp the
+    // scene to the mirror faces (the universe z-edge moved inward — the sanctioned
+    // experiment-boundary sink). 40px deep: un-jumpable (max z step ±2/tick).
+    exp.addObject('Wall', { rect: [0, 0, W, H], z: Math.round(SD / 2), depth: 40,
+      collisionBehavior: 'destroy', name: 'zClipFar', visible: false });
+    exp.addObject('Wall', { rect: [0, 0, W, H], z: -Math.round(SD / 2) - 40, depth: 40,
+      collisionBehavior: 'destroy', name: 'zClipNear', visible: false });
+  }
+  // BACKGROUND POPULATION COUNTER (the canonical objects approach): an INVISIBLE
+  // full-canvas Wall with collisionBehavior 'nothing' + the count hook. Every live leaf inside its
+  // rect collides every tick, so its per-tick collided-frame count (Wall.getLiveCount, bench LO7
+  // mechanics) IS the live population — the ONE 'how many live' authority. In 3D it must contain
+  // EVERY live leaf: the universe z-band is ±half-width (z-strays DIE at it), so its z-slab is ±W
+  // (a strict superset). Counting never moves/kills/recolors a frame: zero physics (SU1).
+  exp.addObject('Wall', Object.assign(
+    { rect: [0, 0, W, H] }, IS3D ? { z: -W, depth: 2 * W } : {},
+    { collisionBehavior: 'nothing', hooks: ['count'], name: 'population', visible: false }));
+  // MOVE/LOOK camera joysticks — the OMNI_3D pattern (3D only).
+  if (IS3D && typeof document !== 'undefined' && exp.runner) {
+    if (exp.runner.controlHost) { CameraControls.attach(exp.runner, exp.runner.controlHost); }
+  }
+}

package/dist/frqtl/scenes/mirror.js

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

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

@@ -0,0 +1,27 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — 7 · 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 (`exp.addObject`) and the render intent are all here; the sugar
+ * objects, renderer and engine are imports. Registered by lib/shim/registry/walkthrough.js
+ * (rung r7-3d).
+ */
+
+// The omni source released into 3D (is2D:false) + the reusable camera joysticks.
+
+import { CameraControls, SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  // is2D:false opens the z-axis: the ball-rejected sampler draws a 3D BALL of
+  // directions (bench S1). three renderer + perspective camera come from renderState.
+  // CameraControls.attach = reusable FAIL-SOFT joystick sugar (no-op in 2D).
+  var SRC = { preset: 'spherical', is2D: false };
+  exp.createScene(600, 400, 600, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
+  exp.addObject('SphereEmitter', SRC);
+  if (typeof document !== 'undefined' && exp.runner) {
+    if (exp.runner.controlHost) { CameraControls.attach(exp.runner, exp.runner.controlHost); }
+  }
+}

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

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

package/dist/frqtl/scenes/self-interference.js

@@ -0,0 +1,39 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — 4 · Self-Interference / 5 · Fountain Pool
+ *
+ * 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
+ * (rungs r4-self-interference, r5-fountain-pool).
+ */
+
+// ── Shared physics recipe SOURCES (ONE authority per physics setup) ──────────
+// The render-variant rungs REFERENCE these consts (never copy-paste) and express
+// ONLY a renderState delta — so a future change to a base tuple flows to its
+// variants automatically (no config mirror).
+// The classic self-interference field (Rung 4). Reused VERBATIM by Rung 5
+// (Fountain Pool) with only a water renderState delta.
+
+import { SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  // The classic self-interference tuple (matches self-interference-preset.png):
+  //   dim 2 (capacity 16) + wavelength 32 -> clamped to 16 -> mass 1 (fullness 1/16);
+  //   fundamentalWaveLength 64 -> wavelengthScale floor(64/4)=16 -> effective lambda 256px;
+  //   chargeMode 'random' -> per-leaf +/- braiding (THE interference);
+  //   emissionShell 'surface' + innerR 16 -> RING launch (empty center, sharp bands);
+  //   burst 72/tick. Red is DERIVED from fullness 1/16 (ROYGBIV low end), not forced.
+  //   Pattern = radial BRAIDED BANDS (not concentric rings).
+  var SRC = {
+    is2D: true, preset: 'spherical',
+    emissionShell: 'surface', innerR: 16,
+    fundamentalDimension: 2, wavelength: 32,
+    chargeMode: 'random', fundamentalWaveLength: 64,
+    burstSize: 72, emitEveryTicks: 1
+  };
+  exp.createCanvas(600, 400, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.addObject('SphereEmitter', SRC);
+}

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

@@ -0,0 +1,122 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — Smoking Gun
+ *
+ * A sketch file: the WHOLE scene as one ES module, `export default function buildExperiment(exp)`. The 3D world, the
+ * muzzle, its wind-down, the bullet and its flight, and the painted gun body are all here; the
+ * sugar objects (SphereEmitter, Wall, LargeObject), the renderer and the engine are imports.
+ * Registered by lib/shim/registry/walkthrough.js (rung smoking-gun); the look and the camera ride
+ * that row's renderState.
+ *
+ * Composition (zero new physics): a 1×10 slit at the muzzle emits at-fundamental leaves with the
+ * particle-walk preset (+X momentum); brownian motion and inter-quantum collisions are on; the
+ * declared dimensions are 4, 8 and 12. The bullet is a Wall{bounce, reflect} cube that a tick-fn
+ * steps +1 px every second tick through Wall.setRect. A second tick-fn ramps the burst from 20 at
+ * tick 180 toward 0 at tick 600 and cuts the muzzle once when it rounds to 0.
+ *
+ * Order (it seeds the run): world → brownian/collision flags → the smoke ladder → the muzzle →
+ * the wind-down tick-fn → the bullet → its flight tick-fn → the gun body.
+ *
+ * Card text (this scene's what / why / how, verbatim; the scene is not on the
+ * showcase roster, lib/shim/registry/exhibits.js, so no front-page tile or GYM card shows it):
+ *   What you are seeing:
+ *     Explore how you can create CGI-like effects out of emergent physics - if you are a ThreeJS
+ *     developer, this is your opportunity to shine! Presently, a gun fires, seen from the side. A
+ *     slit at the muzzle, one pixel wide and ten tall, releases twenty quanta per tick heading down
+ *     the barrel. The bullet is currently a ten-pixel reflecting cube (quanta bounce off it).
+ *   Why it is impossible the usual way:
+ *     Look into how you can use the collisions from the 3D Collisions Lab and the collision
+ *     experiments to make the bullet self-propelled. You'll need an intuitive understanding of what
+ *     the standard collisions in the model end up doing and possibly how Large Objects allow you to
+ *     define your own custom hooks and collision behaviors. The goal is that the collisions of the
+ *     smaller light quanta accumulate into bullet momentum instead of the currently scripted one
+ *     pixel every second tick.
+ *   How FRQTL gets it:
+ *     Currently, the quanta jostle and collide with one another, and they promote into ever larger
+ *     frames, from the fundamental layer through dimensions 4, 8 and 12. That climb is the smoke.
+ *     After three seconds the muzzle winds down, and by ten seconds it is cut, leaving the plume to
+ *     drift and spread on its own. No fluid dynamics, no gas law, no particle system scripted to
+ *     look like smoke.
+ *
+ * Facts to help you out:
+ *   - Muzzle: a 1×10 px slit, particle-walk preset (pure +X), 20 quanta per tick, at-fundamental leaves.
+ *   - Brownian motion and inter-quantum collisions are on. Declared dimensions are 4, 8 and 12 (the
+ *     scene's "smoke ladder": leaves promote 0 → 4 → 8 → 12).
+ *   - The bullet's motion is scripted: a tick function steps it +1 px every second tick. The quanta
+ *     do NOT push it.
+ *   - Bullet: a 10 px cube Wall, collisionBehavior bounce/reflect, so quanta reflect off it.
+ *   - Wind-down: full burst until tick 180, linear fall to zero at tick 600, then the muzzle is cut.
+ *     The rate is capped at 60 ticks per second, so that is 3 s and 10 s.
+ *   - The gun body is a painted shape with no collision, so it has no physical role.
+ *   - Look: side profile (barrel reads left to right), glow 0.6, god rays 0.5 from the fundamental
+ *     layer, heat 0.2, smoke render effect 0. The visible "smoke" is therefore the frames themselves,
+ *     not a render effect.
+ */
+
+import { CameraControls, CollisionTypes, LargeObject, SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  var W = 600, H = 600, D = 600;          // THE WORLD this scene states (its co-init call below)
+  var BURST = 20;                          // quanta per tick at the muzzle, before the wind-down
+  var BULLET_SIDE = 10;                    // the bullet cube's edge = the muzzle slit's height (px)
+  var RAMP_START = 180, RAMP_END = 600;    // the wind-down: full burst until RAMP_START, zero at RAMP_END
+  var GUN_W = 150, GUN_H = 84;             // the painted gun body (px); its right edge is the muzzle
+
+  var MUZZLE_X = Math.floor(W / 2), MUZZLE_Y = Math.floor(H / 2);
+  var SRC = {
+    preset: 'particle-walk', is2D: false,             // pure +X momentum in 2D and 3D
+    center: [MUZZLE_X, MUZZLE_Y, 0],
+    emissionBox: { x: 0, y: BULLET_SIDE, z: 0 },      // the 1×10 slit
+    chargeMode: 'negative', burstSize: BURST, emitEveryTicks: 1,
+    fundamentalDimension: 0, fundamentalWaveLength: 64   // λ scale floor(64/4) = 16
+  };
+
+  // ── WORLD — a 3D scene + universe W×H×D, fundamental layer 0, λ multiplier 16 ──
+  exp.createScene(W, H, D, SphereEmitter.worldCfg(SRC));
+  var u = exp.universe;
+  u.brownianMotion = true;
+  u.withInterQuantumCollisions = true;
+  u.addDimension(4);                       // the smoke ladder: leaves promote 0 → 4 → 8 → 12
+  u.addDimension(8);
+  u.addDimension(12);
+  exp.runner.setRateLimits({ tpsLimit: 60 });   // pacing only: 60 ticks = 1 s of wall-clock
+
+  // ── THE MUZZLE ──
+  var muzzle = exp.addObject('SphereEmitter', SRC);
+
+  // ── THE WIND-DOWN — the burst falls linearly from BURST at RAMP_START to zero at RAMP_END ──
+  // The burst setter's floor is one quantum per tick, so zero is the muzzle's cut, issued once.
+  var rampTick = 0, muzzleCut = false;
+  exp.addTickFunction(function () {
+    rampTick++;
+    if (muzzleCut || rampTick < RAMP_START) { return; }
+    var n = Math.round(BURST * Math.max(0, 1 - (rampTick - RAMP_START) / (RAMP_END - RAMP_START)));
+    if (n >= 1) { muzzle.setBurstSize(n); } else { muzzle.setActive(false); muzzleCut = true; }
+  });
+
+  // ── THE BULLET — a reflecting wall cube at the muzzle, stepped +1 px every second tick ──
+  var bulletLeft = MUZZLE_X, bulletTop = MUZZLE_Y - BULLET_SIDE / 2;
+  var bullet = exp.addObject('Wall', {
+    rect: [bulletLeft, bulletTop, -BULLET_SIDE / 2, BULLET_SIDE, BULLET_SIDE, BULLET_SIDE],
+    collisionBehavior: 'bounce', bounceDirection: 'reflect', shellShape: 'box',
+    color: [235, 205, 150], name: 'bullet'
+  });
+  var flightTick = 0;
+  exp.addTickFunction(function () {
+    flightTick++;
+    if (flightTick % 2 !== 0 || bulletLeft + BULLET_SIDE >= W) { return; }   // stops at the far wall
+    bulletLeft += 1;
+    bullet.setRect([bulletLeft, bulletTop, BULLET_SIDE, BULLET_SIDE]);      // planar: z and depth kept
+  });
+
+  // ── THE GUN BODY — a painted occluder (no collision); the renderer paints the 'gun' hint ──
+  var gun = new LargeObject(u, [MUZZLE_X - GUN_W + 12, MUZZLE_Y - GUN_H / 2, GUN_W, GUN_H],
+                            CollisionTypes.NONE, [], 'gun', 'closest', null, 1, [46, 46, 52]);
+  gun.renderHint = 'gun';
+
+  // ── MOVE/LOOK pads ──
+  if (typeof document !== 'undefined' && exp.runner.controlHost) {
+    CameraControls.attach(exp.runner, exp.runner.controlHost);
+  }
+}

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

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

package/dist/frqtl/scenes/sun.js

@@ -0,0 +1,39 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — 8 · Sun
+ *
+ * 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 r8-sun).
+ */
+
+// The sun — the 3D omni POINT source at the sun.png panel-visible regime
+// (supersedes the bare r-code-a-sun reuse for THIS rung). Panel knobs:
+//   dim 2, virtual mass 16 (mass/cap 16/16, fullness 1 — the density driver, ~25012
+//   activeQuanta) via wavelength arg 1 (mass = max(1, capacity 16 / 1) = 16, verified
+//   vs the factory clamp); λ scale (wavelengthScale) 16 via fundamentalWaveLength 64
+//   (waveLengthMultiplier = max(1, floor(64/4)) = 16 → eff λ (16/16)×16 = 16px); emit
+//   every 1. force-red OFF (no color), water OFF, source-mesh OFF. FX ride the renderState
+//   (values: lib/shim/render/sun-look.js).
+
+import { CameraControls, SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  // Rung 8 (Sun) — the sun.png panel regime: a 3D omni POINT source, virtual mass 16
+  // (fullness 1) via wavelength:1, λ scale 16 via fundamentalWaveLength:64, emit every 1.
+  // The sphere shape + god-rays + glow FX ride the renderState (three-only capabilities).
+  // The sun's yellow is the NATURAL fullness->color (mass=capacity, fullness 1); no forced color.
+  var SRC = {
+    preset: 'spherical', emissionBoxSide: 0, is2D: false,
+    chargeMode: 'random', fundamentalDimension: 2,
+    wavelength: 1, fundamentalWaveLength: 64, emitEveryTicks: 1
+  };
+  exp.createScene(600, 400, 600, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 3D scene + universe, 600x400x600 — first, then parts
+  exp.addObject('SphereEmitter', SRC);
+  if (typeof document !== 'undefined' && exp.runner) {
+    if (exp.runner.controlHost) { CameraControls.attach(exp.runner, exp.runner.controlHost); }
+  }
+}

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

@@ -0,0 +1,37 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — 6A · Two Sources / 6B · Two Fountains / 6C · Plasma Fusion
+ *
+ * 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
+ * (rungs r6a-two-source, r6b-two-fountains, r6c-plasma-fusion).
+ */
+
+// Two self-interference sources ±32px apart (the classic config called TWICE — one
+// world, two parts). Reused VERBATIM by Rung 6B (Two Fountains) + 6C (Plasma Fusion)
+// — render deltas only.
+
+import { SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  // The classic self-interference config called TWICE, centered ±32px from canvas
+  // center (64px apart = 1×fundamentalWaveLength, i.e. λ_eff/4 since λ_eff = 4×fWL).
+  // The world is init'd ONCE, then TWO parts are constructed on it — no flag, no
+  // re-init, no stacking. The
+  // lattice BETWEEN the two visible sources is EMERGENT density superposition (SU1).
+  var W = 600, H = 400;   // THE WORLD this scene states (its co-init call below)
+  var cx = Math.floor(W / 2), cy = Math.floor(H / 2);
+  var CFG = {
+    is2D: true, preset: 'spherical',
+    emissionShell: 'surface', innerR: 16,
+    fundamentalDimension: 2, wavelength: 32,
+    chargeMode: 'random', fundamentalWaveLength: 64,
+    burstSize: 72, emitEveryTicks: 1
+  };
+  exp.createCanvas(W, H, SphereEmitter.worldCfg(CFG));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.addObject('SphereEmitter', Object.assign({}, CFG, { center: [cx - 32, cy] }));
+  exp.addObject('SphereEmitter', Object.assign({}, CFG, { center: [cx + 32, cy] }));
+}

package/dist/frqtl/scenes/wave.js

@@ -0,0 +1,26 @@
+/* Copyright 2023-2026 by Essam Abadir */
+
+/**
+ * SCENE — 2 · Wave
+ *
+ * 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 r2-wave).
+ */
+
+import { SphereEmitter } from '@descix/frqtl-web/parts';
+
+export default function buildExperiment(exp) {
+  // Rung 2 — Rung 1 + raise the leaf dimension to 2 (WAVELENGTH_DEMO_DIMENSION):
+  // wavelength is a NO-OP at dim 0 (capacity=1 saturates mass), so raising the
+  // fundamental gives the wavelength arg leverage. wavelength:8 -> mass 2 ->
+  // transverse period grows from ~16px (Rung 1) to a visible ~128px snake.
+  var SRC = {
+    preset: 'particle-walk', is2D: true,
+    fundamentalDimension: 2, wavelength: 8
+  };
+  exp.createCanvas(600, 400, SphereEmitter.worldCfg(SRC));   // THE WORLD: a 2D canvas + universe — first, then parts
+  exp.addObject('SphereEmitter', SRC);
+}